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

Autenticarsi utilizzando OAuth a tre vie con Auth Manager

Per concedere al tuo agente l'accesso a strumenti e servizi esterni (ad esempio attività Jira o repository GitHub) per conto di un utente finale specifico, configura un provider di autenticazione OAuth a tre vie nel gestore di autenticazione di Agent Identity.

Gestendo le credenziali e i token, i provider di autenticazione OAuth a tre vie eliminano la necessità di codice personalizzato per gestire i flussi di autenticazione.

Flusso di lavoro OAuth a tre vie

I provider di autenticazione OAuth a tre vie richiedono il consenso dell'utente perché l'agente accede alle risorse per suo conto.

Prompt e reindirizzamento: l'interfaccia di chat chiede all'utente di accedere e lo reindirizza alla pagina di consenso dell'applicazione di terze parti.
Consenso e archiviazione: dopo che l'utente ha concesso l'autorizzazione, il gestore di autenticazione di Agent Identity archivia i token OAuth risultanti in un vault di credenziali gestito da Google.
Inserimento: quando utilizzi Agent Development Kit (ADK), l'agente recupera automaticamente il token dal provider di autenticazione e lo inserisce nelle intestazioni di chiamata dello strumento.

Prima di iniziare

Verifica di aver scelto il metodo di autenticazione corretto.
Abilita l'API Agent Identity.
Ruoli necessari per abilitare le API
Per abilitare le API, devi disporre del ruolo IAM Amministratore Service Usage (roles/serviceusage.serviceUsageAdmin), che contiene l'autorizzazione serviceusage.services.enable. Scopri come concedere i ruoli.
Abilitare l'API
Crea ed esegui il deployment di un agente.
Assicurati di avere un'applicazione frontend per gestire i prompt di accesso degli utenti e il reindirizzamento alle pagine di consenso di terze parti.
Verifica di disporre dei ruoli necessari per completare questa attività.

Ruoli obbligatori

Per ottenere le autorizzazioni necessarie per creare e utilizzare un provider di autenticazione a tre vie, chiedi all'amministratore di concederti i seguenti ruoli IAM per il progetto:

Per creare provider di autenticazione:
- Amministratore Agent Identity (roles/agentidentity.admin)
- Editor Agent Identity (roles/agentidentity.editor)
Per utilizzare i provider di autenticazione:
- Utente Agent Identity (roles/agentidentity.user)
- Utente Vertex AI (roles/aiplatform.user)
- Consumer Service Usage (roles/serviceusage.serviceUsageConsumer)

Per saperne di più sulla concessione dei ruoli, consulta Gestisci l'accesso a progetti, cartelle e organizzazioni.

Questi ruoli predefiniti contengono le autorizzazioni necessarie per creare e utilizzare un provider di autenticazione a tre vie. Per vedere quali sono esattamente le autorizzazioni richieste, espandi la sezione Autorizzazioni obbligatorie:

Autorizzazioni obbligatorie

Per creare e utilizzare un provider di autenticazione a tre vie sono necessarie le seguenti autorizzazioni:

Per creare provider di autenticazione: agentidentity.authProviders.create
Per utilizzare i provider di autenticazione:
- agentidentity.authProviders.retrieveCredentials
- aiplatform.endpoints.predict
- aiplatform.sessions.create

Potresti anche ottenere queste autorizzazioni con ruoli personalizzati o altri ruoli predefiniti.

Creare un provider di autenticazione a tre vie

Crea un provider di autenticazione per definire la configurazione e le credenziali per le applicazioni di terze parti.

Per creare un provider di autenticazione a tre vie, utilizza gcloud CLI:

Configura l'applicazione client OAuth per registrare il client e ottenere un ID client e un client secret. Specifica l'URI di reindirizzamento utilizzando il modello in quella sezione.

Crea il provider di autenticazione utilizzando le credenziali client:

