Google uses AI technology to translate content into your preferred language. AI translations can contain errors.

S'authentifier à l'aide d'OAuth en trois étapes avec le gestionnaire d'authentification

Pour accorder à votre agent l'accès à des outils et services externes (tâches Jira ou dépôts GitHub, par exemple) au nom d'un utilisateur final spécifique, configurez un fournisseur d'authentification OAuth en trois étapes dans le gestionnaire d'authentification des identités d'agent.

Les fournisseurs d'authentification OAuth en trois étapes gèrent la redirection des utilisateurs et les jetons pour vous. Vous n'avez donc pas besoin d'écrire de code personnalisé pour gérer les flux OAuth 2.0 complexes.

Workflow OAuth en trois étapes

Les fournisseurs d'authentification OAuth à trois acteurs nécessitent le consentement de l'utilisateur, car l'agent accède aux ressources au nom de l'utilisateur.

Invite et redirection : l'interface de chat invite l'utilisateur à se connecter, puis le redirige vers la page de consentement de l'application tierce.
Consentement et stockage : une fois que l'utilisateur a accordé l'autorisation, le gestionnaire d'authentification Agent Identity stocke les jetons OAuth obtenus dans un coffre-fort d'identifiants géré par Google.
Injection : lorsque vous utilisez Agent Development Kit (ADK), l'agent récupère automatiquement le jeton auprès du fournisseur d'authentification et l'injecte dans les en-têtes d'appel d'outil.

Avant de commencer

Vérifiez que vous avez choisi la bonne méthode d'authentification.
Activez l'API Agent Identity Connector.
Rôles requis pour activer les API
Pour activer les API, vous devez disposer de l'autorisation serviceusage.services.enable. Si vous avez créé le projet, vous disposez probablement déjà de cette autorisation grâce au rôle Propriétaire (roles/owner). Sinon, vous pouvez obtenir cette autorisation grâce au rôle Administrateur Service Usage (roles/serviceusage.serviceUsageAdmin). Découvrez comment attribuer des rôles.
Activer l'API
Créez et déployez un agent.
Assurez-vous de disposer d'une application frontend pour gérer les invites de connexion des utilisateurs et la redirection vers les pages de consentement tierces.
Vérifiez que vous disposez des rôles requis pour effectuer cette tâche.

Rôles requis

Pour obtenir les autorisations nécessaires pour créer et utiliser un fournisseur d'authentification à trois identifiants, demandez à votre administrateur de vous accorder les rôles IAM suivants sur le projet :

Pour créer des fournisseurs d'authentification :
- Administrateur de connecteurs IAM (roles/iamconnectors.admin)
- Éditeur de connecteurs IAM (roles/iamconnectors.editor)
Pour utiliser les fournisseurs d'authentification :
- Utilisateur de connecteur IAM (roles/iamconnectors.user)
- Utilisateur Vertex AI (roles/aiplatform.user)
- Consommateur Service Usage (roles/serviceusage.serviceUsageConsumer)

Pour en savoir plus sur l'attribution de rôles, consultez Gérer l'accès aux projets, aux dossiers et aux organisations.

Ces rôles prédéfinis contiennent les autorisations requises pour créer et utiliser un fournisseur d'authentification à trois niveaux. Pour connaître les autorisations exactes requises, développez la section Autorisations requises :

Autorisations requises

Les autorisations suivantes sont requises pour créer et utiliser un fournisseur d'authentification à trois niveaux :

Pour créer des fournisseurs d'authentification : iamconnectors.connectors.create
Pour utiliser les fournisseurs d'authentification :
- iamconnectors.connectors.retrieveCredentials
- aiplatform.endpoints.predict
- aiplatform.sessions.create

Vous pouvez également obtenir ces autorisations avec des rôles personnalisés ou d'autres rôles prédéfinis.

Créer un fournisseur d'authentification à trois niveaux

Créez un fournisseur d'authentification pour définir la configuration et les identifiants des applications tierces.

Pour créer un fournisseur d'authentification à trois niveaux, utilisez la console Google Cloud ou la Google Cloud CLI.

Console

Dans la console Google Cloud , accédez à la page Agent Registry.
Accéder au registre d'agents
Cliquez sur le nom de l'agent pour lequel vous souhaitez créer un fournisseur d'authentification.
Cliquez sur Identité.
Dans la section Fournisseurs d'authentification, cliquez sur Ajouter un fournisseur d'authentification.
Dans le volet Ajouter un fournisseur d'authentification, saisissez un nom et une description.

