bug: Runner.run_async tool_context may not be fully cleaned up on task cancellation

[tcconnally]

Problem

When Runner.run_async() is cancelled mid-execution via asyncio.CancelledError, the tool_context resources (open connections, auth sessions, file handles) may not be properly cleaned up if the cleanup code doesn't handle CancelledError.

Impact

Each cancelled run can leak resources. Under repeated cancellation patterns (e.g., timeout-based cancellation in production), accumulated resource exhaustion can crash the runtime.

Suggestion

Consider wrapping cleanup in asyncio.shield() or ensuring the finally block catches CancelledError to guarantee cleanup runs even when the task is cancelled.

[llalitkumarrr]

Hello @tcconnally ,

Thank you for raising this issue. To help us investigate this further, could you please share a few additional details, such as the ADK version you are using, the steps to reproduce the issue and a minimal reproducible code sample? Additionally, if you are not already using the latest version please consider testing it to see if the issue persists and letting us know your findings.

[tcconnally]

Thanks @llalitkumarrr. Here are the details you asked for.

ADK version: google-adk 2.3.0 (latest on PyPI), Python 3.12.13. I also confirmed the affected code path is unchanged on current main.

Root cause / location: Runner._cleanup_toolsets() in src/google/adk/runners.py awaits the cleanup directly:

await asyncio.wait_for(toolset.close(), timeout=10.0)

Because this is a bare await (not shielded), if the caller cancels runner.close() while a toolset is mid-close, the CancelledError propagates straight into toolset.close() and the toolset's own cleanup (releasing connections, auth sessions, file handles) never completes. The existing except asyncio.CancelledError branch only logs "cleanup cancelled" after the fact; it does not guarantee the close finishes.

Minimal reproducible sample (no LLM calls needed):

import asyncio
from google.adk.agents.llm_agent import LlmAgent
from google.adk.runners import Runner
from google.adk.sessions.in_memory_session_service import InMemorySessionService
from google.adk.tools.base_toolset import BaseToolset


class SlowCloseToolset(BaseToolset):
    def __init__(self):
        super().__init__()
        self.close_started = asyncio.Event()
        self.resource_released = False   # the cleanup we care about
        self.close_cancelled = False

    async def get_tools(self, readonly_context=None):
        return []

    async def close(self) -> None:
        self.close_started.set()
        try:
            await asyncio.sleep(0.1)      # simulate flushing/closing a real resource
            self.resource_released = True
        except asyncio.CancelledError:
            self.close_cancelled = True
            raise


async def main():
    toolset = SlowCloseToolset()
    runner = Runner(
        app_name="repro_app",
        agent=LlmAgent(name="repro_agent", model="gemini-2.5-flash", tools=[toolset]),
        session_service=InMemorySessionService(),
    )
    close_task = asyncio.create_task(runner.close())
    await toolset.close_started.wait()   # ensure we cancel MID-close
    close_task.cancel()                  # e.g. a timeout wrapper cancels the run
    try:
        await close_task
    except asyncio.CancelledError:
        pass
    print("close_cancelled   :", toolset.close_cancelled)
    print("resource_released :", toolset.resource_released)


asyncio.run(main())

Steps to reproduce:

1. pip install google-adk==2.3.0
2. Save the snippet as repro.py and run python repro.py.

Observed (2.3.0):

Toolset SlowCloseToolset cleanup cancelled:
close_cancelled   : True
resource_released : False   <- LEAK: close() was cancelled before releasing its resource

Expected: resource_released: True — cleanup should complete even if the caller cancels runner.close().

I verified the asyncio.shield() approach fixes it: after applying the change in #6277 to the installed 2.3.0 runners.py, the same repro prints close_cancelled: False / resource_released: True. So this is reproducible from current main/latest release, and #6277 (Refs #6271) resolves the concrete runner/toolset cleanup path. Happy to adjust the repro if you'd like it wired into tests/unittests/test_runners.py (the PR already adds test_runner_close_does_not_cancel_toolset_cleanup).