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

Autentica con OAuth de 3 segmentos con el administrador de autenticación

Para otorgar a tu agente acceso a herramientas y servicios externos (como tareas de Jira o repositorios de GitHub) en nombre de un usuario final específico, configura un proveedor de autenticación de OAuth de 3 segmentos en el administrador de autenticación de identidad del agente.

Los proveedores de autorización de OAuth de 3 segmentos administran el redireccionamiento de usuarios y los tokens por ti. Esto elimina la necesidad de escribir código personalizado para controlar flujos complejos de OAuth 2.0.

Flujo de trabajo de OAuth de 3 segmentos

Los proveedores de autenticación de OAuth de 3 segmentos requieren el consentimiento del usuario porque el agente accede a los recursos en nombre del usuario.

Mensaje y redireccionamiento: La interfaz de chat le solicita al usuario que acceda y, luego, lo redirecciona a la página de consentimiento de la aplicación de terceros.
Consentimiento y almacenamiento: Después de que el usuario otorga permiso, el administrador de autenticación de Agent Identity almacena los tokens de OAuth resultantes en una bóveda de credenciales administrada por Google.
Inyección: Cuando usas el Kit de desarrollo de agentes (ADK), el agente recupera automáticamente el token del proveedor de autenticación y lo inyecta en los encabezados de invocación de la herramienta.

Antes de comenzar

Verifica que hayas elegido el método de autenticación correcto.
Habilita la API de Agent Identity Connector.
Roles necesarios para habilitar las APIs
Para habilitar las APIs, necesitas el rol de IAM de administrador de Service Usage (roles/serviceusage.serviceUsageAdmin), que contiene el permiso serviceusage.services.enable. Obtén más información para otorgar roles.
Habilitar la API
Crea e implementa un agente.
Asegúrate de tener una aplicación de frontend para controlar las indicaciones de acceso del usuario y el redireccionamiento a las páginas de consentimiento de terceros.
Verifica que tengas los roles necesarios para completar esta tarea.

Roles obligatorios

Para obtener los permisos que necesitas para crear y usar un proveedor de autenticación de 3 segmentos, pídele a tu administrador que te otorgue los siguientes roles de IAM en el proyecto:

Para crear proveedores de autenticación, haz lo siguiente:
- Administrador del conector de IAM (roles/iamconnectors.admin)
- Editor de conectores de IAM (roles/iamconnectors.editor)
Para usar proveedores de autenticación, haz lo siguiente:
- Usuario del conector de IAM (roles/iamconnectors.user)
- Usuario de Vertex AI (roles/aiplatform.user)
- Consumidor de Service Usage (roles/serviceusage.serviceUsageConsumer)

Para obtener más información sobre cómo otorgar roles, consulta Administra el acceso a proyectos, carpetas y organizaciones.

Estos roles predefinidos contienen los permisos necesarios para crear y usar un proveedor de autenticación de 3 segmentos. Para ver los permisos exactos que son necesarios, expande la sección Permisos requeridos:

Permisos necesarios

Se requieren los siguientes permisos para crear y usar un proveedor de autenticación de 3 segmentos:

Para crear proveedores de autenticación, haz lo siguiente: iamconnectors.connectors.create
Para usar proveedores de autenticación, haz lo siguiente:
- iamconnectors.connectors.retrieveCredentials
- aiplatform.endpoints.predict
- aiplatform.sessions.create

También puedes obtener estos permisos con roles personalizados o con otros roles predefinidos.

Crea un proveedor de autenticación de 3 segmentos

Crea un proveedor de autenticación para definir la configuración y las credenciales de las aplicaciones de terceros.

Para crear un proveedor de autenticación de 3 segmentos, usa la consola de Google Cloud o Google Cloud CLI.

Console

En la consola de Google Cloud , ve a la página Agent Registry.
Ir a Agent Registry
Haz clic en el nombre del agente para el que deseas crear un proveedor de autenticación.
Haz clic en Identidad.
En la sección Proveedores de autenticación, haz clic en Agregar proveedor de autenticación.
En el panel Agregar proveedor de autenticación, ingresa un nombre y una descripción.

El nombre solo puede contener letras minúsculas, números o guiones, no puede terminar con un guion y debe comenzar con una letra minúscula.
En la lista OAuth Type, selecciona OAuth (3 legged).
Haz clic en Crear y continuar.
Para otorgar permiso a la identidad de tu agente para usar el proveedor de autenticación, haz clic en Otorgar acceso.
Esto asigna automáticamente el rol de Usuario del conector (roles/iamconnectors.user) a la identidad del agente en el recurso del proveedor de autenticación.
Copia la URL de devolución de llamada.
En otra pestaña, registra la URL de devolución de llamada en tu aplicación cliente de OAuth externa.
En la sección Credenciales del proveedor de autenticación, ingresa la siguiente información:
- Client ID (ID de cliente)
- Client Secret (Secreto del cliente)
- URL del token
- URL de autorización
Haz clic en Agregar configuración del proveedor.

El proveedor de autenticación recién creado aparecerá en la lista Auth Providers.

