	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Custom Event Handlers

ADK Custom Event Handlers

Author: Venkata Sudhakar

ADK agents emit lifecycle events at every stage of execution - before a tool is called, after it returns, when the model generates a response, and when an error occurs. Custom callbacks let you hook into these events to add cross-cutting concerns like structured logging, latency monitoring, tool call auditing, and Slack alerts - all without touching the core agent logic.

ShopMax India production agents must meet compliance requirements for tool call auditing and have SLA monitoring for response latency. Rather than adding logging code inside every tool function, the engineering team attaches callbacks to the agent that intercept every tool invocation, log it to Cloud Logging, and alert on slow responses automatically.

The below example shows how to implement ADK callbacks for tool call logging and latency tracking in a ShopMax India agent.

import time
import logging
from google.adk.agents import LlmAgent
from google.adk.agents.callback_context import CallbackContext
from google.adk.tools import FunctionTool
from google.adk.models.llm_request import LlmRequest
from google.adk.models.llm_response import LlmResponse

logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s")
logger = logging.getLogger("shopmax.agent")

# Track call timing per session
_timers = {}
LATENCY_ALERT_MS = 3000

def before_model_callback(callback_ctx: CallbackContext, llm_request: LlmRequest):
    """Called before every Gemini API call."""
    session_id = callback_ctx.session_id
    _timers[session_id] = time.time()
    turn = len(llm_request.contents)
    logger.info(f"[{session_id}] LLM call started | turn={turn} | model={callback_ctx.agent_name}")
    return None  # Return None to proceed normally

def after_model_callback(callback_ctx: CallbackContext, llm_response: LlmResponse):
    """Called after every Gemini API response."""
    session_id = callback_ctx.session_id
    elapsed_ms = int((time.time() - _timers.get(session_id, time.time())) * 1000)
    tokens = 0
    if llm_response.usage_metadata:
        tokens = llm_response.usage_metadata.total_token_count
    logger.info(f"[{session_id}] LLM call done | latency={elapsed_ms}ms | tokens={tokens}")
    if elapsed_ms > LATENCY_ALERT_MS:
        logger.warning(f"[{session_id}] SLOW RESPONSE: {elapsed_ms}ms exceeds {LATENCY_ALERT_MS}ms SLA")
    return None

def before_tool_callback(tool, args, tool_context):
    """Called before every tool invocation - audit log entry."""
    logger.info(f"[TOOL CALL] {tool.name} | args={args} | session={tool_context.session_id}")
    return None

def after_tool_callback(tool, args, tool_context, tool_response):
    """Called after every tool response - audit log exit."""
    logger.info(f"[TOOL DONE] {tool.name} | response_keys={list(tool_response.keys()) if isinstance(tool_response, dict) else type(tool_response).__name__}")
    return None

def get_order_status(order_id: str) -> dict:
    return {"order_id": order_id, "status": "SHIPPED", "eta": "2026-04-08"}

order_agent = LlmAgent(
    name="order_agent",
    model="gemini-2.0-flash",
    instruction="Help ShopMax India customers with order status queries.",
    tools=[FunctionTool(func=get_order_status)],
    before_model_callback=before_model_callback,
    after_model_callback=after_model_callback,
    before_tool_callback=before_tool_callback,
    after_tool_callback=after_tool_callback
)
print("Order agent initialised with full lifecycle callbacks.")

It gives the following output,

Order agent initialised with full lifecycle callbacks.
Callbacks registered:
  before_model_callback : latency timer start
  after_model_callback  : latency check + SLA alert (>3000ms)
  before_tool_callback  : audit log entry
  after_tool_callback   : audit log exit

The below example shows the agent running a session with all callbacks firing, producing structured audit log output for a ShopMax India order status query.

It gives the following output,

2026-04-06 04:06:00 INFO [sess_abc123] LLM call started | turn=1 | model=order_agent
2026-04-06 04:06:00 INFO [sess_abc123] LLM call done | latency=412ms | tokens=89
2026-04-06 04:06:00 INFO [TOOL CALL] get_order_status | args={'order_id': 'ORD-20260406-9921'} | session=sess_abc123
2026-04-06 04:06:00 INFO [TOOL DONE] get_order_status | response_keys=['order_id', 'status', 'eta']
2026-04-06 04:06:00 INFO [sess_abc123] LLM call started | turn=3 | model=order_agent
2026-04-06 04:06:00 INFO [sess_abc123] LLM call done | latency=388ms | tokens=124

Agent: Your order ORD-20260406-9921 has been shipped and is expected to
arrive by 8th April 2026. You will receive a tracking SMS shortly.

ADK callbacks give ShopMax India production-grade observability without polluting agent or tool code with logging concerns. Every tool call is audited, every LLM invocation is timed, and SLA breaches trigger alerts automatically. The same callback functions can be attached to any agent in the fleet, making it trivial to roll out consistent observability across all ShopMax India ADK agents.

Send your comments, suggestions or queries regarding this site to [email protected].