gcloud alpha agent-identity authProviders 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 che il provider di autenticazione sia visualizzato nell'elenco e che il suo stato sia ENABLED:

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

Concedi le autorizzazioni di accesso per consentire al tuo agente e all'ambiente di sviluppo locale di recuperare le credenziali dal provider di autenticazione. Per consentire all'agente di cui hai eseguito il deployment e al tuo account utente personale di accedere al provider di autenticazione, concedi il ruolo Utente Agent Identity (roles/agentidentity.user) alla risorsa del provider di autenticazione:

Concedi l'accesso all'ID SPIFFE dell'agente di cui hai eseguito il deployment (Agent Identity):

gcloud alpha agent-identity authProviders add-iam-policy-binding AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --role="roles/agentidentity.user" \
    --member="principal://agents.global.org-ORGANIZATION_ID.system.id.goog/resources/aiplatform/projects/PROJECT_NUMBER/locations/LOCATION/reasoningEngines/ENGINE_ID"

Concedi l'accesso al tuo account utente personale per lo sviluppo e il test locali (adk web):

gcloud alpha agent-identity authProviders add-iam-policy-binding AUTH_PROVIDER_NAME \
    --project="PROJECT_ID" \
    --location="LOCATION" \
    --role="roles/agentidentity.user" \
    --member="user:USER_EMAIL"

Sostituisci quanto segue:

PROJECT_ID: l' Google Cloud ID progetto.
LOCATION: la località in cui sono stati eseguiti il deployment del provider di autenticazione e dell'agente (ad esempio us-west1).
AUTH_PROVIDER_NAME: il nome del provider di autenticazione (ad esempio bigquery-mcp-3lo-authprovider).
AUTHORIZATION_URL: l'URL del server di autorizzazione (ad esempio https://accounts.google.com/o/oauth2/v2/auth).
TOKEN_URL: l'URL del server di token (ad esempio https://oauth2.googleapis.com/token).
CLIENT_ID: l'ID client OAuth generato dal servizio di terze parti.
CLIENT_SECRET: il client secret OAuth generato dal servizio di terze parti.
ORGANIZATION_ID: l' Google Cloud ID organizzazione.
PROJECT_NUMBER: il Google Cloud numero del progetto.
ENGINE_ID: l'ID dell'agente del motore di ragionamento di cui hai eseguito il deployment.
USER_EMAIL: l'indirizzo email del tuo account utente personale.

Configurare l'applicazione client OAuth

Prima di registrare le credenziali client OAuth, ottieni un ID client e un client secret dal server di autorizzazione di terze parti (ad esempio Google, GitHub o Jira).

Se ti connetti a un servizio di terze parti al di fuori di Google Cloud, ottieni le credenziali client OAuth dal portale per sviluppatori di tale servizio e salta i passaggi di questa sezione.

Registrare l'URI di reindirizzamento

Quando configuri le credenziali client OAuth, devi registrare l'URI di reindirizzamento di callback dedicato del provider di autenticazione.

Crea l'URI di reindirizzamento utilizzando il seguente modello:

https://agentidentitycredentials.googleapis.com/v1alpha/projects/PROJECT_ID/locations/LOCATION/authProviders/AUTH_PROVIDER_NAME/oauthcallback

Sostituisci quanto segue:
- PROJECT_ID: l' Google Cloud ID progetto.
- LOCATION: la regione in cui verrà eseguito il deployment del provider di autenticazione (ad esempio us-west1).
- AUTH_PROVIDER_NAME: il nome del provider di autenticazione.
Ad esempio: https://agentidentitycredentials.googleapis.com/v1alpha/projects/my-project/locations/us-west1/authProviders/bigquery-mcp-3lo-authprovider/oauthcallback
Se ti connetti a Google Cloud servizi (ad esempio BigQuery), puoi configurare la schermata per il consenso e creare le credenziali client OAuth nella Google Cloud console:
1. Configura la schermata per il consenso OAuth:
  1. Nella Google Cloud console, vai alla pagina API e servizi >Schermata per il consenso OAuth.
    Vai ad API e servizi >Schermata per il consenso OAuth
  2. Nella sezione Informazioni sull'app, inserisci un nome dell'applicazione (ad esempio Applicazione di gestione di BigQuery) e un'email di assistenza.
  3. Nella sezione Segmento di pubblico, seleziona Interno o Esterno.
  4. Inserisci i tuoi dati di contatto per ricevere le notifiche.
  5. Leggi e accetta le Norme relative ai dati utente: servizi API di Google Policy.
  6. Fai clic su Fine.