Le nom ne peut contenir que des lettres minuscules, des chiffres ou des traits d'union. Il ne peut pas se terminer par un trait d'union et doit commencer par une lettre minuscule.
Dans la liste Type OAuth, sélectionnez OAuth (3 legs).
Cliquez sur Créer et continuer.
Pour accorder à l'identité de votre agent l'autorisation d'utiliser le fournisseur d'authentification, cliquez sur Accorder l'accès.
Cela attribue automatiquement le rôle Utilisateur du connecteur (roles/iamconnectors.user) à l'identité de l'agent sur la ressource du fournisseur d'authentification.
Copiez l'URL de rappel.
Dans un autre onglet, enregistrez l'URL de rappel dans votre application cliente OAuth tierce.
Dans la section Identifiants du fournisseur d'authentification, saisissez les informations suivantes :
- ID client
- Code secret du client
- URL du jeton
- URL d'autorisation
Cliquez sur Ajouter une configuration de fournisseur.

Le fournisseur d'authentification que vous venez de créer apparaît dans la liste Fournisseurs d'authentification.

gcloud CLI

Configurez votre application cliente OAuth pour enregistrer votre client et obtenir un ID client et un code secret du client. Spécifiez l'URI de redirection à l'aide du modèle de cette section.

Créez le fournisseur d'authentification à l'aide de vos identifiants client :

gcloud alpha agent-identity connectors create AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --three-legged-oauth-client-id="CLIENT_ID" \
    --three-legged-oauth-client-secret="CLIENT_SECRET" \
    --three-legged-oauth-authorization-url="AUTHORIZATION_URL" \
    --three-legged-oauth-token-url="TOKEN_URL"

Vérifiez que votre fournisseur d'authentification apparaît dans la liste et que son état est ENABLED :

gcloud alpha agent-identity connectors list \
   --project="PROJECT_ID" \
   --location="LOCATION"