gcloud CLI

Configura tu aplicación cliente de OAuth para registrar tu cliente y obtener un ID de cliente y un secreto del cliente. Especifica el URI de redireccionamiento con la plantilla de esa sección.

Crea el proveedor de autenticación con tus credenciales de cliente:

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"

Verifica que tu proveedor de autorización aparezca en la lista y que su estado sea ENABLED:

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

Otorga permisos de acceso para permitir que tu agente y el entorno de desarrollo local recuperen credenciales del proveedor de autenticación. Para permitir que tu agente implementado y tu cuenta de usuario personal accedan al proveedor de autenticación, otorga el rol de Usuario del conector (roles/iamconnectors.user) en el recurso del proveedor de autenticación:

Otorga acceso al ID de SPIFFE de tu agente implementado (identidad del agente):

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"

Otorga acceso a tu cuenta de usuario personal para el desarrollo y las pruebas locales (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"

Reemplaza lo siguiente:

PROJECT_ID: Es el ID del proyecto de Google Cloud .
LOCATION: Es la ubicación en la que se implementan tu proveedor de autenticación y tu agente (por ejemplo, us-west1).
AUTH_PROVIDER_NAME: Es el nombre de tu proveedor de autenticación (por ejemplo, bigquery-mcp-3lo-authprovider).
AUTHORIZATION_URL: Es la URL del servidor de autorización (por ejemplo, https://accounts.google.com/o/oauth2/v2/auth).
TOKEN_URL: Es la URL del servidor de tokens (por ejemplo, https://oauth2.googleapis.com/token).
CLIENT_ID: Es el ID de cliente de OAuth que generaste desde el servicio de terceros.
CLIENT_SECRET: Es el secreto del cliente de OAuth que generaste desde el servicio de terceros.
ORGANIZATION_ID: Es el ID de tu organización Google Cloud .
PROJECT_NUMBER: Es el número de tu proyecto de Google Cloud .
ENGINE_ID: Es el ID del agente del motor de razonamiento implementado.
USER_EMAIL: Es la dirección de correo electrónico de tu cuenta de usuario personal.

Configura tu aplicación cliente de OAuth

Antes de registrar tus credenciales de cliente de OAuth, obtén un ID de cliente y un secreto del cliente del servidor de autorización de terceros (por ejemplo, Google, GitHub o Jira).

Si te conectas a un servicio de terceros fuera deGoogle Cloud, obtén las credenciales del cliente de OAuth en el portal para desarrolladores de ese servicio y omite los pasos de esta sección.

Registra el URI de redireccionamiento

Cuando configures tus credenciales de cliente de OAuth, debes registrar el URI de redireccionamiento de devolución de llamada dedicado del proveedor de autenticación.

Construye el URI de redireccionamiento con la siguiente plantilla:

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

Reemplaza lo siguiente:
- PROJECT_ID: Es el ID del proyecto de Google Cloud .
- LOCATION: The region where your auth provider will be deployed (for example,us-west1`).
- CONNECTOR_NAME: Es el nombre de tu proveedor de autenticación.
Por ejemplo: https://iamconnectorcredentials.googleapis.com/v1/projects/my-project/locations/us-west1/connectors/bigquery-mcp-3lo-authprovider/oauthcallback
Si te conectas a servicios de Google Cloud (como BigQuery), puedes configurar la pantalla de consentimiento y crear credenciales de cliente de OAuth en la consola de Google Cloud :
1. Configura la pantalla de consentimiento de OAuth:
  1. En la consola de Google Cloud , ve a la página APIs y servicios >Pantalla de consentimiento de OAuth.
    Ir a API y servicios >Pantalla de consentimiento de OAuth
  2. En la sección Información de la app, ingresa el nombre de la aplicación (por ejemplo, Aplicación de BigQuery Manager) y un correo electrónico de asistencia.
  3. En la sección Público, selecciona Interno o Externo.
  4. Ingresa tu información de contacto para recibir notificaciones.
  5. Lee y acepta la Política de Datos del Usuario de los Servicios de las APIs de Google.
  6. Haz clic en Finalizar.
2. Crea tus credenciales de cliente de OAuth:
  1. En la consola de Google Cloud , ve a la página APIs y servicios >Pantalla de consentimiento de OAuth >Clientes.
    Ve a APIs y servicios >Pantalla de consentimiento de OAuth >Clientes.
  2. Haz clic en Crear credenciales >ID de cliente de OAuth.
  3. Selecciona la opción Aplicación web de la lista.
  4. Ingresa un nombre reconocible para tu cliente de OAuth.
  5. En la sección URI de redireccionamiento autorizados, haz clic en Agregar URI y, luego, ingresa el URI de redireccionamiento que creaste.
  6. Haz clic en Crear. En el diálogo Cliente de OAuth creado, copia los valores generados de ID de cliente y Secreto de cliente.

Autentícate en el código del agente

Para autenticar tu agente, puedes usar el ADK o llamar directamente a la API de Agent Identity.

ADK

Haz referencia al proveedor de autenticación en el código de tu agente con el conjunto de herramientas del MCP en el 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],
)

Ejemplo: Conexión a BigQuery MCP

En el siguiente ejemplo, se muestra una configuración de agent.py que conecta un agente al servidor del MCP de BigQuery con OAuth de 3 segmentos:

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

Haz referencia al proveedor de autenticación en el código de tu agente con una herramienta de función autenticada en el 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

Haz referencia al proveedor de autenticación en el código de tu agente con el conjunto de herramientas del MCP de Agent Registry en el 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],
)

Llama a la API directamente

Si no usas el ADK, tu agente debe llamar a la API de iamconnectorcredentials.retrieveCredentials para obtener el token.

Dado que se trata de un flujo de OAuth de varios pasos, la API devuelve una operación de larga duración (LRO). Tu agente debe controlar el ciclo de vida de la operación:

Solicitud inicial: El agente llama a retrieveCredentials.
Se requiere consentimiento: Si el usuario no otorgó su consentimiento, la API devuelve un LRO en el que los metadatos contienen el objeto auth_uri y un objeto consent_nonce.
Redireccionamiento de frontend: Tu aplicación debe redireccionar al usuario a auth_uri.
Finalización: Después de que el usuario otorga su consentimiento, llama a FinalizeCredential con consent_nonce para completar el flujo y obtener el token.

Actualiza tu aplicación del cliente

Para controlar el acceso y el redireccionamiento del usuario para OAuth de 3 segmentos, tu aplicación del cliente debe implementar los siguientes pasos para administrar el consentimiento del usuario y reanudar la conversación:

Servidor de IU de muestra

Puedes descargar y ejecutar un servidor de IU de muestra completo que use uvicorn. Antes de comenzar, asegúrate de tener una cuenta de GitHub y pip instalado.

Para configurar y ejecutar el servidor de IU de muestra, haz lo siguiente:

Clona el repositorio de GitHub adk-python:

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

Navega al repositorio y activa un entorno virtual de Python:

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

Navega al directorio del cliente de la IU de muestra:

cd contributing/samples/integrations/gcp_auth/client

Instala las dependencias del cliente:
```
pip install -r requirements.txt
```
Antes de iniciar el servidor, configura la variable de entorno AGENT_PROJECT_DIR para especificar el directorio en el que se encuentra el código del agente. De lo contrario, la aplicación buscará agentes de forma predeterminada en la carpeta principal del directorio del cliente.

Inicia el servidor de la IU de muestra con uvicorn. Asegúrate de que el puerto coincida con el URI de redireccionamiento configurado en tu cliente de OAuth:
```
export AGENT_PROJECT_DIR="/path/to/your/agent_project"
uvicorn main:app --port 8501 --reload
```
Abre http://localhost:8501 en tu navegador. (Nota: Debes usar localhost y no 127.0.0.1, ya que la URL de redireccionamiento de OAuth lo requiere específicamente). Especifica la configuración, haz clic en Guardar y aplicar la configuración y, luego, interactúa con tu agente.

Aplicación de IU personalizada

Para implementar estas capacidades directamente en una aplicación de IU personalizada, sigue estos pasos:

Controla el activador de autorización
Implementa un extremo de validación de usuarios
Reanuda la conversación con el agente

Controla el activador de autorización

Cuando un agente necesita el consentimiento del usuario, devuelve una llamada a la función adk_request_credential. Tu aplicación debe interceptar esta llamada para iniciar un diálogo o redireccionamiento de autorización del usuario.

Administra el contexto de la sesión registrando el consent_nonce que proporciona el proveedor de autenticación. Este nonce es obligatorio para verificar al usuario durante el paso de validación. Guarda los valores de auth_config y auth_request_function_call_id dentro de la sesión para facilitar la reanudación del flujo después de que el usuario otorgue el consentimiento.

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

Implementa un extremo de validación de usuarios

Implementa un extremo de validación en tu servidor web (el mismo URI proporcionado como continue_uri durante la configuración). Este extremo debe hacer lo siguiente:

Recibe user_id_validation_state y auth_provider_name como parámetros de consulta.
Recupera los valores de user_id y consent_nonce del contexto de la sesión.
Llama a la API de FinalizeCredentials del proveedor de autorización con estos parámetros.
Cierra la ventana de autorización cuando recibas una respuesta de éxito.

Ejemplo: Endpoint de validación de FastAPI (`main.py`)

En el siguiente ejemplo, se muestra un extremo de validación de FastAPI completo que controla la devolución de llamada de OAuth y finaliza las credenciales del usuario:

@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>
    """)

Reanuda la conversación con el agente

Después de que el usuario otorga su consentimiento y se cierra la ventana de autorización, recupera los valores de auth_config y auth_request_function_call_id de los datos de tu sesión. Para continuar la conversación, incluye estos detalles en una nueva solicitud al agente como un 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,
    ):
        # ...

Implementa el agente

Cuando implementes tu agente en Google Cloud, asegúrate de que la identidad del agente esté habilitada.

Si implementas en Agent Runtime en Gemini Enterprise Agent Platform, usa la marca 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]"
        ],
    },
)