2. Crea le credenziali client OAuth:
  1. Nella Google Cloud console, vai alla pagina API e servizi > Schermata per il consenso OAuth > Client.
    Vai ad API e servizi >Schermata per il consenso OAuth >Client
  2. Fai clic su Crea credenziali >ID client OAuth.
  3. Seleziona l'opzione Applicazione web dall'elenco.
  4. Inserisci un nome riconoscibile per il client OAuth.
  5. Nella sezione URI di reindirizzamento autorizzati, fai clic Aggiungi URI e inserisci l'URI di reindirizzamento creato.
  6. Fai clic su Crea. Nella finestra di dialogo Client OAuth creato, copia i valori ID client e Client Secret generati.

Autenticarsi nel codice dell'agente

Per autenticare l'agente, puoi utilizzare ADK o chiamare direttamente l'API Agent Identity.

ADK

Fai riferimento al provider di autenticazione nel codice dell'agente utilizzando il set di strumenti MCP in 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 Google Cloud auth provider
CredentialManager.register_auth_provider(GcpAuthProvider())

# The URI to redirect the user to after consent is granted.
CONTINUE_URI = "https://YOUR_FRONTEND_URL/validateUserId"

# Create auth provider scheme
# Note: If using the legacy V1 API, the resource name uses 'connectors'
# instead of 'authProviders': projects/.../connectors/...
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/authProviders/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],
)

Esempio: connessione a BigQuery MCP

L'esempio seguente mostra una configurazione agent.py che connette un agente al server BigQuery MCP:

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
CredentialManager.register_auth_provider(GcpAuthProvider())

# URI to redirect user to after consent is granted.
CONTINUE_URI = "http://127.0.0.1:8501/validateUserId"