Accordez des autorisations d'accès pour permettre à votre agent et à votre environnement de développement local de récupérer les identifiants auprès du fournisseur d'authentification. Pour permettre à votre agent déployé et à votre compte utilisateur personnel d'accéder au fournisseur d'authentification, attribuez le rôle Utilisateur du connecteur (roles/iamconnectors.user) à la ressource du fournisseur d'authentification :
1. Accordez l'accès à l'ID SPIFFE de votre agent déployé (identité de l'agent) :
```
gcloud alpha agent-identity connectors add-iam-policy-binding AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --role="roles/iamconnectors.user" \
    --member="principal://agents.global.org-ORGANIZATION_ID.system.id.goog/resources/aiplatform/projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/ENGINE_ID"
```
2. Accordez l'accès à votre compte utilisateur personnel pour le développement et les tests en local (adk web) :
```
gcloud alpha agent-identity connectors add-iam-policy-binding AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --role="roles/iamconnectors.user" \
    --member="user:USER_EMAIL"
```

Remplacez les éléments suivants :

PROJECT_ID : ID de votre projet Google Cloud .
LOCATION : emplacement où votre fournisseur d'authentification et votre agent sont déployés (par exemple, us-west1).
AUTH_PROVIDER_NAME : nom de votre fournisseur d'authentification (par exemple, bigquery-mcp-3lo-authprovider).
AUTHORIZATION_URL : URL du serveur d'autorisation (par exemple, https://accounts.google.com/o/oauth2/v2/auth).
TOKEN_URL : URL du serveur de jetons (par exemple, https://oauth2.googleapis.com/token).
CLIENT_ID : ID client OAuth que vous avez généré à partir du service tiers.
CLIENT_SECRET : code secret du client OAuth que vous avez généré à partir du service tiers.
ORGANIZATION_ID : ID de votre organisation Google Cloud .
PROJECT_NUMBER : numéro de votre projet Google Cloud .
ENGINE_ID : ID de votre agent de moteur de raisonnement déployé.
USER_EMAIL : adresse e-mail de votre compte utilisateur personnel.

Configurer votre application cliente OAuth

Avant d'enregistrer vos identifiants de client OAuth, obtenez un ID client et un code secret du client auprès du serveur d'autorisation tiers (par exemple, Google, GitHub ou Jira).

Si vous vous connectez à un service tiers en dehors deGoogle Cloud, obtenez les identifiants du client OAuth à partir du portail des développeurs de ce service et ignorez les étapes de cette section.

Enregistrer l'URI de redirection

Lorsque vous configurez vos identifiants client OAuth, vous devez enregistrer l'URI de redirection de rappel dédié du fournisseur d'authentification.

Créez l'URI de redirection à l'aide du modèle suivant :

https://iamconnectorcredentials.googleapis.com/v1/projects/PROJECT_ID/locations/LOCATION/connectors/CONNECTOR_NAME/oauthcallback

Remplacez les éléments suivants :
- PROJECT_ID : ID de votre projet Google Cloud .
- LOCATION: The region where your auth provider will be deployed (for example,us-west1`).
- CONNECTOR_NAME : nom de votre fournisseur d'authentification.
Par exemple : https://iamconnectorcredentials.googleapis.com/v1/projects/my-project/locations/us-west1/connectors/bigquery-mcp-3lo-authprovider/oauthcallback
Si vous vous connectez à des services Google Cloud (comme BigQuery), vous pouvez configurer l'écran de consentement et créer des identifiants de client OAuth dans la console Google Cloud :
1. Configurez l'écran de consentement OAuth :
  1. Dans la console Google Cloud , accédez à la page API et services > Écran de consentement OAuth.
    Accédez à API et services > Écran de consentement OAuth.
  2. Dans la section Informations sur l'application, saisissez le nom d'une application (par exemple, "Application BigQuery Manager") et une adresse e-mail d'assistance.
  3. Dans la section Audience, sélectionnez Interne ou Externe.
  4. Saisissez vos coordonnées pour recevoir des notifications.
  5. Lisez et acceptez le Règlement sur les données utilisateur dans les services d'API Google.
  6. Cliquez sur Terminer.
2. Créez vos identifiants client OAuth :
  1. Dans la console Google Cloud , accédez à la page API et services > Écran de consentement OAuth >Clients.
    Accédez à API et services > Écran de consentement OAuth >Clients.
  2. Cliquez sur Créer des identifiants> ID client OAuth.
  3. Sélectionnez l'option Application Web dans la liste.
  4. Saisissez un nom reconnaissable pour votre client OAuth.
  5. Dans la section URI de redirection autorisés, cliquez sur Ajouter un URI et saisissez l'URI de redirection que vous avez créé.
  6. Cliquez sur Créer. Dans la boîte de dialogue Client OAuth créé, copiez les valeurs ID client et Code secret du client générées.

S'authentifier dans le code de votre agent

Pour authentifier votre agent, vous pouvez utiliser l'ADK ou appeler directement l'API Agent Identity.

ADK

Faites référence au fournisseur d'authentification dans le code de votre agent à l'aide de l'ensemble d'outils MCP dans l'ADK.

from google.adk.agents.llm_agent import LlmAgent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider, GcpAuthProviderScheme
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.auth.auth_tool import AuthConfig

# Register the Google Cloud Auth Provider so the CredentialManager can use it.
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is granted and the
# callback is received by the auth provider.
CONTINUE_URI = "https://YOUR_FRONTEND_URL/validateUserId"

# Create the Auth Provider scheme using the auth provider's full resource name.
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/connectors/AUTH_PROVIDER_NAME",
    continue_uri=CONTINUE_URI
)

# Configure an MCP tool with the authentication scheme.
toolset = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url="https://YOUR_MCP_SERVER_URL"),
    auth_scheme=auth_scheme,
)

# Initialize the agent with the authenticated tools.
agent = LlmAgent(
    name="AGENT_NAME",
    model="gemini-2.5-flash",
    instruction="AGENT_INSTRUCTIONS",
    tools=[toolset],
)

Exemple : Se connecter à BigQuery MCP

L'exemple suivant montre une configuration agent.py qui connecte un agent au serveur MCP BigQuery à l'aide d'OAuth à trois identifiants :

import os
from google.adk.agents import Agent
from google.adk.apps import App
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider, GcpAuthProviderScheme
from google.adk.models import Gemini
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
import google.auth
from google.genai import types

_, project_id = google.auth.default()
os.environ["GOOGLE_CLOUD_PROJECT"] = "PROJECT_ID"
os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "True"

bigquery_mcp_auth_provider_id = "AUTH_PROVIDER_NAME"
bigquery_mcp_endpoint = os.environ.get(
    "BIGQUERY_MCP_ENDPOINT", "https://bigquery.googleapis.com/mcp"
)

# Register Google Cloud auth provider for Agent Identity Credentials service
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is granted and the callback is received.
CONTINUE_URI = "http://127.0.0.1:8501/validateUserId"

bigquery_mcp_auth_scheme = GcpAuthProviderScheme(
    name=f"projects/{project_id}/locations/LOCATION/connectors/{bigquery_mcp_auth_provider_id}",
    scopes=["https://www.googleapis.com/auth/bigquery"],
    continue_uri=CONTINUE_URI,
)

bigquery_mcp_tools = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url=bigquery_mcp_endpoint),
    auth_scheme=bigquery_mcp_auth_scheme,
    errlog=None,
)

root_agent = Agent(
    name="root_agent",
    model=Gemini(
        model="gemini-2.5-flash",
        retry_options=types.HttpRetryOptions(attempts=3),
    ),
    instruction=(
        "You are a helpful AI assistant designed to provide accurate and useful"
        " information. You can also use your BigQuery MCP tools to look up"
        " BigQuery data."
    ),
    tools=[bigquery_mcp_tools],
)

app = App(
    root_agent=root_agent,
    name="AGENT_NAME",
)

ADK

Référencez le fournisseur d'authentification dans le code de votre agent à l'aide d'un outil de fonction authentifié dans l'ADK.

import httpx
from google.adk.agents.llm_agent import LlmAgent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider
from google.adk.integrations.agent_identity import GcpAuthProviderScheme
from google.adk.apps import App
from google.adk.auth.auth_credential import AuthCredential
from google.adk.auth.auth_tool import AuthConfig
from google.adk.tools.authenticated_function_tool import AuthenticatedFunctionTool
from vertexai import agent_engines

# First, register Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is completed.
CONTINUE_URI = "WEB_APP_VALIDATE_USER_URI"

# Create Auth Config
spotify_auth_config = AuthConfig(
    auth_scheme=GcpAuthProviderScheme(
        name="projects/PROJECT_ID/locations/LOCATION/connectors/AUTH_PROVIDER_NAME",
        continue_uri=CONTINUE_URI
    )
)

# Use the Auth Config in Authenticated Function Tool
spotify_search_track_tool = AuthenticatedFunctionTool(
    func=spotify_search_track, auth_config=spotify_auth_config
)

# Sample function tool
async def spotify_search_track(credential: AuthCredential, query: str) -> str | list:
    token = None
    if credential.http and credential.http.credentials:
        token = credential.http.credentials.token

    if not token:
        return "Error: No authentication token available."

    async with httpx.AsyncClient() as client:
        response = await client.get(
            "https://api.spotify.com/v1/search",
            headers={"Authorization": f"Bearer {token}"},
            params={"q": query, "type": "track", "limit": 1},
        )
        # Add your own logic here

agent = LlmAgent(
    name="AGENT_NAME",
    model="gemini-2.5-flash",
    instruction="AGENT_INSTRUCTIONS",
    tools=[spotify_search_track_tool],
)

app = App(
    name="APP_NAME",
    root_agent=agent,
)

vertex_app = agent_engines.AdkApp(app_name=app)

ADK

Référencez le fournisseur d'authentification dans le code de votre agent à l'aide de l'ensemble d'outils MCP du registre d'agents dans l'ADK.

from google.adk.agents.llm_agent import LlmAgent
from google.adk.auth.credential_manager import CredentialManager
from google.adk.integrations.agent_identity import GcpAuthProvider
from google.adk.integrations.agent_identity import GcpAuthProviderScheme
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
from google.adk.tools.mcp_tool.mcp_toolset import McpToolset
from google.adk.auth.auth_tool import AuthConfig
from google.adk.integrations.agent_registry import AgentRegistry

# First, register Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is completed.
CONTINUE_URI="WEB_APP_VALIDATE_USER_URI"

# Create Google Cloud auth provider by providing auth provider full resource name
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/connectors/AUTH_PROVIDER_NAME",
    continue_uri=CONTINUE_URI
)

# Set Agent Registry
registry = AgentRegistry(project_id="PROJECT_ID", location="global")

toolset = registry.get_mcp_toolset(
    mcp_server_name="projects/PROJECT_ID/locations/"
    "global/mcpServers/"
    "agentregistry-00000000-0000-0000-0000-000000000000",
    auth_scheme=auth_scheme,
)

# Example MCP tool
toolset = McpToolset(
    connection_params=StreamableHTTPConnectionParams(url="MCP_URL"),
    auth_scheme=auth_scheme,
)

agent = LlmAgent(
    name="AGENT_NAME",
    model="MODEL_NAME",
    instruction="AGENT_INSTRUCTIONS",
    tools=[toolset],
)

Appeler l'API directement

Si vous n'utilisez pas l'ADK, votre agent doit appeler l'API iamconnectorcredentials.retrieveCredentials pour obtenir le jeton.

Comme il s'agit d'un flux OAuth en plusieurs étapes, l'API renvoie une opération de longue durée (LRO). Votre agent doit gérer le cycle de vie de l'opération :

Demande initiale : l'agent appelle retrieveCredentials.
Consentement requis : si l'utilisateur n'a pas donné son consentement, l'API renvoie un LRO dont les métadonnées contiennent auth_uri et consent_nonce.
Redirection du frontend : votre application doit rediriger l'utilisateur vers auth_uri.
Finalisation : une fois que l'utilisateur a donné son consentement, appelez FinalizeCredential à l'aide de consent_nonce pour finaliser le flux et obtenir le jeton.

Mettre à jour votre application côté client

Pour gérer la connexion et la redirection des utilisateurs pour OAuth à trois niveaux, votre application côté client doit implémenter les étapes suivantes pour gérer le consentement de l'utilisateur et reprendre la conversation :

Exemple de serveur d'UI

Vous pouvez télécharger et exécuter un serveur d'interface utilisateur complet qui utilise uvicorn. Avant de commencer, assurez-vous de disposer d'un compte GitHub et d'avoir installé pip.

Pour configurer et exécuter l'exemple de serveur d'UI, procédez comme suit :

Clonez le dépôt GitHub adk-python :

git clone https://github.com/google/adk-python.git

Accédez au dépôt et activez un environnement virtuel Python :

cd adk-python
python3 -m venv .venv
source .venv/bin/activate

Accédez au répertoire client de l'exemple d'UI :

cd contributing/samples/integrations/gcp_auth/client

Installez les dépendances du client :
```
pip install -r requirements.txt
```
Avant de démarrer le serveur, définissez la variable d'environnement AGENT_PROJECT_DIR pour spécifier le répertoire dans lequel se trouve le code de votre agent. Sinon, l'application recherche par défaut les agents dans le dossier parent du répertoire client.

Lancez l'exemple de serveur d'UI à l'aide de uvicorn. Assurez-vous que le port correspond à l'URI de redirection configuré dans votre client OAuth :
```
export AGENT_PROJECT_DIR="/path/to/your/agent_project"
uvicorn main:app --port 8501 --reload
```
Ouvrez http://localhost:8501 dans votre navigateur. (Remarque : Vous devez utiliser localhost et non 127.0.0.1, car l'URL de redirection OAuth nécessite spécifiquement le nom d'hôte localhost.) Spécifiez vos paramètres, cliquez sur Enregistrer et appliquer les paramètres, puis interagissez avec votre agent.

Application d'UI personnalisée

Pour implémenter ces fonctionnalités directement dans une application d'UI personnalisée, procédez comme suit :

Gérer le déclencheur d'autorisation
Implémenter un point de terminaison de validation des utilisateurs
Reprendre la conversation avec l'agent

Gérer le déclencheur d'autorisation

Lorsqu'un agent a besoin du consentement de l'utilisateur, il renvoie un appel de fonction adk_request_credential. Votre application doit intercepter cet appel pour lancer une boîte de dialogue d'autorisation de l'utilisateur ou une redirection.

Gérez le contexte de la session en enregistrant le consent_nonce fourni par le fournisseur d'authentification. Ce nonce est nécessaire pour valider l'utilisateur lors de l'étape de validation. Enregistrez les valeurs auth_config et auth_request_function_call_id dans la session pour faciliter la reprise du flux une fois que l'utilisateur a donné son consentement.

if (fc := get_auth_request_function_call(event_data)):
    print("--> Authentication required by agent.")
    try:
        auth_config = get_auth_config(fc)
        auth_uri, consent_nonce = handle_adk_request_credential(
            auth_config, AUTH_PROVIDER_NAME, request.user_id
        )
        if auth_uri:
            event_data['popup_auth_uri'] = auth_uri
            fc_id = (
                fc.get('id') if isinstance(fc, dict)
                else getattr(fc, 'id', None)
            )
            event_data['auth_request_function_call_id'] = fc_id
            event_data['auth_config'] = auth_config.model_dump()

            # Store session state
            if session_id:
                consent_sessions[session_id] = {
                    "user_id": request.user_id,
                    "consent_nonce": consent_nonce
                }
    except Exception as e:
        print(f"Error handling adk_request_credential: {e}")
        # Optionally, add logic to inform the user about the error.

def handle_adk_request_credential(auth_config, auth_provider_name, user_id):
    ec = auth_config.exchanged_auth_credential
    if ec and ec.oauth2:
        oauth2 = ec.oauth2
        return oauth2.auth_uri, oauth2.nonce
    return None, None

Implémenter un point de terminaison de validation des utilisateurs

Implémentez un point de terminaison de validation sur votre serveur Web (le même URI que celui fourni en tant que continue_uri lors de la configuration). Ce point de terminaison doit effectuer les opérations suivantes :

Recevez user_id_validation_state, auth_provider_name et uuid en tant que paramètres de requête.
Récupérez les valeurs user_id et consent_nonce à partir du stockage de session. Si plusieurs flux d'autorisation s'exécutent simultanément, utilisez uuid pour faire correspondre la bonne session.
Appelez l'API FinalizeCredentials du fournisseur d'authentification avec ces paramètres.
Fermez la fenêtre d'autorisation une fois que vous avez reçu une réponse positive.

Exemple : point de terminaison de validation FastAPI (`main.py`)

L'exemple suivant montre un point de terminaison de validation FastAPI complet qui gère le rappel OAuth et finalise les identifiants utilisateur :

@app.api_route("/validateUserId", methods=["GET"])
async def validate_user(request: Request):
    auth_provider_name = request.query_params.get("auth_provider_name")
    session_id = request.cookies.get("session_id")
    session = consent_sessions.get(session_id, {})

    payload = {
        "userId": session.get("user_id"),
        "userIdValidationState": request.query_params.get(
            "user_id_validation_state"
        ),
        "consentNonce": session.get("consent_nonce"),
    }

    base_url = "https://iamconnectorcredentials.googleapis.com/v1alpha"
    finalize_url = f"{base_url}/{auth_provider_name}/credentials:finalize"

    try:
        async with httpx.AsyncClient(timeout=30.0) as client:
            resp = await client.post(finalize_url, json=payload)
            resp.raise_for_status()
    except httpx.HTTPError as e:
        err_text = e.response.text if hasattr(e, "response") else str(e)
        status = e.response.status_code if hasattr(e, "response") else 500
        return HTMLResponse(err_text, status_code=status)

    return HTMLResponse("""
        <script>
            window.close();
        </script>
        <p>Success. You can close this window.</p>
    """)

Reprendre la conversation avec l'agent

Une fois que l'utilisateur a donné son consentement et que la fenêtre d'autorisation s'est fermée, récupérez les valeurs auth_config et auth_request_function_call_id à partir de vos données de session. Pour poursuivre la conversation, incluez ces informations dans une nouvelle demande à l'agent en tant que function_response.

if (request.is_auth_resume and session.auth_request_function_call_id
    and session.auth_config):
    auth_content = types.Content(
        role='user',
        parts=[
            types.Part(
                function_response=types.FunctionResponse(
                    id=session.auth_request_function_call_id,
                    name='adk_request_credential',
                    response=session.auth_config
                )
            )
        ],
    )
    # Send message to agent
    async for event in agent.async_stream_query(
        user_id=request.user_id,
        message=auth_content,
        session_id=session_id,
    ):
        # ...

Déployer l'agent

Lorsque vous déployez votre agent sur Google Cloud, assurez-vous que l'identité de l'agent est activée.

Si vous déployez sur Agent Runtime sur Gemini Enterprise Agent Platform, utilisez l'indicateur identity_type=AGENT_IDENTITY :

import vertexai
from vertexai import types
from vertexai.agent_engines import AdkApp

# Initialize the Vertex AI client with v1beta1 API for Agent Identity support
client = vertexai.Client(
    project="PROJECT_ID",
    location="LOCATION",
    http_options=dict(api_version="v1beta1")
)

# Use the proper wrapper class for your Agent Framework (e.g., AdkApp)
app = AdkApp(agent=agent)

# Deploy the agent with Agent Identity enabled
remote_app = client.agent_engines.create(
    agent=app,
    config={
        "identity_type": types.IdentityType.AGENT_IDENTITY,
        "requirements": [
            "google-cloud-aiplatform[agent_engines,adk]",
            "google-adk[agent-identity]"
        ],
    },
)