[BUG] When executing Runners(of which agent contains stateful toolset) in parallel, toolset is being released when only one of them has finished

[challenger71498]

Describe the bug

When you configure root agent able to call same AgentTool which is configured with MCP toolset in parallel, and one of them finishes first, the rest of them fails.

To Reproduce

Before we go..

• Any stateful toolset(which means that its close() method does something) may cause this error.
• Since I encountered this is when using McpToolset, I will explain the step to reproduce using McpToolset.
• It is more likely to reproduce the issue if:
  • The execution time of AgentTool is fairly long(about >10s).
  • The execution time of AgentTool is random.
  • These will cause the invocation of AgentTools not to finish at the same time, making a certain call to finish at first.

You may reproduce this issue by 2 ways.

First case: call Runner which shares same Agent concurrently.

1. A root agent, configured with an McpToolset.
2. Execute two runners simultaneously.
3. When any runner finishes first, the rest of runner fails, raises exception(related to resource exhaution).

Second case: call AgentTool with McpToolset in parallel.

1. A root agent, configured with an AgentTool.
2. This AgentTool consists of an agent, which has a MCP toolset.
3. Write an instruction to trigger root agent to call AgentTools in parallel. (e.g. You must call 10 'search_item' tool in parallel.)
4. Execute the root agent.
5. When any AgentTool finishes first, the rest of AgentTool fails, raises exception(related to resource exhaution).

Expected behavior

Even if one of the runner has finished first, the rest of runners should not fail.

Screenshots

None, but I could reproduce both case by adding 2 test sample agent setups. You may look into it this PR #4046.

Desktop (please complete the following information):

• OS: macOS
• Python version(python -V): 3.13
• ADK version(pip show google-adk): 1.9.0

Model Information:

• Are you using LiteLLM: No
• Which model is being used: gemini-2.5-flash

Additional context

This happens due to the early release of shared resource in runner, especially when the toolset is stateful.

First case: call `Runner` which shares same `Agent` concurrently

Starting with the first case, I described the initial state to a diagram as below.
Note that 2 runners are connected to a single toolset, demonstrates that the runner will close the toolset after it finishes since both runners are based on the same agent.

Assume that Runner 1 is done first, cleaning up the toolset by calling self.close().

Now the toolset has been closed. But Runner 2 is not finished yet. Therefore, tool call throws exception, making the runner to fail.

Second case: call `AgentTool` with `McpToolset` in parallel.

Same thing goes on with the second case. The initial state is quite complicated, but the configuration is basically same: 2 runners are being executed concurrently.

And as you expected, same problem occurs.

IMO users usually do not use runner explicitly, I think first case would not occur frequently.

The second will occur quite frequently since calling same AgentTool in parallel is common(and useful!), e.g.

• RAG search in parallel (this is my case)
• run PR review bot in parallel
• fetch data chunks in parallel

Also, calling tool in parallel is decided by LLM, and from what I know is that LLM usually calls tool in parallel. We could controll this behaviour only by restricting LLM to call tools sequentially, which is not deterministic(99% maybe, but not 100%).

I made a PR to address the second issue, adding AgentToolManager which functions as reference-count for agent when using AgentTool.