bigquery_mcp_auth_scheme = GcpAuthProviderScheme(
    name=f"projects/{project_id}/locations/LOCATION/authProviders/{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

Fai riferimento al provider di autenticazione nel codice dell'agente utilizzando uno strumento di funzione autenticato in 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/authProviders/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

Fai riferimento al provider di autenticazione nel codice dell'agente utilizzando il set di strumenti MCP del registro degli agenti in 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 scheme
auth_scheme = GcpAuthProviderScheme(
    name="projects/PROJECT_ID/locations/LOCATION/authProviders/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],
)

Chiamare direttamente l'API

Se non utilizzi ADK, l'agente deve chiamare l'API agentidentitycredentials.retrieveCredentials per ottenere il token.

Poiché si tratta di un flusso OAuth in più passaggi, l'agente deve gestire il ciclo di vita dell'operazione:

Richiesta iniziale: l'agente chiama retrieveCredentials.
Consenso richiesto: se l'utente non ha concesso il consenso, l'API restituisce una risposta contenente il risultato come uri_consent_required. Questo conterrà authorization_uri e un consent_nonce.
Reindirizzamento frontend: l'applicazione deve reindirizzare l'utente a authorization_uri.
Completamento: dopo che l'utente ha concesso il consenso, chiama FinalizeCredentials utilizzando consent_nonce per completare il flusso e ottenere il token.

Aggiornare l'applicazione lato client

Per gestire l'accesso e il reindirizzamento degli utenti per OAuth a tre vie, l'applicazione lato client deve implementare i seguenti passaggi per gestire il consenso dell'utente e riprendere la conversazione:

Server UI di esempio

Puoi scaricare ed eseguire un server UI di esempio completo che utilizza uvicorn. Prima di iniziare, assicurati di avere un account GitHub account e pip installato.

Per configurare ed eseguire il server UI di esempio:

Clona il repository GitHub adk-python:

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

Vai al repository e attiva un ambiente virtuale Python:

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

Vai alla directory client dell'interfaccia utente di esempio:
```
cd contributing/samples/integrations/gcp_auth/client
```
Installa le dipendenze del client:
```
pip install -r requirements.txt
```
Prima di avviare il server, imposta la variabile di ambiente AGENT_PROJECT_DIR per specificare la directory in cui si trova il codice dell'agente. In caso contrario, l'applicazione cerca gli agenti nella cartella principale della directory client.

Avvia il server UI di esempio utilizzando uvicorn. Assicurati che la porta corrisponda all'URI di reindirizzamento configurato nel client OAuth:
```
export AGENT_PROJECT_DIR="/path/to/your/agent_project"
uvicorn main:app --port 8501 --reload
```
Apri http://localhost:8501 nel browser. (Nota: devi utilizzare localhost e non 127.0.0.1, perché l'URL di reindirizzamento OAuth richiede specificamente il nome host localhost.) Specifica le impostazioni, fai clic su Salva e applica impostazioni e poi interagisci con l'agente.

Applicazione UI personalizzata

Per implementare queste funzionalità direttamente in un'applicazione UI personalizzata, segui questi passaggi:

Gestire il trigger di autorizzazione
Implementare un endpoint di convalida utente
Riprendere la conversazione dell'agente

Gestire il trigger di autorizzazione

Quando un agente ha bisogno del consenso dell'utente, restituisce una chiamata di funzione adk_request_credential. L'applicazione deve intercettare questa chiamata per avviare una finestra di dialogo o un reindirizzamento di autorizzazione utente.

Gestisci il contesto della sessione registrando consent_nonce fornito dal provider di autenticazione. Questo nonce è necessario per verificare l'utente durante il passaggio di convalida. Salva i valori auth_config e auth_request_function_call_id all'interno della sessione per facilitare la ripresa del flusso dopo che l'utente ha concesso il consenso.

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

Implementare un endpoint di convalida utente

Implementa un endpoint di convalida sul tuo server web (lo stesso URI fornito come continue_uri durante la configurazione). Questo endpoint deve:

Ricevere user_id_validation_state, auth_provider_name, e uuid come parametri di ricerca.
Recuperare i valori user_id e consent_nonce dall'archiviazione della sessione. Se vengono eseguiti più flussi di autorizzazione contemporaneamente, utilizza il uuid per trovare la sessione corretta.
Chiama l'API FinalizeCredentials del provider di autenticazione con questi parametri.
Chiudi la finestra di autorizzazione dopo aver ricevuto una risposta di successo.

Esempio: endpoint di convalida FastAPI (`main.py`)

L'esempio seguente mostra un endpoint di convalida FastAPI completo che gestisce il callback OAuth e finalizza le credenziali utente:

@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://agentidentitycredentials.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>
    """)

Riprendere la conversazione dell'agente

Dopo che l'utente ha concesso il consenso e la finestra di autorizzazione si è chiusa, recupera i valori auth_config e auth_request_function_call_id dai dati della sessione. Per continuare la conversazione, includi questi dettagli in una nuova richiesta all'agente come 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,
    ):
        # ...

Eseguire il deployment dell'agente

Quando esegui il deployment dell'agente in Google Cloud, assicurati che Agent Identity sia abilitato.

Se esegui il deployment in Agent Runtime su Gemini Enterprise Agent Platform , utilizza il identity_type=AGENT_IDENTITY flag:

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]"
        ],
    },
)