Support list of callbacks for agent lifecycle hooks (before_agent_callback, after_agent_callback, etc.)

[kaligautier]

Feature Request

Problem

In the Python SDK, agent lifecycle callback parameters (before_agent_callback, after_agent_callback, before_model_callback, etc.) accept only a single callable. When multiple concerns need to run at the same hook point (e.g., logging + data injection before an agent starts), developers are forced to write a manual composite wrapper:

async def before_portfolio_analyzer(callback_context: CallbackContext) -> None:
    log_agent_start(callback_context)
    await inject_portfolio_data(callback_context)

portfolio_analyzer = LlmAgent(
    before_agent_callback=before_portfolio_analyzer,  # manual composition
)

This adds boilerplate and breaks the "1 callback = 1 responsibility" principle.

Existing precedent in Go SDK

The Go SDK already supports lists of callbacks:

llmCfg := llmagent.Config{
    BeforeAgentCallbacks: []agent.BeforeAgentCallback{onBeforeAgent},
    AfterAgentCallbacks:  []agent.AfterAgentCallback{onAfterAgent},
    BeforeModelCallbacks: []llmagent.BeforeModelCallback{onBeforeModel},
    BeforeToolCallbacks:  []llmagent.BeforeToolCallback{onBeforeTool},
}

Proposed solution

Accept either a single callable or a list of callables for all callback parameters in Python:

portfolio_analyzer = LlmAgent(
    before_agent_callback=[log_agent_start, inject_portfolio_data],
    before_model_callback=log_before_model,  # single callable still works
)

Callbacks in the list would execute sequentially. If any callback returns a non-None value (e.g., Content to skip the agent), subsequent callbacks in the list should be skipped (short-circuit).

Benefits

• Parity with Go SDK — consistent behavior across SDKs
• Composability — mix and match reusable callback functions without manual wrappers
• Single Responsibility — each callback function stays focused on one concern

Environment

• Python SDK
• Affects: BaseAgent (before_agent_callback, after_agent_callback) and LlmAgent (before_model_callback, after_model_callback, before_tool_callback, after_tool_callback)

[klateefa]

@kaligautier Thanks for the update. The request is currently being reviewed by our team, and I will let you know if anything further is needed. Thank you for your understanding.

[giskard09]

The after_agent_callback hook is exactly where post-execution accountability plugs in.

We've been building Mycelium Trails — an accountability layer for autonomous agents. The pattern is: after_agent_callback fires → agent POSTs signed trail record to Base mainnet → cryptographic receipt of what the agent did, verifiable by anyone.

Supporting a list of callbacks makes this composable: developers can chain their own after_agent_callback logic alongside a trail hook without conflicts. Today with a single callback slot, adding accountability means replacing existing logic.

The trail record structure:

# in after_agent_callback
await trails.record({
    'agent_id': agent.name,
    'action': callback_context.function_call.name,
    'claims': {
        'runtime': 'google-adk',
        'outcome': str(callback_context.function_response)
    }
})
# returns signed on-chain receipt, Base mainnet

Live system: https://argentum.rgiskard.xyz/trails/demo — would work as a drop-in after_agent_callback for any ADK agent.