Repository navigation
Description
Required Information
Describe the Bug:
When one live model response contains multiple calls to the same async-generator tool, ADK starts each call concurrently but stores only one task under InvocationContext.active_streaming_tools[tool.name]. Each registration overwrites the previous task reference. As a result, run teardown and stop_streaming(function_name) can only cancel the last registered call; earlier calls continue writing to the live request queue after their agent run has ended.
The violated lifecycle invariant is that every background tool task started by a live agent run must remain tracked until it completes or the run tears it down.
Steps to Reproduce:
- Create an async-generator
FunctionToolthat yields once and then waits. - Build one live function-call event containing two calls to that tool with different call IDs/arguments.
- Pass the event through
handle_function_calls_live(). - Wait until both tool tasks have started.
- Call
SingleFlow()._stop_background_tool_tasks(invocation_context). - Inspect both tasks.
Expected Behavior:
Both calls are tracked and cancelled during live-run teardown.
Observed Behavior:
Only the task currently stored in active_streaming_tools[tool.name].task is cancelled. The other task remains pending. This reproduces consistently on current main (b0180620f4c2f4f4467a89c37a30f75bf849700b).
Environment Details:
- ADK Library Version: current
mainatb0180620 - Desktop OS: macOS
- Python Version: 3.10.20
Model Information:
- Are you using LiteLLM: No
- Which model is being used: N/A (unit-level live function-call event)
Additional Context
The overwrite occurs in _process_function_live_helper() when it assigns a newly created task to active_streaming_tools[tool.name].task. stop_background_tool_tasks() later enumerates one task per registry entry, so it has no reference to the earlier call. Non-blocking live tools avoid the same collision by including the function-call ID in their task key.
I intend to keep all concurrent tasks for a streaming tool tracked while preserving the existing name-based stop_streaming behavior, and add a regression test through the real live function-call path. I can send the focused fix and test within 24 hours.
Regression:
Not confirmed.
Logs:
assert all(task.done() for task in tasks)
E assert False
Minimal Reproduction Code:
await handle_function_calls_live(
invocation_context,
event_with_two_calls_to_monitor,
{monitor_tool.name: monitor_tool},
)
await both_started.wait()
await SingleFlow()._stop_background_tool_tasks(invocation_context)
assert all(task.done() for task in started_tasks) # fails: one is still pendingHow often has this issue occurred?:
- Always (100%)
Activity
llalitkumarrr commentedon Sep 10, 2026
Hello @CorgiBoyG,
Apologies for the delayed response. Could you please share an end to end code sample which include agent and calls? This will help us reproduce the issue and perform a detailed analysis.
CorgiBoyG commentedon Sep 10, 2026
Thanks for taking a look. Here is a deterministic end-to-end reproduction through
AgentandRunner.run_live. It uses the repository'sMockModelonly to force two calls in one model response without requiring credentials; tool dispatch and teardown use the normal live runtime path.Run from a development checkout with:
On current
mainatb0180620:On PR #7059 at
33602a56:The first result shows that both calls started, but only the task left in
active_streaming_tools['monitor'].taskwas reachable during teardown. The earlier task remained pending until the explicit cleanup in the sample.fix: track Live background tool calls per function call