Google

Google provides two SDKs relevant for tracing. Choose based on what you’re building:

SDK	Use case	Integration
Google ADK	Full agent framework (multi-agent, tools, sessions)	`AgentXADKPlugin`
Google Gen AI	Raw Gemini API calls (`generate_content`)	`patch_genai_client`

Google ADK

Install:

pip install "agentx-python[google-adk]" google-adk

Register AgentXADKPlugin in the plugins list when constructing the ADK Runner. Every subsequent runner.run() call is traced automatically.

import os
from agentx import AgentX
from agentx.integrations.google_adk import AgentXADKPlugin
from google.adk.agents import Agent
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
from google.adk.tools import FunctionTool
from google.genai import types

os.environ["GEMINI_API_KEY"] = "xxxxxxxxxxxxxxxxxxxx"

client = AgentX.from_env()  # AGENTX_API_KEY (+ AGENTX_API_BASE_URL for self-host)

def get_policy(topic: str) -> dict:
    """Return the company policy for a given topic."""
    db = {
        "cancel": "Go to Account → Subscription → Cancel.",
        "trial": "14-day free trial, no credit card required.",
        "refund": "Full refund within 30 days.",
    }
    return {"result": db.get(topic.lower(), "No policy found.")}


agent = Agent(
    name="support_agent",
    instruction="You are a helpful support agent. Use get_policy to look up policies.",
    tools=[FunctionTool(func=get_policy)],
)

runner = Runner(
    agent=agent,
    app_name="support-app",
    session_service=InMemorySessionService(),
    plugins=[
        AgentXADKPlugin(
            tracer=client.tracer,
            name="support-agent",
            metadata={"env": "production"},
        )
    ],
)

session = runner.session_service.create_session_sync(
    app_name="support-app", user_id="user-1"
)
for event in runner.run(
    user_id="user-1",
    session_id=session.id,
    new_message=types.Content(
        role="user", parts=[types.Part(text="How do I cancel my subscription?")]
    ),
):
    if event.is_final_response():
        print(event.content.parts[0].text)

client.tracer.flush(timeout=10)

What gets traced

Field	Source
`input`	User message text from `on_user_message_callback`
`output`	Last model reply text from `after_model_callback`
`latencyMs`	Wall-clock time from `before_run_callback` to `after_run_callback`
`model`	`llm_request.model` from `before_model_callback`
`toolCalls`	Each `after_tool_callback`: `name`, `input`, `output`, `latencyMs`
`inputTokens` / `outputTokens`	Summed from each model call’s `usage_metadata` (`prompt_token_count` / `candidates_token_count`)
`framework`	Stamped `google-adk` automatically - the platform label on the framework filter and Monitor’s Platforms chart
`error`	`on_model_error_callback` (a failed model call) or `on_tool_error_callback` (a failed tool call)

Each model call and tool call also becomes its own real child span with per-call timing, so the trace dialog’s Timeline shows the invocation’s actual step sequence.

`AgentXADKPlugin` reference

AgentXADKPlugin(
    tracer: Tracer,
    name: str = "google-adk-agent",
    metadata: dict | None = None,
    session_id: str | None = None,
)

Parameter	Description
`tracer`	`client.tracer` from your `AgentX` instance
`name`	Fallback label when the agent has no name set
`metadata`	Static key-value metadata attached to every trace
`session_id`	Links traces from the same conversation thread

Google Gen AI (raw Gemini API)

Install:

pip install "agentx-python[google-genai]" google-genai

Call patch_genai_client() once after creating your genai.Client. All subsequent client.models.generate_content() calls are traced automatically. Works with the async client too - pass client.aio instead of client to trace await client.aio.models.generate_content(...) and async for chunk in await client.aio.models.generate_content_stream(...) calls.

import os
from agentx import AgentX
from agentx.integrations.google_genai import patch_genai_client
from google import genai
from google.genai import types

client = AgentX.from_env()  # AGENTX_API_KEY (+ AGENTX_API_BASE_URL for self-host)

genai_client = genai.Client(api_key="GEMINI_API_KEY")

patch_genai_client(
    genai_client,
    tracer=client.tracer,
    name="gemini-support-agent",
    metadata={"env": "production"},
)

# Regular call
response = genai_client.models.generate_content(
    model="gemini-3.5-flash",
    contents="How do I cancel my subscription?",
)
print(response.text)

# or Streaming call
for chunk in genai_client.models.generate_content_stream(
    model="gemini-3.5-flash",
    contents="What is your refund policy?",
):
    print(chunk.text, end="", flush=True)

client.tracer.flush(timeout=10)

To trace the async client, patch genai_client.aio instead of genai_client:

patch_genai_client(
    genai_client.aio,
    tracer=client.tracer,
    name="gemini-support-agent",
)

response = await genai_client.aio.models.generate_content(
    model="gemini-3.5-flash",
    contents="How do I cancel my subscription?",
)
print(response.text)

async for chunk in await genai_client.aio.models.generate_content_stream(
    model="gemini-3.5-flash",
    contents="What is your refund policy?",
):
    print(chunk.text, end="", flush=True)

What gets traced

By default, each generate_content() / generate_content_stream() call produces its own trace. Wrap a multi-call loop in with tracer.trace(...) to collapse the calls into one trace instead, exactly as in the Anthropic integration.

Field	Source
`input`	`contents` argument
`output`	`response.text` (or a function-call description if the reply is a pure tool call); for streams, the concatenated chunk text
`latencyMs`	Wall-clock time of the API call (for streams, until the stream is fully consumed)
`model`	`model` argument
`inputTokens` / `outputTokens`	`usage_metadata.prompt_token_count` / `.candidates_token_count`
`cacheReadTokens`	`usage_metadata.cached_content_token_count` - the cached subset of `inputTokens`, priced at the cache rate
`framework`	Stamped `google-genai` automatically - the platform label on the framework filter and Monitor’s Platforms chart
`metadata.tools`	The request config’s `tools` function declarations, captured for the unregistered-tool listing (Tools & MCPs)
`error`	Exception message if the API call raises

`patch_genai_client()` reference

patch_genai_client(
    client: genai.Client,
    tracer: Tracer,
    name: str = "gemini-agent",
    metadata: dict | None = None,
    session_id: str | None = None,
) -> None

Parameter	Description
`client`	The `genai.Client()` instance to patch
`tracer`	`client.tracer` from your `AgentX` instance
`name`	Label shown in the AgentX UI for every trace
`metadata`	Static key-value metadata attached to every trace
`session_id`	Links traces from the same conversation thread

Calling patch_genai_client() on an already-patched client is a no-op.

Call tracer.flush() before your process exits in scripts or one-shot jobs. In long-running servers it is not required: traces drain automatically in the background.

Tracing

Framework Integrations

Google ADK

What gets traced

`AgentXADKPlugin` reference

Google Gen AI (raw Gemini API)

What gets traced

`patch_genai_client()` reference

​Google ADK

​What gets traced

​AgentXADKPlugin reference

​Google Gen AI (raw Gemini API)

​What gets traced

​patch_genai_client() reference

Google ADK

What gets traced

`AgentXADKPlugin` reference

Google Gen AI (raw Gemini API)

What gets traced

`patch_genai_client()` reference