refactor(serde): DELTA_SENTINEL uses msgpack ext type EXT_DELTA_SENTINEL=8

Aligns DELTA_SENTINEL serialization with _DeltaSnapshot: both now go
through the msgpack ext hook (EXT_DELTA_SENTINEL=8, EXT_DELTA_SNAPSHOT=7)
rather than a separate "delta" type tag in dumps_typed/loads_typed.

Removes the special-case "delta" branch from dumps_typed and loads_typed.
Updates prune() sentinel detection to deserialize and compare rather than
checking the raw type tag string.

Co-Authored-By: Claude Sonnet 4.6 (1M context) <noreply@anthropic.com>

.gitignore

@@ -100,3 +100,4 @@ dmypy.json
 .turbo
 .editorconfig
 .scratch
+.worktrees/

libs/checkpoint-conformance/uv.lock

@@ -306,7 +306,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.7.3"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -319,9 +319,9 @@ dependencies = [
     { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8d/bc/8172fefad4f2da888a6d564a27d1fb7d4dbf3c640899c2b40c46235cbe98/langsmith-0.7.3.tar.gz", hash = "sha256:0223b97021af62d2cf53c8a378a27bd22e90a7327e45b353e0069ae60d5d6f9e", size = 988575, upload-time = "2026-02-13T23:25:32.916Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f4/9d/5a68b6b5e313ffabbb9725d18a71edb48177fd6d3ad329c07801d2a8e862/langsmith-0.7.3-py3-none-any.whl", hash = "sha256:03659bf9274e6efcead361c9c31a7849ea565ae0d6c0d73e1d8b239029eff3be", size = 325718, upload-time = "2026-02-13T23:25:31.52Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]

libs/checkpoint-postgres/langgraph/checkpoint/postgres/__init__.py

@@ -8,11 +8,13 @@ from typing import Any
 
 from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
+    DELTA_SENTINEL,
     WRITES_IDX_MAP,
     ChannelVersions,
     Checkpoint,
     CheckpointMetadata,
     CheckpointTuple,
+    _ChannelWritesHistory,
     get_checkpoint_id,
     get_serializable_checkpoint_metadata,
 )
@@ -23,7 +25,12 @@ from psycopg.types.json import Jsonb
 from psycopg_pool import ConnectionPool
 
 from langgraph.checkpoint.postgres import _internal
-from langgraph.checkpoint.postgres.base import BasePostgresSaver
+from langgraph.checkpoint.postgres.base import (
+    SELECT_DELTA_BLOBS_SQL,
+    SELECT_DELTA_PARENTS_SQL,
+    SELECT_DELTA_WRITES_SQL,
+    BasePostgresSaver,
+)
 from langgraph.checkpoint.postgres.shallow import ShallowPostgresSaver
 
 Conn = _internal.Conn  # For backward compatibility
@@ -430,6 +437,42 @@ class PostgresSaver(BasePostgresSaver):
                 with conn.cursor(binary=True, row_factory=dict_row) as cur:
                     yield cur
 
+    def _get_channel_writes_history(
+        self, config: RunnableConfig, channel: str
+    ) -> _ChannelWritesHistory:
+        """Fast-path override of `BaseCheckpointSaver._get_channel_writes_history`.
+
+        Three indexed roundtrips (`checkpoints`, `checkpoint_writes`,
+        `checkpoint_blobs`) each filtered by `(thread_id, checkpoint_ns)` and
+        the per-table key. Plain SELECTs let the planner pick straight index
+        scans; rationale + benchmark in `notes/delta_channel_query_bench.md`.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        checkpoint_id = get_checkpoint_id(config)
+        if checkpoint_id is None:
+            # Caller didn't specify a target — resolve to the latest
+            # checkpoint on the thread. `get_tuple` without `checkpoint_id`
+            # returns the newest; its config carries the resolved id.
+            target = self.get_tuple(config)
+            if target is None:
+                return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=[])
+            checkpoint_id = target.config["configurable"]["checkpoint_id"]
+        with self._cursor() as cur:
+            cur.execute(SELECT_DELTA_PARENTS_SQL, (channel, thread_id, checkpoint_ns))
+            parents_rows = cur.fetchall()
+            cur.execute(SELECT_DELTA_WRITES_SQL, (thread_id, checkpoint_ns, channel))
+            writes_rows = cur.fetchall()
+            cur.execute(SELECT_DELTA_BLOBS_SQL, (thread_id, checkpoint_ns, channel))
+            blobs_rows = cur.fetchall()
+        return self._build_delta_channel_writes_history(
+            channel=channel,
+            target_id=checkpoint_id,
+            parents_rows=parents_rows,
+            writes_rows=writes_rows,
+            blobs_rows=blobs_rows,
+        )
+
     def _load_checkpoint_tuple(self, value: DictRow) -> CheckpointTuple:
         """
         Convert a database row into a CheckpointTuple object.
@@ -442,6 +485,7 @@ class PostgresSaver(BasePostgresSaver):
             including its configuration, metadata, parent checkpoint (if any),
             and pending writes.
         """
+        channel_values = self._load_blobs(value["channel_values"])
         return CheckpointTuple(
             {
                 "configurable": {
@@ -454,7 +498,7 @@ class PostgresSaver(BasePostgresSaver):
                 **value["checkpoint"],
                 "channel_values": {
                     **(value["checkpoint"].get("channel_values") or {}),
-                    **self._load_blobs(value["channel_values"]),
+                    **channel_values,
                 },
             },
             value["metadata"],

libs/checkpoint-postgres/langgraph/checkpoint/postgres/aio.py

@@ -8,11 +8,13 @@ from typing import Any
 
 from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
+    DELTA_SENTINEL,
     WRITES_IDX_MAP,
     ChannelVersions,
     Checkpoint,
     CheckpointMetadata,
     CheckpointTuple,
+    _ChannelWritesHistory,
     get_checkpoint_id,
     get_serializable_checkpoint_metadata,
 )
@@ -23,7 +25,12 @@ from psycopg.types.json import Jsonb
 from psycopg_pool import AsyncConnectionPool
 
 from langgraph.checkpoint.postgres import _ainternal
-from langgraph.checkpoint.postgres.base import BasePostgresSaver
+from langgraph.checkpoint.postgres.base import (
+    SELECT_DELTA_BLOBS_SQL,
+    SELECT_DELTA_PARENTS_SQL,
+    SELECT_DELTA_WRITES_SQL,
+    BasePostgresSaver,
+)
 from langgraph.checkpoint.postgres.shallow import AsyncShallowPostgresSaver
 
 Conn = _ainternal.Conn  # For backward compatibility
@@ -391,6 +398,45 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 async with conn.cursor(binary=True, row_factory=dict_row) as cur:
                     yield cur
 
+    async def _aget_channel_writes_history(
+        self, config: RunnableConfig, channel: str
+    ) -> _ChannelWritesHistory:
+        """Fast-path override of `BaseCheckpointSaver._aget_channel_writes_history`.
+
+        Three indexed roundtrips (`checkpoints`, `checkpoint_writes`,
+        `checkpoint_blobs`); rows assembled by the shared pure helper on
+        `BasePostgresSaver`. Rationale + benchmark in
+        `notes/delta_channel_query_bench.md`.
+        """
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        checkpoint_id = get_checkpoint_id(config)
+        if checkpoint_id is None:
+            target = await self.aget_tuple(config)
+            if target is None:
+                return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=[])
+            checkpoint_id = target.config["configurable"]["checkpoint_id"]
+        async with self._cursor() as cur:
+            await cur.execute(
+                SELECT_DELTA_PARENTS_SQL, (channel, thread_id, checkpoint_ns)
+            )
+            parents_rows = await cur.fetchall()
+            await cur.execute(
+                SELECT_DELTA_WRITES_SQL, (thread_id, checkpoint_ns, channel)
+            )
+            writes_rows = await cur.fetchall()
+            await cur.execute(
+                SELECT_DELTA_BLOBS_SQL, (thread_id, checkpoint_ns, channel)
+            )
+            blobs_rows = await cur.fetchall()
+        return self._build_delta_channel_writes_history(
+            channel=channel,
+            target_id=checkpoint_id,
+            parents_rows=parents_rows,
+            writes_rows=writes_rows,
+            blobs_rows=blobs_rows,
+        )
+
     async def _load_checkpoint_tuple(self, value: DictRow) -> CheckpointTuple:
         """
         Convert a database row into a CheckpointTuple object.
@@ -403,11 +449,18 @@ class AsyncPostgresSaver(BasePostgresSaver):
             including its configuration, metadata, parent checkpoint (if any),
             and pending writes.
         """
+        thread_id = value["thread_id"]
+        checkpoint_ns = value["checkpoint_ns"]
+        blob_values = value["channel_values"]
+        channel_values: dict[str, Any] = {}
+        if blob_values:
+            channel_values = self._load_blobs(blob_values)
+
         return CheckpointTuple(
             {
                 "configurable": {
-                    "thread_id": value["thread_id"],
-                    "checkpoint_ns": value["checkpoint_ns"],
+                    "thread_id": thread_id,
+                    "checkpoint_ns": checkpoint_ns,
                     "checkpoint_id": value["checkpoint_id"],
                 }
             },
@@ -415,15 +468,15 @@ class AsyncPostgresSaver(BasePostgresSaver):
                 **value["checkpoint"],
                 "channel_values": {
                     **(value["checkpoint"].get("channel_values") or {}),
-                    **self._load_blobs(value["channel_values"]),
+                    **channel_values,
                 },
             },
             value["metadata"],
             (
                 {
                     "configurable": {
-                        "thread_id": value["thread_id"],
-                        "checkpoint_ns": value["checkpoint_ns"],
+                        "thread_id": thread_id,
+                        "checkpoint_ns": checkpoint_ns,
                         "checkpoint_id": value["parent_checkpoint_id"],
                     }
                 }

libs/checkpoint-postgres/langgraph/checkpoint/postgres/base.py

@@ -8,12 +8,15 @@ from typing import Any, cast
 
 from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
+    DELTA_SENTINEL,
     WRITES_IDX_MAP,
     BaseCheckpointSaver,
     ChannelVersions,
+    PendingWrite,
+    _ChannelWritesHistory,
     get_checkpoint_id,
 )
-from langgraph.checkpoint.serde.types import TASKS
+from langgraph.checkpoint.serde.types import TASKS, _DeltaSnapshot
 from psycopg.types.json import Jsonb
 
 MetadataInput = dict[str, Any] | None
@@ -152,6 +155,30 @@ INSERT_CHECKPOINT_WRITES_SQL = """
     ON CONFLICT (thread_id, checkpoint_ns, checkpoint_id, task_id, idx) DO NOTHING
 """
 
+# DeltaChannel reconstruction: three plain indexed SELECTs per channel.
+# Bench (notes/delta_channel_query_bench.md) showed the prior recursive CTE
+# carried a hidden O(ancestors x blobs_in_thread) join; plain SELECTs are
+# 3x-100x faster in the realistic depth range and the Python walk is O(n).
+SELECT_DELTA_PARENTS_SQL = """
+    SELECT checkpoint_id,
+           parent_checkpoint_id,
+           checkpoint -> 'channel_versions' ->> %s AS ver
+    FROM checkpoints
+    WHERE thread_id = %s AND checkpoint_ns = %s
+"""
+
+SELECT_DELTA_WRITES_SQL = """
+    SELECT checkpoint_id, type, blob, task_id, idx
+    FROM checkpoint_writes
+    WHERE thread_id = %s AND checkpoint_ns = %s AND channel = %s
+"""
+
+SELECT_DELTA_BLOBS_SQL = """
+    SELECT version, type, blob
+    FROM checkpoint_blobs
+    WHERE thread_id = %s AND checkpoint_ns = %s AND channel = %s
+"""
+
 
 class BasePostgresSaver(BaseCheckpointSaver[str]):
     SELECT_SQL = SELECT_SQL
@@ -185,16 +212,107 @@ class BasePostgresSaver(BaseCheckpointSaver[str]):
         )
 
     def _load_blobs(
-        self, blob_values: list[tuple[bytes, bytes, bytes]]
+        self,
+        blob_values: Any,
     ) -> dict[str, Any]:
         if not blob_values:
             return {}
-        return {
-            k.decode(): self.serde.loads_typed((t.decode(), v))
-            for k, t, v in blob_values
-            if t.decode() != "empty"
+        result: dict[str, Any] = {}
+        for k, t, v in blob_values:
+            type_tag = t.decode()
+            if type_tag != "empty":
+                result[k.decode()] = self.serde.loads_typed((type_tag, v))
+        return result
+
+    def _build_delta_channel_writes_history(
+        self,
+        *,
+        channel: str,
+        target_id: str,
+        parents_rows: Sequence[Any],
+        writes_rows: Sequence[Any],
+        blobs_rows: Sequence[Any],
+    ) -> _ChannelWritesHistory:
+        """Reconstruct one delta channel's history from rows of the three SELECTs.
+
+        Pure data transform shared by sync (`PostgresSaver`) and async
+        (`AsyncPostgresSaver`); both paths run the queries themselves and
+        feed the rows here.
+
+        Walk is newest → oldest from the target's parent. A non-sentinel
+        blob in `checkpoint_blobs` (a pre-delta snapshot) terminates the
+        walk and is returned as the seed so replay starts from it.
+
+        Writes stored at `target_id` itself are pending writes for the next
+        step and are excluded — the walk begins at the target's parent.
+        """
+        parent_of: dict[str, str | None] = {}
+        ver_of: dict[str, str | None] = {}
+        for r in parents_rows:
+            cid = r["checkpoint_id"]
+            parent_of[cid] = r["parent_checkpoint_id"]
+            ver_of[cid] = r["ver"]
+
+        ancestors: list[str] = []
+        cid = parent_of.get(target_id)
+        while cid is not None:
+            ancestors.append(cid)
+            cid = parent_of.get(cid)
+        if not ancestors:
+            return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=[])
+        ancestor_set = set(ancestors)
+
+        # Group writes by ancestor cid; sort within (task_id DESC, idx DESC)
+        # to match the prior CTE ordering — newest write first per ancestor.
+        writes_by_cid: dict[str, list[tuple[str, bytes, str, int]]] = {}
+        for r in writes_rows:
+            cid = r["checkpoint_id"]
+            if cid not in ancestor_set:
+                continue
+            writes_by_cid.setdefault(cid, []).append(
+                (r["type"], r["blob"], r["task_id"], r["idx"])
+            )
+        for ws in writes_by_cid.values():
+            ws.sort(key=lambda w: (w[2], w[3]), reverse=True)
+
+        blob_by_ver: dict[str, tuple[str, bytes]] = {
+            r["version"]: (r["type"], r["blob"]) for r in blobs_rows
         }
 
+        collected: list[PendingWrite] = []  # newest first; reversed at the end
+        for cid in ancestors:
+            ver = ver_of.get(cid)
+            if ver is not None:
+                seed_blob = blob_by_ver.get(ver)
+                if seed_blob is not None and seed_blob[0] != "empty":
+                    blob_value = self.serde.loads_typed(seed_blob)
+                    if blob_value is not DELTA_SENTINEL:
+                        if isinstance(blob_value, _DeltaSnapshot):
+                            # Step-based snapshot: collect this ancestor's
+                            # pending_writes first (they encode the NEXT step's
+                            # transition, not subsumed by the snapshot blob).
+                            for (
+                                type_tag,
+                                write_blob,
+                                task_id,
+                                _idx,
+                            ) in writes_by_cid.get(cid, []):
+                                val = self.serde.loads_typed((type_tag, write_blob))
+                                collected.append((task_id, channel, val))
+                            collected.reverse()
+                            return _ChannelWritesHistory(
+                                seed=blob_value, writes=collected
+                            )
+                        # Pre-delta blob: subsumes this ancestor's writes.
+                        collected.reverse()
+                        return _ChannelWritesHistory(seed=blob_value, writes=collected)
+            for type_tag, write_blob, task_id, _idx in writes_by_cid.get(cid, []):
+                val = self.serde.loads_typed((type_tag, write_blob))
+                collected.append((task_id, channel, val))
+
+        collected.reverse()  # oldest → newest
+        return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=collected)
+
     def _dump_blobs(
         self,
         thread_id: str,

libs/checkpoint-postgres/tests/test_async.py

@@ -361,9 +361,9 @@ async def test_get_checkpoint_no_channel_values(
 
         load_checkpoint_tuple = saver._load_checkpoint_tuple
 
-        def patched_load_checkpoint_tuple(value):
+        async def patched_load_checkpoint_tuple(value):
             value["checkpoint"].pop("channel_values", None)
-            return load_checkpoint_tuple(value)
+            return await load_checkpoint_tuple(value)
 
         monkeypatch.setattr(
             saver, "_load_checkpoint_tuple", patched_load_checkpoint_tuple
@@ -371,3 +371,47 @@ async def test_get_checkpoint_no_channel_values(
 
         checkpoint = await saver.aget_tuple(config)
         assert checkpoint.checkpoint["channel_values"] == {}
+
+
+@pytest.mark.parametrize("saver_name", ["base", "pool", "pipe"])
+async def test_delta_channel_chain_reconstruction(saver_name: str) -> None:
+    """AsyncPostgresSaver reconstructs DeltaChannel chain via point-lookup traversal."""
+    pytest.importorskip(
+        "langgraph.channels.delta", reason="langgraph core not installed"
+    )
+
+    from typing import Annotated
+
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.channels.delta import DeltaChannel
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+    from typing_extensions import TypedDict
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    def respond(state: State) -> dict:
+        n = len(state["messages"])
+        return {"messages": [AIMessage(content=f"reply-{n}", id=f"ai-{n}")]}
+
+    builder = StateGraph(State)
+    builder.add_node("respond", respond)
+    builder.add_edge(START, "respond")
+
+    async with _saver(saver_name) as saver:
+        graph = builder.compile(checkpointer=saver)
+        config = {"configurable": {"thread_id": "diff-channel-test-1"}}
+
+        await graph.ainvoke({"messages": [HumanMessage(content="hi", id="h1")]}, config)
+        await graph.ainvoke(
+            {"messages": [HumanMessage(content="there", id="h2")]}, config
+        )
+
+        state = await graph.aget_state(config)
+        msgs = state.values["messages"]
+        assert len(msgs) == 4, f"expected 4, got {len(msgs)}: {msgs}"
+        assert msgs[0].content == "hi"
+        assert msgs[1].content == "reply-1"
+        assert msgs[2].content == "there"
+        assert msgs[3].content == "reply-3"

libs/checkpoint-postgres/uv.lock

@@ -259,7 +259,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 source = { editable = "../checkpoint" }
 dependencies = [
     { name = "langchain-core" },
@@ -382,7 +382,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.6.4"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -392,11 +392,12 @@ dependencies = [
     { name = "requests" },
     { name = "requests-toolbelt" },
     { name = "uuid-utils" },
+    { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/85/9c7933052a997da1b85bc5c774f3865e9b1da1c8d71541ea133178b13229/langsmith-0.6.4.tar.gz", hash = "sha256:36f7223a01c218079fbb17da5e536ebbaf5c1468c028abe070aa3ae59bc99ec8", size = 919964, upload-time = "2026-01-15T20:02:28.873Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/0f/09a6637a7ba777eb307b7c80852d9ee26438e2bdafbad6fcc849ff9d9192/langsmith-0.6.4-py3-none-any.whl", hash = "sha256:ac4835860160be371042c7adbba3cb267bcf8d96a5ea976c33a8a4acad6c5486", size = 283503, upload-time = "2026-01-15T20:02:26.662Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]
@@ -1284,6 +1285,124 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
 ]
 
+[[package]]
+name = "xxhash"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" },
+    { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" },
+    { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" },
+    { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" },
+    { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" },
+    { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" },
+    { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" },
+    { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" },
+    { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" },
+    { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" },
+    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
+    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
+    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" },
+    { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" },
+    { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" },
+    { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" },
+    { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" },
+    { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" },
+    { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" },
+    { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" },
+    { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" },
+    { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" },
+    { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
+]
+
 [[package]]
 name = "zstandard"
 version = "0.25.0"

libs/checkpoint-sqlite/uv.lock

@@ -268,7 +268,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 source = { editable = "../checkpoint" }
 dependencies = [
     { name = "langchain-core" },
@@ -385,7 +385,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.6.4"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -395,11 +395,12 @@ dependencies = [
     { name = "requests" },
     { name = "requests-toolbelt" },
     { name = "uuid-utils" },
+    { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/85/9c7933052a997da1b85bc5c774f3865e9b1da1c8d71541ea133178b13229/langsmith-0.6.4.tar.gz", hash = "sha256:36f7223a01c218079fbb17da5e536ebbaf5c1468c028abe070aa3ae59bc99ec8", size = 919964, upload-time = "2026-01-15T20:02:28.873Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/0f/09a6637a7ba777eb307b7c80852d9ee26438e2bdafbad6fcc849ff9d9192/langsmith-0.6.4-py3-none-any.whl", hash = "sha256:ac4835860160be371042c7adbba3cb267bcf8d96a5ea976c33a8a4acad6c5486", size = 283503, upload-time = "2026-01-15T20:02:26.662Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]
@@ -1211,6 +1212,124 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
 ]
 
+[[package]]
+name = "xxhash"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" },
+    { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" },
+    { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" },
+    { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" },
+    { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" },
+    { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" },
+    { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" },
+    { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" },
+    { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" },
+    { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" },
+    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
+    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
+    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" },
+    { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" },
+    { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" },
+    { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" },
+    { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" },
+    { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" },
+    { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" },
+    { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" },
+    { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" },
+    { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" },
+    { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
+]
+
 [[package]]
 name = "zstandard"
 version = "0.25.0"

libs/checkpoint/langgraph/checkpoint/base/__init__.py

@@ -1,9 +1,10 @@
 from __future__ import annotations
 
+import contextvars
 import copy
 import logging
 from collections.abc import AsyncIterator, Collection, Iterator, Mapping, Sequence
-from typing import (  # noqa: UP035
+from typing import (
     Any,
     Generic,
     Literal,
@@ -18,16 +19,30 @@ from langgraph.checkpoint.base.id import uuid6
 from langgraph.checkpoint.serde.base import SerializerProtocol, maybe_add_typed_methods
 from langgraph.checkpoint.serde.encrypted import EncryptedSerializer
 from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+from langgraph.checkpoint.serde.types import (
+    DELTA_SENTINEL as DELTA_SENTINEL,
+)
 from langgraph.checkpoint.serde.types import (
     ERROR,
     INTERRUPT,
     RESUME,
     SCHEDULED,
     ChannelProtocol,
+    _DeltaSnapshot,
 )
 
 V = TypeVar("V", int, float, str)
 PendingWrite = tuple[str, str, Any]
+
+# Task-local guard: ContextVar is copied per asyncio Task, so concurrent
+# requests on the same event-loop thread do not share this flag. A plain
+# `threading.local()` would leak across tasks and let one in-flight
+# reconstruction silently short-circuit another.
+_DELTA_RECONSTRUCTION: contextvars.ContextVar[bool] = contextvars.ContextVar(
+    "_DELTA_RECONSTRUCTION", default=False
+)
+
+
 logger = logging.getLogger(__name__)
 
 
@@ -119,6 +134,30 @@ class CheckpointTuple(NamedTuple):
     pending_writes: list[PendingWrite] | None = None
 
 
+class _ChannelWritesHistory(NamedTuple):
+    """Result of `BaseCheckpointSaver._get_channel_writes_history`.
+
+    Storage-level view of what one channel wrote across the ancestor chain
+    of a target checkpoint:
+
+      * `seed` — the nearest ancestor's stored blob value for this channel,
+        or `DELTA_SENTINEL` if the walk reached the root without finding a
+        stored value. A non-sentinel seed typically indicates a pre-delta
+        snapshot preserved across a channel-type migration (e.g.
+        `BinaryOperatorAggregate` storage extended under `DeltaChannel`).
+      * `writes` — on-path deltas oldest→newest, one `PendingWrite` per
+        step that wrote to this channel. Writes stored at the target
+        checkpoint itself are pending for the next super-step and are
+        excluded.
+
+    Experimental: method surface may change; the NamedTuple shape is the
+    contract.
+    """
+
+    seed: Any
+    writes: list[PendingWrite]
+
+
 class BaseCheckpointSaver(Generic[V]):
     """Base class for creating a graph checkpointer.
 
@@ -457,6 +496,121 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
+    def _get_channel_writes_history(
+        self, config: RunnableConfig, channel: str
+    ) -> _ChannelWritesHistory:
+        """**Experimental.** Query one channel's writes along the parent chain.
+
+        Storage-level query, not channel semantics: returns `(seed, writes)`
+        reflecting what storage knows about a single channel across the
+        ancestor chain of the target checkpoint identified by `config`.
+
+        * `writes` — on-path deltas oldest→newest as `PendingWrite` tuples.
+          Writes stored at the target `checkpoint_id` itself are pending
+          for the next super-step and are excluded.
+        * `seed` — the nearest ancestor's stored blob value for this
+          channel; `DELTA_SENTINEL` if the walk reached the root without
+          finding a stored value. A non-sentinel seed typically indicates
+          a pre-delta snapshot preserved across a channel-type migration.
+
+        Walks the **parent chain** (not `list(before=...)`): for forked
+        threads, only on-path ancestors contribute.
+
+        Reference implementation walks `get_tuple` + `parent_config`,
+        inspecting each ancestor's `channel_values[channel]` for the seed
+        terminator. Savers with direct storage access (`InMemorySaver`,
+        `PostgresSaver`) override for performance; the return contract is
+        fixed here.
+
+        Underscore-prefixed because the method surface is experimental.
+        """
+        # Guard against re-entrant calls: when get_tuple() triggers
+        # reconstruction which calls get_tuple() again, the inner call
+        # short-circuits here.
+        if _DELTA_RECONSTRUCTION.get():
+            return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=[])
+
+        token = _DELTA_RECONSTRUCTION.set(True)
+        try:
+            collected: list[PendingWrite] = []  # newest first; reversed at the end
+            target_tuple = self.get_tuple(config)
+            cursor_config: RunnableConfig | None = (
+                target_tuple.parent_config if target_tuple else None
+            )
+            while cursor_config is not None:
+                tup = self.get_tuple(cursor_config)
+                if tup is None:
+                    break
+                # Pre-delta seed terminator: if the ancestor has a stored
+                # (non-sentinel) value for this channel, that snapshot
+                # subsumes any earlier writes on the chain. Stop here.
+                ancestor_value = tup.checkpoint["channel_values"].get(channel)
+                if ancestor_value is not None and ancestor_value is not DELTA_SENTINEL:
+                    if isinstance(ancestor_value, _DeltaSnapshot):
+                        # Step-based snapshot: the blob is state AT this ancestor,
+                        # but pending_writes encode the NEXT step's transition and
+                        # are NOT subsumed — collect them before terminating.
+                        if tup.pending_writes:
+                            for write in reversed(tup.pending_writes):
+                                if write[1] != channel:
+                                    continue
+                                collected.append(write)
+                    # Pre-delta blob: subsumes its own writes — stop immediately.
+                    collected.reverse()
+                    return _ChannelWritesHistory(seed=ancestor_value, writes=collected)
+                if tup.pending_writes:
+                    # Within a superstep, pending_writes are oldest→newest;
+                    # reverse to scan newest-first.
+                    for write in reversed(tup.pending_writes):
+                        if write[1] != channel:
+                            continue
+                        collected.append(write)
+                cursor_config = tup.parent_config
+            collected.reverse()
+            return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=collected)
+        finally:
+            _DELTA_RECONSTRUCTION.reset(token)
+
+    async def _aget_channel_writes_history(
+        self, config: RunnableConfig, channel: str
+    ) -> _ChannelWritesHistory:
+        """Async version of `_get_channel_writes_history`. See docstring there."""
+        if _DELTA_RECONSTRUCTION.get():
+            return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=[])
+
+        token = _DELTA_RECONSTRUCTION.set(True)
+        try:
+            collected: list[PendingWrite] = []
+            target_tuple = await self.aget_tuple(config)
+            cursor_config: RunnableConfig | None = (
+                target_tuple.parent_config if target_tuple else None
+            )
+            while cursor_config is not None:
+                tup = await self.aget_tuple(cursor_config)
+                if tup is None:
+                    break
+                # See sync variant for rationale.
+                ancestor_value = tup.checkpoint["channel_values"].get(channel)
+                if ancestor_value is not None and ancestor_value is not DELTA_SENTINEL:
+                    if isinstance(ancestor_value, _DeltaSnapshot):
+                        if tup.pending_writes:
+                            for write in reversed(tup.pending_writes):
+                                if write[1] != channel:
+                                    continue
+                                collected.append(write)
+                    collected.reverse()
+                    return _ChannelWritesHistory(seed=ancestor_value, writes=collected)
+                if tup.pending_writes:
+                    for write in reversed(tup.pending_writes):
+                        if write[1] != channel:
+                            continue
+                        collected.append(write)
+                cursor_config = tup.parent_config
+            collected.reverse()
+            return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=collected)
+        finally:
+            _DELTA_RECONSTRUCTION.reset(token)
+
     def get_next_version(self, current: V | None, channel: None) -> V:
         """Generate the next version ID for a channel.
 

libs/checkpoint/langgraph/checkpoint/memory/__init__.py

@@ -9,21 +9,25 @@ from collections import defaultdict
 from collections.abc import AsyncIterator, Iterator, Sequence
 from contextlib import AbstractAsyncContextManager, AbstractContextManager, ExitStack
 from types import TracebackType
-from typing import Any
+from typing import Any, cast
 
 from langchain_core.runnables import RunnableConfig
 
 from langgraph.checkpoint.base import (
+    DELTA_SENTINEL,
     WRITES_IDX_MAP,
     BaseCheckpointSaver,
     ChannelVersions,
     Checkpoint,
     CheckpointMetadata,
     CheckpointTuple,
+    PendingWrite,
     SerializerProtocol,
+    _ChannelWritesHistory,
     get_checkpoint_id,
     get_checkpoint_metadata,
 )
+from langgraph.checkpoint.serde.types import _DeltaSnapshot
 
 logger = logging.getLogger(__name__)
 
@@ -121,16 +125,114 @@ class InMemorySaver(
         return self.stack.__exit__(__exc_type, __exc_value, __traceback)
 
     def _load_blobs(
-        self, thread_id: str, checkpoint_ns: str, versions: ChannelVersions
+        self,
+        thread_id: str,
+        checkpoint_ns: str,
+        versions: ChannelVersions,
     ) -> dict[str, Any]:
-        channel_values: dict[str, Any] = {}
-        for k, v in versions.items():
-            kk = (thread_id, checkpoint_ns, k, v)
-            if kk in self.blobs:
-                vv = self.blobs[kk]
-                if vv[0] != "empty":
-                    channel_values[k] = self.serde.loads_typed(vv)
-        return channel_values
+        result: dict[str, Any] = {}
+        for k, ver in versions.items():
+            kk = (thread_id, checkpoint_ns, k, ver)
+            if kk not in self.blobs:
+                continue
+            vv = self.blobs[kk]
+            if vv[0] == "empty":
+                continue
+            result[k] = self.serde.loads_typed(vv)
+        return result
+
+    def _get_channel_writes_history(
+        self, config: RunnableConfig, channel: str
+    ) -> _ChannelWritesHistory:
+        thread_id = config["configurable"]["thread_id"]
+        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
+        checkpoint_id = config["configurable"].get("checkpoint_id", "")
+        ns_storage = self.storage.get(thread_id, {}).get(checkpoint_ns, {})
+        # Walk the parent chain newest→oldest. Skip the target itself —
+        # writes stored AT `checkpoint_id` are pending for the next step
+        # (pregel applies them via `apply_writes`; they aren't part of the
+        # snapshot value AT `checkpoint_id`).
+        chain: list[str] = []
+        target_entry = ns_storage.get(checkpoint_id)
+        current: str | None = target_entry[2] if target_entry is not None else None
+        while current is not None:
+            entry = ns_storage.get(current)
+            if entry is None:
+                break
+            chain.append(current)
+            _, _, parent = entry
+            current = parent
+        # Scan newest→oldest. A pre-delta blob on an ancestor terminates the
+        # walk and is bound as `seed`; without this, a thread migrated from
+        # pre-delta storage would replay ancestor writes all the way to the
+        # root AND miss any value that lived only in the old blob (e.g. from
+        # `update_state`).
+        #
+        # At each ancestor, check the blob BEFORE processing its pending
+        # writes: a pre-delta blob represents the state AT that ancestor,
+        # which already subsumes any writes stored under it. Processing
+        # those writes first would fold them into the reconstructed value
+        # twice (once via the blob, once via replay).
+        collected: list[PendingWrite] = []  # newest first
+        for cp_id in chain:  # newest → oldest
+            entry = ns_storage.get(cp_id)
+            if entry is not None:
+                ckpt = self.serde.loads_typed(entry[0])
+                ver = ckpt.get("channel_versions", {}).get(channel)
+                if ver is not None:
+                    blob_entry = self.blobs.get(
+                        (thread_id, checkpoint_ns, channel, ver)
+                    )
+                    if blob_entry is not None and blob_entry[0] != "empty":
+                        blob_value = self.serde.loads_typed(blob_entry)
+                        if blob_value is not DELTA_SENTINEL:
+                            if isinstance(blob_value, _DeltaSnapshot):
+                                # Step-based snapshot: the blob is state AT this
+                                # ancestor, but the ancestor's pending_writes
+                                # encode the NEXT step's transition and are NOT
+                                # subsumed by the snapshot — collect them first.
+                                step_writes = self.writes.get(
+                                    (thread_id, checkpoint_ns, cp_id), {}
+                                )
+                                for (_task_id, _idx), (
+                                    tid,
+                                    ch,
+                                    serialized,
+                                    _,
+                                ) in sorted(step_writes.items(), reverse=True):
+                                    if ch != channel:
+                                        continue
+                                    collected.append(
+                                        (tid, ch, self.serde.loads_typed(serialized))
+                                    )
+                                collected.reverse()
+                                return _ChannelWritesHistory(
+                                    seed=blob_value, writes=collected
+                                )
+                            # Pre-delta blob: state AT this ancestor already
+                            # subsumes its pending_writes — skip them.
+                            collected.reverse()
+                            return _ChannelWritesHistory(
+                                seed=blob_value, writes=collected
+                            )
+
+            step_writes = self.writes.get((thread_id, checkpoint_ns, cp_id), {})
+            # Within a superstep, sorted by (task_id, idx) = oldest → newest;
+            # reverse for newest-first scan.
+            for (_task_id, _idx), (tid, ch, serialized, _) in sorted(
+                step_writes.items(), reverse=True
+            ):
+                if ch != channel:
+                    continue
+                val = self.serde.loads_typed(serialized)
+                collected.append((tid, ch, val))
+        collected.reverse()
+        return _ChannelWritesHistory(seed=DELTA_SENTINEL, writes=collected)
+
+    async def _aget_channel_writes_history(
+        self, config: RunnableConfig, channel: str
+    ) -> _ChannelWritesHistory:
+        return self._get_channel_writes_history(config, channel)
 
     def get_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Get a checkpoint tuple from the in-memory storage.
@@ -153,13 +255,16 @@ class InMemorySaver(
                 checkpoint, metadata, parent_checkpoint_id = saved
                 writes = self.writes[(thread_id, checkpoint_ns, checkpoint_id)].values()
                 checkpoint_: Checkpoint = self.serde.loads_typed(checkpoint)
+                channel_values = self._load_blobs(
+                    thread_id,
+                    checkpoint_ns,
+                    checkpoint_["channel_versions"],
+                )
                 return CheckpointTuple(
                     config=config,
                     checkpoint={
                         **checkpoint_,
-                        "channel_values": self._load_blobs(
-                            thread_id, checkpoint_ns, checkpoint_["channel_versions"]
-                        ),
+                        "channel_values": channel_values,
                     },
                     metadata=self.serde.loads_typed(metadata),
                     pending_writes=[
@@ -183,19 +288,26 @@ class InMemorySaver(
                 checkpoint, metadata, parent_checkpoint_id = checkpoints[checkpoint_id]
                 writes = self.writes[(thread_id, checkpoint_ns, checkpoint_id)].values()
                 checkpoint_ = self.serde.loads_typed(checkpoint)
-                return CheckpointTuple(
-                    config={
+                resolved_config = cast(
+                    RunnableConfig,
+                    {
                         "configurable": {
                             "thread_id": thread_id,
                             "checkpoint_ns": checkpoint_ns,
                             "checkpoint_id": checkpoint_id,
                         }
                     },
+                )
+                channel_values = self._load_blobs(
+                    thread_id,
+                    checkpoint_ns,
+                    checkpoint_["channel_versions"],
+                )
+                return CheckpointTuple(
+                    config=resolved_config,
                     checkpoint={
                         **checkpoint_,
-                        "channel_values": self._load_blobs(
-                            thread_id, checkpoint_ns, checkpoint_["channel_versions"]
-                        ),
+                        "channel_values": channel_values,
                     },
                     metadata=self.serde.loads_typed(metadata),
                     pending_writes=[
@@ -290,21 +402,27 @@ class InMemorySaver(
 
                     checkpoint_: Checkpoint = self.serde.loads_typed(checkpoint)
 
-                    yield CheckpointTuple(
-                        config={
+                    list_config = cast(
+                        RunnableConfig,
+                        {
                             "configurable": {
                                 "thread_id": thread_id,
                                 "checkpoint_ns": checkpoint_ns,
                                 "checkpoint_id": checkpoint_id,
                             }
                         },
+                    )
+                    channel_values = self._load_blobs(
+                        thread_id,
+                        checkpoint_ns,
+                        checkpoint_["channel_versions"],
+                    )
+
+                    yield CheckpointTuple(
+                        config=list_config,
                         checkpoint={
                             **checkpoint_,
-                            "channel_values": self._load_blobs(
-                                thread_id,
-                                checkpoint_ns,
-                                checkpoint_["channel_versions"],
-                            ),
+                            "channel_values": channel_values,
                         },
                         metadata=metadata,
                         parent_config=(
@@ -407,6 +525,101 @@ class InMemorySaver(
                 task_path,
             )
 
+    def prune(
+        self,
+        thread_ids: Sequence[str],
+        *,
+        strategy: str = "keep_latest",
+    ) -> None:
+        """Prune checkpoints for the given threads.
+
+        For DeltaChannel channels, a checkpoint is only deleted if the walk
+        from the latest checkpoint would not need to traverse it — i.e., a
+        `_DeltaSnapshot` blob exists in the kept ancestry that covers all
+        sentinel channels.  Checkpoints that are still in the active walk
+        chain (because no snapshot has been taken yet, e.g. with
+        `snapshot_frequency=None`) are retained.
+
+        Args:
+            thread_ids: Thread IDs to prune.
+            strategy: ``"keep_latest"`` keeps only the most recent checkpoint
+                per namespace; ``"delete"`` removes all checkpoints.
+        """
+        for thread_id in thread_ids:
+            if strategy == "delete":
+                self.delete_thread(thread_id)
+                continue
+
+            if strategy != "keep_latest":
+                raise ValueError(
+                    f"Unknown pruning strategy {strategy!r}. "
+                    "Expected 'keep_latest' or 'delete'."
+                )
+
+            for checkpoint_ns, ns_storage in list(
+                self.storage.get(thread_id, {}).items()
+            ):
+                if not ns_storage:
+                    continue
+
+                # Latest checkpoint (uuid6 IDs are lexicographically monotonic)
+                latest_id = max(ns_storage.keys())
+                latest_data, _, _ = ns_storage[latest_id]
+                latest_cp = self.serde.loads_typed(latest_data)
+
+                # Which channels in the latest checkpoint still have sentinels?
+                sentinel_channels: set[str] = set()
+                for ch, ver in latest_cp.get("channel_versions", {}).items():
+                    blob = self.blobs.get((thread_id, checkpoint_ns, ch, ver))
+                    if blob is not None and blob[0] != "empty":
+                        if self.serde.loads_typed(blob) is DELTA_SENTINEL:
+                            sentinel_channels.add(ch)
+
+                # Walk the parent chain to find the oldest ancestor still needed.
+                # We stop (and mark "safe to prune before here") when all
+                # sentinel channels are covered by a non-sentinel blob.
+                required_ids: set[str] = {latest_id}
+                if sentinel_channels:
+                    _, _, parent_id = ns_storage[latest_id]
+                    remaining = set(sentinel_channels)
+                    while parent_id is not None and remaining:
+                        entry = ns_storage.get(parent_id)
+                        if entry is None:
+                            break
+                        required_ids.add(parent_id)
+                        cp_data, _, grandparent_id = entry
+                        cp = self.serde.loads_typed(cp_data)
+                        resolved: set[str] = set()
+                        for ch in remaining:
+                            ver = cp.get("channel_versions", {}).get(ch)
+                            if ver is None:
+                                continue
+                            blob = self.blobs.get((thread_id, checkpoint_ns, ch, ver))
+                            if blob is not None and blob[0] != "empty":
+                                if self.serde.loads_typed(blob) is not DELTA_SENTINEL:
+                                    resolved.add(ch)
+                        remaining -= resolved
+                        parent_id = grandparent_id
+
+                # Delete everything outside the required set
+                for cp_id in list(ns_storage.keys()):
+                    if cp_id in required_ids:
+                        continue
+                    cp_data, _, _ = ns_storage.pop(cp_id)
+                    self.writes.pop((thread_id, checkpoint_ns, cp_id), None)
+
+                # Clean up blobs no longer referenced by any kept checkpoint
+                live: set[tuple[str, str, str, Any]] = set()
+                for cp_data, _, _ in ns_storage.values():
+                    cp = self.serde.loads_typed(cp_data)
+                    for ch, ver in cp.get("channel_versions", {}).items():
+                        live.add((thread_id, checkpoint_ns, ch, ver))
+                for key in [
+                    k for k in self.blobs if k[:2] == (thread_id, checkpoint_ns)
+                ]:
+                    if key not in live:
+                        del self.blobs[key]
+
     def delete_thread(self, thread_id: str) -> None:
         """Delete all checkpoints and writes associated with a thread ID.
 

libs/checkpoint/langgraph/checkpoint/serde/jsonplus.py

@@ -33,19 +33,40 @@ from langchain_core.load.load import Reviver
 from langgraph.checkpoint.serde import _msgpack as _lg_msgpack
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.checkpoint.serde.event_hooks import emit_serde_event
-from langgraph.checkpoint.serde.types import SendProtocol
+from langgraph.checkpoint.serde.types import (
+    DELTA_SENTINEL,
+    SendProtocol,
+    _DeltaSentinel,
+    _DeltaSnapshot,
+)
 from langgraph.store.base import Item
 
 if TYPE_CHECKING:
     from langgraph.checkpoint.serde._msgpack import (
         AllowedMsgpackModules,
     )
-    from langgraph.checkpoint.serde.types import SendProtocol
 
 LC_REVIVER = Reviver()
 EMPTY_BYTES = b""
 logger = logging.getLogger(__name__)
 
+# Dedup log warnings across process lifetime; cap bounds state if types are
+# dynamically generated (also acts as a circuit breaker on warning volume).
+# Dedup is best-effort: racing threads may each emit once for the same key,
+# and warnings are silently dropped once _MAX_WARNED_TYPES is reached.
+_MAX_WARNED_TYPES = 1000
+_warned_unregistered_types: set[tuple[str, str]] = set()
+_warned_blocked_types: set[tuple[str, str]] = set()
+
+
+def _warn_once(
+    seen: set[tuple[str, str]], key: tuple[str, str], msg: str, *args: object
+) -> None:
+    if key in seen or len(seen) >= _MAX_WARNED_TYPES:
+        return
+    seen.add(key)
+    logger.warning(msg, *args)
+
 
 class JsonPlusSerializer(SerializerProtocol):
     """Serializer that uses ormsgpack, with optional fallbacks.
@@ -276,10 +297,16 @@ EXT_METHOD_SINGLE_ARG = 3
 EXT_PYDANTIC_V1 = 4
 EXT_PYDANTIC_V2 = 5
 EXT_NUMPY_ARRAY = 6
+EXT_DELTA_SNAPSHOT = 7
+EXT_DELTA_SENTINEL = 8
 
 
 def _msgpack_default(obj: Any) -> str | ormsgpack.Ext:
-    if hasattr(obj, "model_dump") and callable(obj.model_dump):  # pydantic v2
+    if isinstance(obj, _DeltaSentinel):
+        return ormsgpack.Ext(EXT_DELTA_SENTINEL, b"")
+    elif isinstance(obj, _DeltaSnapshot):
+        return ormsgpack.Ext(EXT_DELTA_SNAPSHOT, _msgpack_enc(obj.value))
+    elif hasattr(obj, "model_dump") and callable(obj.model_dump):  # pydantic v2
         return ormsgpack.Ext(
             EXT_PYDANTIC_V2,
             _msgpack_enc(
@@ -534,7 +561,9 @@ def _create_msgpack_ext_hook(
                     "name": name,
                 }
             )
-            logger.warning(
+            _warn_once(
+                _warned_unregistered_types,
+                key,
                 "Deserializing unregistered type %s.%s from checkpoint. "
                 "This will be blocked in a future version. "
                 "Set LANGGRAPH_STRICT_MSGPACK=true to block now, or add "
@@ -556,7 +585,9 @@ def _create_msgpack_ext_hook(
                 "name": name,
             }
         )
-        logger.warning(
+        _warn_once(
+            _warned_blocked_types,
+            key,
             "Blocked deserialization of %s.%s - not in allowed_msgpack_modules. "
             "Add to allowed_msgpack_modules to allow: [(%r, %r)]",
             module,
@@ -589,7 +620,15 @@ def _create_msgpack_ext_hook(
         return False
 
     def ext_hook(code: int, data: bytes) -> Any:
-        if code == EXT_CONSTRUCTOR_SINGLE_ARG:
+        if code == EXT_DELTA_SENTINEL:
+            return DELTA_SENTINEL
+        elif code == EXT_DELTA_SNAPSHOT:
+            return _DeltaSnapshot(
+                ormsgpack.unpackb(
+                    data, ext_hook=ext_hook, option=ormsgpack.OPT_NON_STR_KEYS
+                )
+            )
+        elif code == EXT_CONSTRUCTOR_SINGLE_ARG:
             try:
                 tup = ormsgpack.unpackb(
                     data, ext_hook=ext_hook, option=ormsgpack.OPT_NON_STR_KEYS

libs/checkpoint/langgraph/checkpoint/serde/types.py

@@ -1,6 +1,7 @@
 from collections.abc import Sequence
 from typing import (
     Any,
+    NamedTuple,
     Protocol,
     TypeVar,
     runtime_checkable,
@@ -14,6 +15,39 @@ INTERRUPT = "__interrupt__"
 RESUME = "__resume__"
 TASKS = "__pregel_tasks"
 
+
+class _DeltaSentinel:
+    """Singleton marker stored (as zero bytes) in checkpoint_blobs for a
+    DeltaChannel field. The actual per-step writes live in checkpoint_writes
+    and are replayed through the reducer at load time.
+
+    Compare with `is DELTA_SENTINEL` — `loads_typed` always returns the same
+    module-level instance.
+    """
+
+    __slots__ = ()
+
+    def __repr__(self) -> str:
+        return "DELTA_SENTINEL"
+
+
+DELTA_SENTINEL = _DeltaSentinel()
+
+
+class _DeltaSnapshot(NamedTuple):
+    """Snapshot blob for a DeltaChannel with finite snapshot_frequency.
+
+    Stored in checkpoint_blobs via the `EXT_DELTA_SNAPSHOT` msgpack ext code.
+    The ancestor walk in `_get_channel_writes_history` terminates when it
+    encounters this type (any non-sentinel blob stops the walk).
+
+    `from_checkpoint` reconstructs the channel value directly from `.value`
+    without replaying writes — the snapshot IS the accumulated state.
+    """
+
+    value: Any
+
+
 Value = TypeVar("Value", covariant=True)
 Update = TypeVar("Update", contravariant=True)
 C = TypeVar("C")

libs/checkpoint/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 description = "Library with base interfaces for LangGraph checkpoint savers."
 authors = []
 requires-python = ">=3.10"

libs/checkpoint/tests/test_encrypted.py

@@ -29,6 +29,8 @@ from langgraph.checkpoint.serde.jsonplus import (
     EXT_METHOD_SINGLE_ARG,
     JsonPlusSerializer,
     _msgpack_enc,
+    _warned_blocked_types,
+    _warned_unregistered_types,
 )
 
 
@@ -102,6 +104,13 @@ def test_msgpack_method_pathlib_blocked_encrypted_strict(
 class TestEncryptedSerializerMsgpackAllowlist:
     """Test msgpack allowlist behavior through EncryptedSerializer."""
 
+    @pytest.fixture(autouse=True)
+    def _reset_warned_types(self) -> None:
+        # Warning dedup state is process-global; reset per-test so each case
+        # sees a fresh slate and assertions about warning emission are stable.
+        _warned_unregistered_types.clear()
+        _warned_blocked_types.clear()
+
     def test_safe_types_no_warning(self, caplog: pytest.LogCaptureFixture) -> None:
         """Test safe types deserialize without warnings through encryption."""
         serde = _make_encrypted_serde()

libs/checkpoint/tests/test_jsonplus.py

@@ -35,6 +35,8 @@ from langgraph.checkpoint.serde.jsonplus import (
     JsonPlusSerializer,
     _msgpack_enc,
     _msgpack_ext_hook_to_json,
+    _warned_blocked_types,
+    _warned_unregistered_types,
 )
 from langgraph.store.base import Item
 
@@ -580,6 +582,14 @@ def test_msgpack_safe_types_no_warning(caplog: pytest.LogCaptureFixture) -> None
         assert result is not None
 
 
+@pytest.fixture(autouse=True)
+def _reset_warned_types() -> None:
+    # Warning dedup state is process-global; reset per-test so each case sees
+    # a fresh slate and assertions about warning emission are stable.
+    _warned_unregistered_types.clear()
+    _warned_blocked_types.clear()
+
+
 def test_msgpack_pydantic_warns_by_default(caplog: pytest.LogCaptureFixture) -> None:
     """Pydantic models not in allowlist should log warning but still deserialize."""
     current = _lg_msgpack.STRICT_MSGPACK_ENABLED
@@ -595,6 +605,12 @@ def test_msgpack_pydantic_warns_by_default(caplog: pytest.LogCaptureFixture) ->
     assert "unregistered type" in caplog.text.lower()
     assert "allowed_msgpack_modules" in caplog.text
     assert result == obj
+
+    # Second deserialization of the same type should NOT produce another warning
+    caplog.clear()
+    result2 = serde.loads_typed(dumped)
+    assert "unregistered type" not in caplog.text.lower()
+    assert result2 == obj
     _lg_msgpack.STRICT_MSGPACK_ENABLED = current
 
 
@@ -639,7 +655,6 @@ def test_msgpack_allowlist_silences_warning(caplog: pytest.LogCaptureFixture) ->
 
 def test_msgpack_none_blocks_unregistered(caplog: pytest.LogCaptureFixture) -> None:
     """allowed_msgpack_modules=None should block unregistered types."""
-
     serde = JsonPlusSerializer(allowed_msgpack_modules=None)
 
     obj = MyPydantic(foo="test", bar=42, inner=InnerPydantic(hello="world"))
@@ -657,7 +672,6 @@ def test_msgpack_allowlist_blocks_non_listed(
     caplog: pytest.LogCaptureFixture,
 ) -> None:
     """Allowlists should block unregistered types even if msgpack is enabled."""
-
     serde = JsonPlusSerializer(
         allowed_msgpack_modules=[("tests.test_jsonplus", "MyPydantic")]
     )
@@ -983,3 +997,16 @@ def test_msgpack_nested_pydantic_serializes_as_dict(
     # No blocking should occur - inner is serialized as dict, not ext
     assert "blocked" not in caplog.text.lower()
     assert result == obj
+
+
+def test_delta_sentinel_serde_round_trip() -> None:
+    from langgraph.checkpoint.base import DELTA_SENTINEL
+    from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+
+    serde = JsonPlusSerializer()
+    type_tag, blob = serde.dumps_typed(DELTA_SENTINEL)
+    # Zero-byte "delta" tag — no allowlist change needed.
+    assert type_tag == "delta"
+    assert blob == b""
+    loaded = serde.loads_typed((type_tag, blob))
+    assert loaded is DELTA_SENTINEL

libs/checkpoint/tests/test_memory.py

@@ -6,19 +6,32 @@ from langchain_core.runnables import RunnableConfig
 from pydantic import BaseModel
 
 from langgraph.checkpoint.base import (
+    DELTA_SENTINEL,
     Checkpoint,
     CheckpointMetadata,
     create_checkpoint,
     empty_checkpoint,
 )
 from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.checkpoint.serde.jsonplus import JsonPlusSerializer
+from langgraph.checkpoint.serde.jsonplus import (
+    JsonPlusSerializer,
+    _warned_blocked_types,
+    _warned_unregistered_types,
+)
 
 
 class MemoryPydantic(BaseModel):
     foo: str
 
 
+@pytest.fixture(autouse=True)
+def _reset_warned_types() -> None:
+    # Warning dedup state is process-global; reset per-test so each case sees
+    # a fresh slate and assertions about warning emission are stable.
+    _warned_unregistered_types.clear()
+    _warned_blocked_types.clear()
+
+
 class TestMemorySaver:
     @pytest.fixture(autouse=True)
     def setup(self) -> None:
@@ -196,8 +209,6 @@ class TestMemorySaver:
 
 
 async def test_memory_saver() -> None:
-    from langgraph.checkpoint.memory import InMemorySaver
-
     memory_saver = InMemorySaver()
     assert isinstance(memory_saver, InMemorySaver)
 
@@ -308,3 +319,492 @@ def test_memory_saver_with_allowlist_proxy_isolated() -> None:
     assert direct is not None
     expected = obj.model_dump() if hasattr(obj, "model_dump") else obj.dict()
     assert direct.checkpoint["channel_values"]["foo"] == expected
+
+
+class TestInMemorySaverDeltaChannel:
+    def test_load_blobs_returns_sentinel_for_delta_channel(self) -> None:
+        """_load_blobs returns DELTA_SENTINEL for delta channels (reconstruction deferred)."""
+        saver = InMemorySaver()
+        serde = JsonPlusSerializer()
+
+        thread_id, ns, channel = "t1", "", "messages"
+        v1 = "00000000000000000000000000000001.0000000000000000"
+
+        saver.blobs[(thread_id, ns, channel, v1)] = serde.dumps_typed(DELTA_SENTINEL)
+
+        cp1 = empty_checkpoint()
+        cp1["id"] = "cp1"
+        cp1["channel_versions"][channel] = v1
+        saver.storage[thread_id][ns] = {
+            "cp1": (serde.dumps_typed(cp1), serde.dumps_typed({}), None),
+        }
+
+        result = saver._load_blobs(thread_id, ns, {channel: v1})
+        assert channel in result
+        assert result[channel] is DELTA_SENTINEL
+
+    def test_get_channel_writes_collects_ancestor_writes_only(self) -> None:
+        """_get_channel_writes_history collects ancestor writes oldest→newest,
+        and excludes writes stored at the target checkpoint itself (those are
+        pending writes for the next step, applied separately by pregel)."""
+        saver = InMemorySaver()
+        serde = JsonPlusSerializer()
+
+        thread_id, ns, channel = "t1", "", "messages"
+
+        cp1 = empty_checkpoint()
+        cp1["id"] = "cp1"
+        cp2 = empty_checkpoint()
+        cp2["id"] = "cp2"
+        saver.storage[thread_id][ns] = {
+            "cp1": (serde.dumps_typed(cp1), serde.dumps_typed({}), None),
+            "cp2": (serde.dumps_typed(cp2), serde.dumps_typed({}), "cp1"),
+        }
+        # Writes stored at cp1 produced the cp1 snapshot; part of history.
+        saver.writes[(thread_id, ns, "cp1")][("task1", 0)] = (
+            "task1",
+            channel,
+            serde.dumps_typed({"content": "hi"}),
+            "",
+        )
+        # Writes stored at cp2 are pending — they will produce cp3 when the
+        # step that loaded cp2 completes. They MUST NOT appear in the
+        # reconstructed snapshot value at cp2.
+        saver.writes[(thread_id, ns, "cp2")][("task2", 0)] = (
+            "task2",
+            channel,
+            serde.dumps_typed({"content": "pending"}),
+            "",
+        )
+
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": "cp2",
+            }
+        }
+        result = saver._get_channel_writes_history(config, channel)
+        assert result.seed is DELTA_SENTINEL
+        values = [v for _, _, v in result.writes]
+        assert values == [{"content": "hi"}]
+
+    def test_get_channel_writes_at_root_returns_empty(self) -> None:
+        """Reconstructing the root checkpoint's state: no ancestors → []."""
+        saver = InMemorySaver()
+        serde = JsonPlusSerializer()
+        thread_id, ns, channel = "t1", "", "messages"
+
+        cp1 = empty_checkpoint()
+        cp1["id"] = "cp1"
+        saver.storage[thread_id][ns] = {
+            "cp1": (serde.dumps_typed(cp1), serde.dumps_typed({}), None),
+        }
+        saver.writes[(thread_id, ns, "cp1")][("task1", 0)] = (
+            "task1",
+            channel,
+            serde.dumps_typed({"content": "pending"}),
+            "",
+        )
+
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": "cp1",
+            }
+        }
+        result = saver._get_channel_writes_history(config, channel)
+        assert result.seed is DELTA_SENTINEL
+        assert result.writes == []
+
+
+class TestBaseFallbackGetChannelWrites:
+    """Exercises the `BaseCheckpointSaver._get_channel_writes_history` default
+    implementation — the path third-party savers inherit when they don't
+    override `_get_channel_writes_history` themselves.
+
+    Regression guard for a bug where the fallback passed the caller's config
+    (with `checkpoint_id`) straight to `self.list()`, which most savers
+    collapse to a single row — causing the fallback to return `[]`.
+    """
+
+    def _build_saver_with_chain(self) -> tuple[InMemorySaver, str, str]:
+        """Build an InMemorySaver with a 3-checkpoint chain and per-step writes
+        for a `messages` channel.
+
+        Returns `(saver, thread_id, namespace)`. The saver subclass deletes the
+        InMemorySaver override so the base class fallback is exercised.
+        """
+
+        class _ThirdPartyStyleSaver(InMemorySaver):
+            _get_channel_writes_history = (
+                InMemorySaver.__mro__[1]._get_channel_writes_history  # type: ignore[attr-defined]
+            )
+            _aget_channel_writes_history = (
+                InMemorySaver.__mro__[1]._aget_channel_writes_history  # type: ignore[attr-defined]
+            )
+
+        saver = _ThirdPartyStyleSaver()
+        serde = JsonPlusSerializer()
+        thread_id, ns, channel = "t1", "", "messages"
+
+        cp0 = empty_checkpoint()
+        cp0["id"] = "00000000000000000000000000000001.0000000000000000"
+        cp1 = empty_checkpoint()
+        cp1["id"] = "00000000000000000000000000000002.0000000000000000"
+        cp2 = empty_checkpoint()
+        cp2["id"] = "00000000000000000000000000000003.0000000000000000"
+        saver.storage[thread_id][ns] = {
+            cp0["id"]: (serde.dumps_typed(cp0), serde.dumps_typed({}), None),
+            cp1["id"]: (serde.dumps_typed(cp1), serde.dumps_typed({}), cp0["id"]),
+            cp2["id"]: (serde.dumps_typed(cp2), serde.dumps_typed({}), cp1["id"]),
+        }
+        # Writes under cp0 produced cp1's state; writes under cp1 produced cp2's.
+        saver.writes[(thread_id, ns, cp0["id"])][("task1", 0)] = (
+            "task1",
+            channel,
+            serde.dumps_typed({"content": "first"}),
+            "",
+        )
+        saver.writes[(thread_id, ns, cp1["id"])][("task2", 0)] = (
+            "task2",
+            channel,
+            serde.dumps_typed({"content": "second"}),
+            "",
+        )
+        return saver, thread_id, ns
+
+    def test_fallback_returns_ancestor_writes_oldest_first(self) -> None:
+        saver, thread_id, ns = self._build_saver_with_chain()
+        target_id = "00000000000000000000000000000003.0000000000000000"
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": target_id,
+            }
+        }
+
+        result = saver._get_channel_writes_history(config, "messages")
+
+        assert result.seed is DELTA_SENTINEL
+        values = [v for _, _, v in result.writes]
+        assert values == [{"content": "first"}, {"content": "second"}]
+
+    async def test_async_fallback_returns_ancestor_writes_oldest_first(self) -> None:
+        saver, thread_id, ns = self._build_saver_with_chain()
+        target_id = "00000000000000000000000000000003.0000000000000000"
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": target_id,
+            }
+        }
+
+        result = await saver._aget_channel_writes_history(config, "messages")
+
+        assert result.seed is DELTA_SENTINEL
+        values = [v for _, _, v in result.writes]
+        assert values == [{"content": "first"}, {"content": "second"}]
+
+    async def test_async_fallback_concurrent_tasks_do_not_interfere(self) -> None:
+        """Regression: the re-entrancy guard must be task-local, not thread-local.
+
+        Two concurrent `_aget_channel_writes_history` calls on the same
+        event-loop thread must each see their full reconstructed writes. A
+        `threading.local()` guard would let whichever task set it first
+        short-circuit the other to `writes=[]`.
+        """
+        import asyncio
+
+        saver, thread_id, ns = self._build_saver_with_chain()
+
+        # Force the two tasks to interleave across the `set(True)` boundary:
+        # each `aget_tuple` yields control, so if the guard were thread-local
+        # the second task would observe `active=True` set by the first.
+        orig_aget_tuple = saver.aget_tuple
+
+        async def slow_aget_tuple(config: RunnableConfig) -> Any:
+            await asyncio.sleep(0)
+            return await orig_aget_tuple(config)
+
+        saver.aget_tuple = slow_aget_tuple  # type: ignore[method-assign]
+
+        target_id = "00000000000000000000000000000003.0000000000000000"
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": target_id,
+            }
+        }
+
+        results = await asyncio.gather(
+            saver._aget_channel_writes_history(config, "messages"),
+            saver._aget_channel_writes_history(config, "messages"),
+        )
+
+        expected_values = [{"content": "first"}, {"content": "second"}]
+        for result in results:
+            assert result.seed is DELTA_SENTINEL
+            values = [v for _, _, v in result.writes]
+            assert values == expected_values
+
+
+class TestPreDeltaBlobTerminator:
+    """Verify the pre-delta blob terminator: when the ancestor walk hits a
+    checkpoint whose blob for the channel is a real value (not
+    DELTA_SENTINEL), reconstruction seeds from it and stops. This guards
+
+      * back-compat: a thread written by pre-delta code, then extended under
+        delta — reconstruction must return the correct value without walking
+        past the last pre-delta ancestor;
+      * perf: without the terminator, every reconstruct-after-migration would
+        walk all the way to the thread root.
+    """
+
+    def _build_mixed_thread(self) -> tuple[InMemorySaver, str, str, str, str]:
+        """Three-checkpoint chain: cp1 (pre-delta, blob=[A]), cp2 (delta,
+        write=B), cp3 (delta, write=C). Reconstructing at cp3 must yield
+        seed=[A] + writes=[B, C].
+
+        Returns `(saver, thread_id, ns, channel, cp3_id)`.
+        """
+        saver = InMemorySaver()
+        serde = JsonPlusSerializer()
+        thread_id, ns, channel = "t1", "", "messages"
+
+        v1 = "00000000000000000000000000000001.0"
+        v2 = "00000000000000000000000000000002.0"
+        v3 = "00000000000000000000000000000003.0"
+
+        # Pre-delta: cp1 stored a real blob for the channel.
+        saver.blobs[(thread_id, ns, channel, v1)] = serde.dumps_typed(["A"])
+        # Delta-era: cp2 and cp3 store sentinels; real writes in checkpoint_writes.
+        saver.blobs[(thread_id, ns, channel, v2)] = serde.dumps_typed(DELTA_SENTINEL)
+        saver.blobs[(thread_id, ns, channel, v3)] = serde.dumps_typed(DELTA_SENTINEL)
+
+        cp1 = empty_checkpoint()
+        cp1["id"] = "cp1"
+        cp1["channel_versions"][channel] = v1
+        cp2 = empty_checkpoint()
+        cp2["id"] = "cp2"
+        cp2["channel_versions"][channel] = v2
+        cp3 = empty_checkpoint()
+        cp3["id"] = "cp3"
+        cp3["channel_versions"][channel] = v3
+
+        saver.storage[thread_id][ns] = {
+            "cp1": (serde.dumps_typed(cp1), serde.dumps_typed({}), None),
+            "cp2": (serde.dumps_typed(cp2), serde.dumps_typed({}), "cp1"),
+            "cp3": (serde.dumps_typed(cp3), serde.dumps_typed({}), "cp2"),
+        }
+        # Write under cp1 would be from the pre-delta era and MUST be ignored
+        # (the blob already captures it). We add one and assert it is not
+        # folded into the reconstructed result.
+        saver.writes[(thread_id, ns, "cp1")][("task0", 0)] = (
+            "task0",
+            channel,
+            serde.dumps_typed("PRE-DELTA-WRITE"),
+            "",
+        )
+        saver.writes[(thread_id, ns, "cp2")][("task2", 0)] = (
+            "task2",
+            channel,
+            serde.dumps_typed("B"),
+            "",
+        )
+        saver.writes[(thread_id, ns, "cp3")][("task3", 0)] = (
+            "task3",
+            channel,
+            serde.dumps_typed("PENDING-AT-TARGET"),
+            "",
+        )
+        return saver, thread_id, ns, channel, "cp3"
+
+    def test_seed_from_pre_delta_ancestor_blob(self) -> None:
+        saver, thread_id, ns, channel, target = self._build_mixed_thread()
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": target,
+            }
+        }
+
+        result = saver._get_channel_writes_history(config, channel)
+
+        # Seed came from the pre-delta blob at cp1.
+        assert result.seed == ["A"]
+        # Delta-era writes from cp2 replay through the reducer on top of seed.
+        # cp3 is the target — its own write is pending for the NEXT step and
+        # must be excluded.
+        values = [v for _, _, v in result.writes]
+        assert values == ["B"]
+
+    def test_pre_delta_blob_terminates_walk_before_older_writes(self) -> None:
+        """Writes stored at the pre-delta ancestor itself must not be replayed
+        (the blob subsumes them)."""
+        saver, thread_id, ns, channel, target = self._build_mixed_thread()
+        config: RunnableConfig = {
+            "configurable": {
+                "thread_id": thread_id,
+                "checkpoint_ns": ns,
+                "checkpoint_id": target,
+            }
+        }
+
+        result = saver._get_channel_writes_history(config, channel)
+
+        values = [v for _, _, v in result.writes]
+        # The pre-delta write under cp1 must not appear (the blob subsumes it).
+        assert "PRE-DELTA-WRITE" not in values
+        # And the pending write at the target is never folded in.
+        assert "PENDING-AT-TARGET" not in values
+
+
+class TestInMemorySaverPrune:
+    """Tests for InMemorySaver.prune with DeltaChannel awareness."""
+
+    def _build_chain(
+        self,
+        saver: InMemorySaver,
+        thread_id: str,
+        ns: str,
+        channel: str,
+        n: int,
+        *,
+        snapshot_at: set[int] | None = None,
+    ) -> list[str]:
+        """Build a chain of n checkpoints with DELTA_SENTINEL blobs.
+
+        If snapshot_at is provided, writes a _DeltaSnapshot blob at those steps.
+        Returns list of checkpoint IDs in order (oldest first).
+        """
+        from langgraph.checkpoint.serde.types import _DeltaSnapshot
+
+        serde = saver.serde
+        cp_ids = []
+        parent_id = None
+        ver_base = "0000000000000000000000000000000{i}.0000000000000000"
+
+        for i in range(n):
+            cp_id = f"cp{i:04d}"
+            ver = ver_base.format(i=i)
+            cp = empty_checkpoint()
+            cp["id"] = cp_id
+            cp["channel_versions"][channel] = ver
+
+            if snapshot_at and i in snapshot_at:
+                blob = serde.dumps_typed(_DeltaSnapshot(value=[f"msg{i}"]))
+            else:
+                blob = serde.dumps_typed(DELTA_SENTINEL)
+
+            saver.blobs[(thread_id, ns, channel, ver)] = blob
+            saver.storage[thread_id][ns][cp_id] = (
+                serde.dumps_typed(cp),
+                serde.dumps_typed({}),
+                parent_id,
+            )
+            # Add a dummy write for this checkpoint
+            saver.writes[(thread_id, ns, cp_id)][("task", i)] = (
+                "task",
+                channel,
+                serde.dumps_typed(f"write{i}"),
+                "",
+            )
+            cp_ids.append(cp_id)
+            parent_id = cp_id
+
+        return cp_ids
+
+    def test_prune_pure_delta_keeps_all(self) -> None:
+        """With no snapshots, all checkpoints are required for reconstruction."""
+        saver = InMemorySaver()
+        thread_id, ns, channel = "t1", "", "messages"
+        cp_ids = self._build_chain(saver, thread_id, ns, channel, n=5)
+
+        saver.prune([thread_id], strategy="keep_latest")
+
+        # All checkpoints must be retained (walk needs the full chain)
+        remaining = set(saver.storage[thread_id][ns].keys())
+        assert remaining == set(cp_ids)
+
+    def test_prune_with_snapshot_removes_pre_snapshot_checkpoints(self) -> None:
+        """Checkpoints older than the nearest snapshot can be safely pruned."""
+        saver = InMemorySaver()
+        thread_id, ns, channel = "t1", "", "messages"
+        # Snapshot at step 2; steps 3 and 4 are sentinels
+        cp_ids = self._build_chain(saver, thread_id, ns, channel, n=5, snapshot_at={2})
+
+        saver.prune([thread_id], strategy="keep_latest")
+
+        remaining = set(saver.storage[thread_id][ns].keys())
+        # cp0, cp1 (before snapshot) must be gone; cp2, cp3, cp4 must remain
+        assert cp_ids[0] not in remaining  # pre-snapshot
+        assert cp_ids[1] not in remaining  # pre-snapshot
+        assert cp_ids[2] in remaining  # the snapshot itself
+        assert cp_ids[3] in remaining  # sentinel after snapshot
+        assert cp_ids[4] in remaining  # latest
+
+    def test_prune_removes_orphaned_blobs(self) -> None:
+        """Blob entries for pruned checkpoints are cleaned up."""
+        saver = InMemorySaver()
+        thread_id, ns, channel = "t1", "", "messages"
+        self._build_chain(saver, thread_id, ns, channel, n=4, snapshot_at={1})
+        saver.prune([thread_id], strategy="keep_latest")
+
+        # cp0 blob should be gone (pruned); cp1, cp2, cp3 blobs remain
+        assert (
+            thread_id,
+            ns,
+            channel,
+            f"0000000000000000000000000000000{0}.0000000000000000",
+        ) not in saver.blobs
+        for i in range(1, 4):
+            ver = f"0000000000000000000000000000000{i}.0000000000000000"
+            assert (thread_id, ns, channel, ver) in saver.blobs
+
+    def test_prune_removes_writes_for_pruned_checkpoints(self) -> None:
+        """checkpoint_writes for pruned checkpoints are deleted."""
+        saver = InMemorySaver()
+        thread_id, ns, channel = "t1", "", "messages"
+        cp_ids = self._build_chain(saver, thread_id, ns, channel, n=4, snapshot_at={1})
+
+        saver.prune([thread_id], strategy="keep_latest")
+
+        # writes for cp0 must be gone
+        assert (thread_id, ns, cp_ids[0]) not in saver.writes
+        # writes for cp1+ must remain (they're in the walk chain)
+        for cp_id in cp_ids[1:]:
+            assert (thread_id, ns, cp_id) in saver.writes
+
+    def test_prune_delete_strategy_removes_everything(self) -> None:
+        """strategy='delete' removes all checkpoints for the thread."""
+        saver = InMemorySaver()
+        thread_id, ns, channel = "t1", "", "messages"
+        self._build_chain(saver, thread_id, ns, channel, n=3)
+
+        saver.prune([thread_id], strategy="delete")
+
+        assert not saver.storage.get(thread_id, {}).get(ns)
+        assert not any(k[0] == thread_id for k in saver.writes)
+        assert not any(k[0] == thread_id for k in saver.blobs)
+
+    def test_prune_non_delta_channel_always_pruneable(self) -> None:
+        """A channel with full snapshot blobs (no sentinels) allows full prune."""
+
+        saver = InMemorySaver()
+        thread_id, ns, channel = "t1", "", "messages"
+        # All snapshots, no sentinels
+        cp_ids = self._build_chain(
+            saver, thread_id, ns, channel, n=4, snapshot_at={0, 1, 2, 3}
+        )
+
+        saver.prune([thread_id], strategy="keep_latest")
+
+        remaining = set(saver.storage[thread_id][ns].keys())
+        # Only the latest checkpoint is needed (all blobs are snapshots)
+        assert remaining == {cp_ids[-1]}

libs/checkpoint/uv.lock

@@ -286,7 +286,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
@@ -369,7 +369,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.6.4"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -379,11 +379,12 @@ dependencies = [
     { name = "requests" },
     { name = "requests-toolbelt" },
     { name = "uuid-utils" },
+    { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/85/9c7933052a997da1b85bc5c774f3865e9b1da1c8d71541ea133178b13229/langsmith-0.6.4.tar.gz", hash = "sha256:36f7223a01c218079fbb17da5e536ebbaf5c1468c028abe070aa3ae59bc99ec8", size = 919964, upload-time = "2026-01-15T20:02:28.873Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/0f/09a6637a7ba777eb307b7c80852d9ee26438e2bdafbad6fcc849ff9d9192/langsmith-0.6.4-py3-none-any.whl", hash = "sha256:ac4835860160be371042c7adbba3cb267bcf8d96a5ea976c33a8a4acad6c5486", size = 283503, upload-time = "2026-01-15T20:02:26.662Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]
@@ -1515,6 +1516,124 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/33/e8/e40370e6d74ddba47f002a32919d91310d6074130fe4e17dabcafc15cbf1/watchdog-6.0.0-py3-none-win_ia64.whl", hash = "sha256:a1914259fa9e1454315171103c6a30961236f508b9b623eae470268bbcc6a22f", size = 79067, upload-time = "2024-11-01T14:07:11.845Z" },
 ]
 
+[[package]]
+name = "xxhash"
+version = "3.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/02/84/30869e01909fb37a6cc7e18688ee8bf1e42d57e7e0777636bd47524c43c7/xxhash-3.6.0.tar.gz", hash = "sha256:f0162a78b13a0d7617b2845b90c763339d1f1d82bb04a4b07f4ab535cc5e05d6", size = 85160, upload-time = "2025-10-02T14:37:08.097Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/34/ee/f9f1d656ad168681bb0f6b092372c1e533c4416b8069b1896a175c46e484/xxhash-3.6.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:87ff03d7e35c61435976554477a7f4cd1704c3596a89a8300d5ce7fc83874a71", size = 32845, upload-time = "2025-10-02T14:33:51.573Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/b1/93508d9460b292c74a09b83d16750c52a0ead89c51eea9951cb97a60d959/xxhash-3.6.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f572dfd3d0e2eb1a57511831cf6341242f5a9f8298a45862d085f5b93394a27d", size = 30807, upload-time = "2025-10-02T14:33:52.964Z" },
+    { url = "https://files.pythonhosted.org/packages/07/55/28c93a3662f2d200c70704efe74aab9640e824f8ce330d8d3943bf7c9b3c/xxhash-3.6.0-cp310-cp310-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:89952ea539566b9fed2bbd94e589672794b4286f342254fad28b149f9615fef8", size = 193786, upload-time = "2025-10-02T14:33:54.272Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/96/fec0be9bb4b8f5d9c57d76380a366f31a1781fb802f76fc7cda6c84893c7/xxhash-3.6.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:48e6f2ffb07a50b52465a1032c3cf1f4a5683f944acaca8a134a2f23674c2058", size = 212830, upload-time = "2025-10-02T14:33:55.706Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a0/c706845ba77b9611f81fd2e93fad9859346b026e8445e76f8c6fd057cc6d/xxhash-3.6.0-cp310-cp310-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b5b848ad6c16d308c3ac7ad4ba6bede80ed5df2ba8ed382f8932df63158dd4b2", size = 211606, upload-time = "2025-10-02T14:33:57.133Z" },
+    { url = "https://files.pythonhosted.org/packages/67/1e/164126a2999e5045f04a69257eea946c0dc3e86541b400d4385d646b53d7/xxhash-3.6.0-cp310-cp310-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:a034590a727b44dd8ac5914236a7b8504144447a9682586c3327e935f33ec8cc", size = 444872, upload-time = "2025-10-02T14:33:58.446Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/4b/55ab404c56cd70a2cf5ecfe484838865d0fea5627365c6c8ca156bd09c8f/xxhash-3.6.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8a8f1972e75ebdd161d7896743122834fe87378160c20e97f8b09166213bf8cc", size = 193217, upload-time = "2025-10-02T14:33:59.724Z" },
+    { url = "https://files.pythonhosted.org/packages/45/e6/52abf06bac316db33aa269091ae7311bd53cfc6f4b120ae77bac1b348091/xxhash-3.6.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:ee34327b187f002a596d7b167ebc59a1b729e963ce645964bbc050d2f1b73d07", size = 210139, upload-time = "2025-10-02T14:34:02.041Z" },
+    { url = "https://files.pythonhosted.org/packages/34/37/db94d490b8691236d356bc249c08819cbcef9273a1a30acf1254ff9ce157/xxhash-3.6.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:339f518c3c7a850dd033ab416ea25a692759dc7478a71131fe8869010d2b75e4", size = 197669, upload-time = "2025-10-02T14:34:03.664Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/36/c4f219ef4a17a4f7a64ed3569bc2b5a9c8311abdb22249ac96093625b1a4/xxhash-3.6.0-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:bf48889c9630542d4709192578aebbd836177c9f7a4a2778a7d6340107c65f06", size = 210018, upload-time = "2025-10-02T14:34:05.325Z" },
+    { url = "https://files.pythonhosted.org/packages/fd/06/bfac889a374fc2fc439a69223d1750eed2e18a7db8514737ab630534fa08/xxhash-3.6.0-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:5576b002a56207f640636056b4160a378fe36a58db73ae5c27a7ec8db35f71d4", size = 413058, upload-time = "2025-10-02T14:34:06.925Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/d1/555d8447e0dd32ad0930a249a522bb2e289f0d08b6b16204cfa42c1f5a0c/xxhash-3.6.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:af1f3278bd02814d6dedc5dec397993b549d6f16c19379721e5a1d31e132c49b", size = 190628, upload-time = "2025-10-02T14:34:08.669Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/15/8751330b5186cedc4ed4b597989882ea05e0408b53fa47bcb46a6125bfc6/xxhash-3.6.0-cp310-cp310-win32.whl", hash = "sha256:aed058764db109dc9052720da65fafe84873b05eb8b07e5e653597951af57c3b", size = 30577, upload-time = "2025-10-02T14:34:10.234Z" },
+    { url = "https://files.pythonhosted.org/packages/bb/cc/53f87e8b5871a6eb2ff7e89c48c66093bda2be52315a8161ddc54ea550c4/xxhash-3.6.0-cp310-cp310-win_amd64.whl", hash = "sha256:e82da5670f2d0d98950317f82a0e4a0197150ff19a6df2ba40399c2a3b9ae5fb", size = 31487, upload-time = "2025-10-02T14:34:11.618Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/00/60f9ea3bb697667a14314d7269956f58bf56bb73864f8f8d52a3c2535e9a/xxhash-3.6.0-cp310-cp310-win_arm64.whl", hash = "sha256:4a082ffff8c6ac07707fb6b671caf7c6e020c75226c561830b73d862060f281d", size = 27863, upload-time = "2025-10-02T14:34:12.619Z" },
+    { url = "https://files.pythonhosted.org/packages/17/d4/cc2f0400e9154df4b9964249da78ebd72f318e35ccc425e9f403c392f22a/xxhash-3.6.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:b47bbd8cf2d72797f3c2772eaaac0ded3d3af26481a26d7d7d41dc2d3c46b04a", size = 32844, upload-time = "2025-10-02T14:34:14.037Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/ec/1cc11cd13e26ea8bc3cb4af4eaadd8d46d5014aebb67be3f71fb0b68802a/xxhash-3.6.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:2b6821e94346f96db75abaa6e255706fb06ebd530899ed76d32cd99f20dc52fa", size = 30809, upload-time = "2025-10-02T14:34:15.484Z" },
+    { url = "https://files.pythonhosted.org/packages/04/5f/19fe357ea348d98ca22f456f75a30ac0916b51c753e1f8b2e0e6fb884cce/xxhash-3.6.0-cp311-cp311-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d0a9751f71a1a65ce3584e9cae4467651c7e70c9d31017fa57574583a4540248", size = 194665, upload-time = "2025-10-02T14:34:16.541Z" },
+    { url = "https://files.pythonhosted.org/packages/90/3b/d1f1a8f5442a5fd8beedae110c5af7604dc37349a8e16519c13c19a9a2de/xxhash-3.6.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b29ee68625ab37b04c0b40c3fafdf24d2f75ccd778333cfb698f65f6c463f62", size = 213550, upload-time = "2025-10-02T14:34:17.878Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/ef/3a9b05eb527457d5db13a135a2ae1a26c80fecd624d20f3e8dcc4cb170f3/xxhash-3.6.0-cp311-cp311-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:6812c25fe0d6c36a46ccb002f40f27ac903bf18af9f6dd8f9669cb4d176ab18f", size = 212384, upload-time = "2025-10-02T14:34:19.182Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/18/ccc194ee698c6c623acbf0f8c2969811a8a4b6185af5e824cd27b9e4fd3e/xxhash-3.6.0-cp311-cp311-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4ccbff013972390b51a18ef1255ef5ac125c92dc9143b2d1909f59abc765540e", size = 445749, upload-time = "2025-10-02T14:34:20.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a5/86/cf2c0321dc3940a7aa73076f4fd677a0fb3e405cb297ead7d864fd90847e/xxhash-3.6.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:297b7fbf86c82c550e12e8fb71968b3f033d27b874276ba3624ea868c11165a8", size = 193880, upload-time = "2025-10-02T14:34:22.431Z" },
+    { url = "https://files.pythonhosted.org/packages/82/fb/96213c8560e6f948a1ecc9a7613f8032b19ee45f747f4fca4eb31bb6d6ed/xxhash-3.6.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:dea26ae1eb293db089798d3973a5fc928a18fdd97cc8801226fae705b02b14b0", size = 210912, upload-time = "2025-10-02T14:34:23.937Z" },
+    { url = "https://files.pythonhosted.org/packages/40/aa/4395e669b0606a096d6788f40dbdf2b819d6773aa290c19e6e83cbfc312f/xxhash-3.6.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:7a0b169aafb98f4284f73635a8e93f0735f9cbde17bd5ec332480484241aaa77", size = 198654, upload-time = "2025-10-02T14:34:25.644Z" },
+    { url = "https://files.pythonhosted.org/packages/67/74/b044fcd6b3d89e9b1b665924d85d3f400636c23590226feb1eb09e1176ce/xxhash-3.6.0-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:08d45aef063a4531b785cd72de4887766d01dc8f362a515693df349fdb825e0c", size = 210867, upload-time = "2025-10-02T14:34:27.203Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/fd/3ce73bf753b08cb19daee1eb14aa0d7fe331f8da9c02dd95316ddfe5275e/xxhash-3.6.0-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:929142361a48ee07f09121fe9e96a84950e8d4df3bb298ca5d88061969f34d7b", size = 414012, upload-time = "2025-10-02T14:34:28.409Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/b3/5a4241309217c5c876f156b10778f3ab3af7ba7e3259e6d5f5c7d0129eb2/xxhash-3.6.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:51312c768403d8540487dbbfb557454cfc55589bbde6424456951f7fcd4facb3", size = 191409, upload-time = "2025-10-02T14:34:29.696Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/01/99bfbc15fb9abb9a72b088c1d95219fc4782b7d01fc835bd5744d66dd0b8/xxhash-3.6.0-cp311-cp311-win32.whl", hash = "sha256:d1927a69feddc24c987b337ce81ac15c4720955b667fe9b588e02254b80446fd", size = 30574, upload-time = "2025-10-02T14:34:31.028Z" },
+    { url = "https://files.pythonhosted.org/packages/65/79/9d24d7f53819fe301b231044ea362ce64e86c74f6e8c8e51320de248b3e5/xxhash-3.6.0-cp311-cp311-win_amd64.whl", hash = "sha256:26734cdc2d4ffe449b41d186bbeac416f704a482ed835d375a5c0cb02bc63fef", size = 31481, upload-time = "2025-10-02T14:34:32.062Z" },
+    { url = "https://files.pythonhosted.org/packages/30/4e/15cd0e3e8772071344eab2961ce83f6e485111fed8beb491a3f1ce100270/xxhash-3.6.0-cp311-cp311-win_arm64.whl", hash = "sha256:d72f67ef8bf36e05f5b6c65e8524f265bd61071471cd4cf1d36743ebeeeb06b7", size = 27861, upload-time = "2025-10-02T14:34:33.555Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/07/d9412f3d7d462347e4511181dea65e47e0d0e16e26fbee2ea86a2aefb657/xxhash-3.6.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:01362c4331775398e7bb34e3ab403bc9ee9f7c497bc7dee6272114055277dd3c", size = 32744, upload-time = "2025-10-02T14:34:34.622Z" },
+    { url = "https://files.pythonhosted.org/packages/79/35/0429ee11d035fc33abe32dca1b2b69e8c18d236547b9a9b72c1929189b9a/xxhash-3.6.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b7b2df81a23f8cb99656378e72501b2cb41b1827c0f5a86f87d6b06b69f9f204", size = 30816, upload-time = "2025-10-02T14:34:36.043Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/f2/57eb99aa0f7d98624c0932c5b9a170e1806406cdbcdb510546634a1359e0/xxhash-3.6.0-cp312-cp312-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:dc94790144e66b14f67b10ac8ed75b39ca47536bf8800eb7c24b50271ea0c490", size = 194035, upload-time = "2025-10-02T14:34:37.354Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/ed/6224ba353690d73af7a3f1c7cdb1fc1b002e38f783cb991ae338e1eb3d79/xxhash-3.6.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:93f107c673bccf0d592cdba077dedaf52fe7f42dcd7676eba1f6d6f0c3efffd2", size = 212914, upload-time = "2025-10-02T14:34:38.6Z" },
+    { url = "https://files.pythonhosted.org/packages/38/86/fb6b6130d8dd6b8942cc17ab4d90e223653a89aa32ad2776f8af7064ed13/xxhash-3.6.0-cp312-cp312-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:2aa5ee3444c25b69813663c9f8067dcfaa2e126dc55e8dddf40f4d1c25d7effa", size = 212163, upload-time = "2025-10-02T14:34:39.872Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/dc/e84875682b0593e884ad73b2d40767b5790d417bde603cceb6878901d647/xxhash-3.6.0-cp312-cp312-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:f7f99123f0e1194fa59cc69ad46dbae2e07becec5df50a0509a808f90a0f03f0", size = 445411, upload-time = "2025-10-02T14:34:41.569Z" },
+    { url = "https://files.pythonhosted.org/packages/11/4f/426f91b96701ec2f37bb2b8cec664eff4f658a11f3fa9d94f0a887ea6d2b/xxhash-3.6.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:49e03e6fe2cac4a1bc64952dd250cf0dbc5ef4ebb7b8d96bce82e2de163c82a2", size = 193883, upload-time = "2025-10-02T14:34:43.249Z" },
+    { url = "https://files.pythonhosted.org/packages/53/5a/ddbb83eee8e28b778eacfc5a85c969673e4023cdeedcfcef61f36731610b/xxhash-3.6.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:bd17fede52a17a4f9a7bc4472a5867cb0b160deeb431795c0e4abe158bc784e9", size = 210392, upload-time = "2025-10-02T14:34:45.042Z" },
+    { url = "https://files.pythonhosted.org/packages/1e/c2/ff69efd07c8c074ccdf0a4f36fcdd3d27363665bcdf4ba399abebe643465/xxhash-3.6.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:6fb5f5476bef678f69db04f2bd1efbed3030d2aba305b0fc1773645f187d6a4e", size = 197898, upload-time = "2025-10-02T14:34:46.302Z" },
+    { url = "https://files.pythonhosted.org/packages/58/ca/faa05ac19b3b622c7c9317ac3e23954187516298a091eb02c976d0d3dd45/xxhash-3.6.0-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:843b52f6d88071f87eba1631b684fcb4b2068cd2180a0224122fe4ef011a9374", size = 210655, upload-time = "2025-10-02T14:34:47.571Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/7a/06aa7482345480cc0cb597f5c875b11a82c3953f534394f620b0be2f700c/xxhash-3.6.0-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:7d14a6cfaf03b1b6f5f9790f76880601ccc7896aff7ab9cd8978a939c1eb7e0d", size = 414001, upload-time = "2025-10-02T14:34:49.273Z" },
+    { url = "https://files.pythonhosted.org/packages/23/07/63ffb386cd47029aa2916b3d2f454e6cc5b9f5c5ada3790377d5430084e7/xxhash-3.6.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:418daf3db71e1413cfe211c2f9a528456936645c17f46b5204705581a45390ae", size = 191431, upload-time = "2025-10-02T14:34:50.798Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/93/14fde614cadb4ddf5e7cebf8918b7e8fac5ae7861c1875964f17e678205c/xxhash-3.6.0-cp312-cp312-win32.whl", hash = "sha256:50fc255f39428a27299c20e280d6193d8b63b8ef8028995323bf834a026b4fbb", size = 30617, upload-time = "2025-10-02T14:34:51.954Z" },
+    { url = "https://files.pythonhosted.org/packages/13/5d/0d125536cbe7565a83d06e43783389ecae0c0f2ed037b48ede185de477c0/xxhash-3.6.0-cp312-cp312-win_amd64.whl", hash = "sha256:c0f2ab8c715630565ab8991b536ecded9416d615538be8ecddce43ccf26cbc7c", size = 31534, upload-time = "2025-10-02T14:34:53.276Z" },
+    { url = "https://files.pythonhosted.org/packages/54/85/6ec269b0952ec7e36ba019125982cf11d91256a778c7c3f98a4c5043d283/xxhash-3.6.0-cp312-cp312-win_arm64.whl", hash = "sha256:eae5c13f3bc455a3bbb68bdc513912dc7356de7e2280363ea235f71f54064829", size = 27876, upload-time = "2025-10-02T14:34:54.371Z" },
+    { url = "https://files.pythonhosted.org/packages/33/76/35d05267ac82f53ae9b0e554da7c5e281ee61f3cad44c743f0fcd354f211/xxhash-3.6.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:599e64ba7f67472481ceb6ee80fa3bd828fd61ba59fb11475572cc5ee52b89ec", size = 32738, upload-time = "2025-10-02T14:34:55.839Z" },
+    { url = "https://files.pythonhosted.org/packages/31/a8/3fbce1cd96534a95e35d5120637bf29b0d7f5d8fa2f6374e31b4156dd419/xxhash-3.6.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7d8b8aaa30fca4f16f0c84a5c8d7ddee0e25250ec2796c973775373257dde8f1", size = 30821, upload-time = "2025-10-02T14:34:57.219Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/ea/d387530ca7ecfa183cb358027f1833297c6ac6098223fd14f9782cd0015c/xxhash-3.6.0-cp313-cp313-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:d597acf8506d6e7101a4a44a5e428977a51c0fadbbfd3c39650cca9253f6e5a6", size = 194127, upload-time = "2025-10-02T14:34:59.21Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/0c/71435dcb99874b09a43b8d7c54071e600a7481e42b3e3ce1eb5226a5711a/xxhash-3.6.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:858dc935963a33bc33490128edc1c12b0c14d9c7ebaa4e387a7869ecc4f3e263", size = 212975, upload-time = "2025-10-02T14:35:00.816Z" },
+    { url = "https://files.pythonhosted.org/packages/84/7a/c2b3d071e4bb4a90b7057228a99b10d51744878f4a8a6dd643c8bd897620/xxhash-3.6.0-cp313-cp313-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:ba284920194615cb8edf73bf52236ce2e1664ccd4a38fdb543506413529cc546", size = 212241, upload-time = "2025-10-02T14:35:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/81/5f/640b6eac0128e215f177df99eadcd0f1b7c42c274ab6a394a05059694c5a/xxhash-3.6.0-cp313-cp313-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:4b54219177f6c6674d5378bd862c6aedf64725f70dd29c472eaae154df1a2e89", size = 445471, upload-time = "2025-10-02T14:35:03.61Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1e/3c3d3ef071b051cc3abbe3721ffb8365033a172613c04af2da89d5548a87/xxhash-3.6.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:42c36dd7dbad2f5238950c377fcbf6811b1cdb1c444fab447960030cea60504d", size = 193936, upload-time = "2025-10-02T14:35:05.013Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/bd/4a5f68381939219abfe1c22a9e3a5854a4f6f6f3c4983a87d255f21f2e5d/xxhash-3.6.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:f22927652cba98c44639ffdc7aaf35828dccf679b10b31c4ad72a5b530a18eb7", size = 210440, upload-time = "2025-10-02T14:35:06.239Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/37/b80fe3d5cfb9faff01a02121a0f4d565eb7237e9e5fc66e73017e74dcd36/xxhash-3.6.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:b45fad44d9c5c119e9c6fbf2e1c656a46dc68e280275007bbfd3d572b21426db", size = 197990, upload-time = "2025-10-02T14:35:07.735Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/fd/2c0a00c97b9e18f72e1f240ad4e8f8a90fd9d408289ba9c7c495ed7dc05c/xxhash-3.6.0-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:6f2580ffab1a8b68ef2b901cde7e55fa8da5e4be0977c68f78fc80f3c143de42", size = 210689, upload-time = "2025-10-02T14:35:09.438Z" },
+    { url = "https://files.pythonhosted.org/packages/93/86/5dd8076a926b9a95db3206aba20d89a7fc14dd5aac16e5c4de4b56033140/xxhash-3.6.0-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:40c391dd3cd041ebc3ffe6f2c862f402e306eb571422e0aa918d8070ba31da11", size = 414068, upload-time = "2025-10-02T14:35:11.162Z" },
+    { url = "https://files.pythonhosted.org/packages/af/3c/0bb129170ee8f3650f08e993baee550a09593462a5cddd8e44d0011102b1/xxhash-3.6.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:f205badabde7aafd1a31e8ca2a3e5a763107a71c397c4481d6a804eb5063d8bd", size = 191495, upload-time = "2025-10-02T14:35:12.971Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/3a/6797e0114c21d1725e2577508e24006fd7ff1d8c0c502d3b52e45c1771d8/xxhash-3.6.0-cp313-cp313-win32.whl", hash = "sha256:2577b276e060b73b73a53042ea5bd5203d3e6347ce0d09f98500f418a9fcf799", size = 30620, upload-time = "2025-10-02T14:35:14.129Z" },
+    { url = "https://files.pythonhosted.org/packages/86/15/9bc32671e9a38b413a76d24722a2bf8784a132c043063a8f5152d390b0f9/xxhash-3.6.0-cp313-cp313-win_amd64.whl", hash = "sha256:757320d45d2fbcce8f30c42a6b2f47862967aea7bf458b9625b4bbe7ee390392", size = 31542, upload-time = "2025-10-02T14:35:15.21Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c5/cc01e4f6188656e56112d6a8e0dfe298a16934b8c47a247236549a3f7695/xxhash-3.6.0-cp313-cp313-win_arm64.whl", hash = "sha256:457b8f85dec5825eed7b69c11ae86834a018b8e3df5e77783c999663da2f96d6", size = 27880, upload-time = "2025-10-02T14:35:16.315Z" },
+    { url = "https://files.pythonhosted.org/packages/f3/30/25e5321c8732759e930c555176d37e24ab84365482d257c3b16362235212/xxhash-3.6.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:a42e633d75cdad6d625434e3468126c73f13f7584545a9cf34e883aa1710e702", size = 32956, upload-time = "2025-10-02T14:35:17.413Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/3c/0573299560d7d9f8ab1838f1efc021a280b5ae5ae2e849034ef3dee18810/xxhash-3.6.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:568a6d743219e717b07b4e03b0a828ce593833e498c3b64752e0f5df6bfe84db", size = 31072, upload-time = "2025-10-02T14:35:18.844Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1c/52d83a06e417cd9d4137722693424885cc9878249beb3a7c829e74bf7ce9/xxhash-3.6.0-cp313-cp313t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:bec91b562d8012dae276af8025a55811b875baace6af510412a5e58e3121bc54", size = 196409, upload-time = "2025-10-02T14:35:20.31Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/8e/c6d158d12a79bbd0b878f8355432075fc82759e356ab5a111463422a239b/xxhash-3.6.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:78e7f2f4c521c30ad5e786fdd6bae89d47a32672a80195467b5de0480aa97b1f", size = 215736, upload-time = "2025-10-02T14:35:21.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/68/c4c80614716345d55071a396cf03d06e34b5f4917a467faf43083c995155/xxhash-3.6.0-cp313-cp313t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:3ed0df1b11a79856df5ffcab572cbd6b9627034c1c748c5566fa79df9048a7c5", size = 214833, upload-time = "2025-10-02T14:35:23.32Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/e9/ae27c8ffec8b953efa84c7c4a6c6802c263d587b9fc0d6e7cea64e08c3af/xxhash-3.6.0-cp313-cp313t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:0e4edbfc7d420925b0dd5e792478ed393d6e75ff8fc219a6546fb446b6a417b1", size = 448348, upload-time = "2025-10-02T14:35:25.111Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/6b/33e21afb1b5b3f46b74b6bd1913639066af218d704cc0941404ca717fc57/xxhash-3.6.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fba27a198363a7ef87f8c0f6b171ec36b674fe9053742c58dd7e3201c1ab30ee", size = 196070, upload-time = "2025-10-02T14:35:26.586Z" },
+    { url = "https://files.pythonhosted.org/packages/96/b6/fcabd337bc5fa624e7203aa0fa7d0c49eed22f72e93229431752bddc83d9/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:794fe9145fe60191c6532fa95063765529770edcdd67b3d537793e8004cabbfd", size = 212907, upload-time = "2025-10-02T14:35:28.087Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/d3/9ee6160e644d660fcf176c5825e61411c7f62648728f69c79ba237250143/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:6105ef7e62b5ac73a837778efc331a591d8442f8ef5c7e102376506cb4ae2729", size = 200839, upload-time = "2025-10-02T14:35:29.857Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/98/e8de5baa5109394baf5118f5e72ab21a86387c4f89b0e77ef3e2f6b0327b/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_ppc64le.whl", hash = "sha256:f01375c0e55395b814a679b3eea205db7919ac2af213f4a6682e01220e5fe292", size = 213304, upload-time = "2025-10-02T14:35:31.222Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/1d/71056535dec5c3177eeb53e38e3d367dd1d16e024e63b1cee208d572a033/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_s390x.whl", hash = "sha256:d706dca2d24d834a4661619dcacf51a75c16d65985718d6a7d73c1eeeb903ddf", size = 416930, upload-time = "2025-10-02T14:35:32.517Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/6c/5cbde9de2cd967c322e651c65c543700b19e7ae3e0aae8ece3469bf9683d/xxhash-3.6.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:5f059d9faeacd49c0215d66f4056e1326c80503f51a1532ca336a385edadd033", size = 193787, upload-time = "2025-10-02T14:35:33.827Z" },
+    { url = "https://files.pythonhosted.org/packages/19/fa/0172e350361d61febcea941b0cc541d6e6c8d65d153e85f850a7b256ff8a/xxhash-3.6.0-cp313-cp313t-win32.whl", hash = "sha256:1244460adc3a9be84731d72b8e80625788e5815b68da3da8b83f78115a40a7ec", size = 30916, upload-time = "2025-10-02T14:35:35.107Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/e6/e8cf858a2b19d6d45820f072eff1bea413910592ff17157cabc5f1227a16/xxhash-3.6.0-cp313-cp313t-win_amd64.whl", hash = "sha256:b1e420ef35c503869c4064f4a2f2b08ad6431ab7b229a05cce39d74268bca6b8", size = 31799, upload-time = "2025-10-02T14:35:36.165Z" },
+    { url = "https://files.pythonhosted.org/packages/56/15/064b197e855bfb7b343210e82490ae672f8bc7cdf3ddb02e92f64304ee8a/xxhash-3.6.0-cp313-cp313t-win_arm64.whl", hash = "sha256:ec44b73a4220623235f67a996c862049f375df3b1052d9899f40a6382c32d746", size = 28044, upload-time = "2025-10-02T14:35:37.195Z" },
+    { url = "https://files.pythonhosted.org/packages/7e/5e/0138bc4484ea9b897864d59fce9be9086030825bc778b76cb5a33a906d37/xxhash-3.6.0-cp314-cp314-macosx_10_13_x86_64.whl", hash = "sha256:a40a3d35b204b7cc7643cbcf8c9976d818cb47befcfac8bbefec8038ac363f3e", size = 32754, upload-time = "2025-10-02T14:35:38.245Z" },
+    { url = "https://files.pythonhosted.org/packages/18/d7/5dac2eb2ec75fd771957a13e5dda560efb2176d5203f39502a5fc571f899/xxhash-3.6.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:a54844be970d3fc22630b32d515e79a90d0a3ddb2644d8d7402e3c4c8da61405", size = 30846, upload-time = "2025-10-02T14:35:39.6Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/71/8bc5be2bb00deb5682e92e8da955ebe5fa982da13a69da5a40a4c8db12fb/xxhash-3.6.0-cp314-cp314-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:016e9190af8f0a4e3741343777710e3d5717427f175adfdc3e72508f59e2a7f3", size = 194343, upload-time = "2025-10-02T14:35:40.69Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/3b/52badfb2aecec2c377ddf1ae75f55db3ba2d321c5e164f14461c90837ef3/xxhash-3.6.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4f6f72232f849eb9d0141e2ebe2677ece15adfd0fa599bc058aad83c714bb2c6", size = 213074, upload-time = "2025-10-02T14:35:42.29Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/2b/ae46b4e9b92e537fa30d03dbc19cdae57ed407e9c26d163895e968e3de85/xxhash-3.6.0-cp314-cp314-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:63275a8aba7865e44b1813d2177e0f5ea7eadad3dd063a21f7cf9afdc7054063", size = 212388, upload-time = "2025-10-02T14:35:43.929Z" },
+    { url = "https://files.pythonhosted.org/packages/f5/80/49f88d3afc724b4ac7fbd664c8452d6db51b49915be48c6982659e0e7942/xxhash-3.6.0-cp314-cp314-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:3cd01fa2aa00d8b017c97eb46b9a794fbdca53fc14f845f5a328c71254b0abb7", size = 445614, upload-time = "2025-10-02T14:35:45.216Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/ba/603ce3961e339413543d8cd44f21f2c80e2a7c5cfe692a7b1f2cccf58f3c/xxhash-3.6.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:0226aa89035b62b6a86d3c68df4d7c1f47a342b8683da2b60cedcddb46c4d95b", size = 194024, upload-time = "2025-10-02T14:35:46.959Z" },
+    { url = "https://files.pythonhosted.org/packages/78/d1/8e225ff7113bf81545cfdcd79eef124a7b7064a0bba53605ff39590b95c2/xxhash-3.6.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:c6e193e9f56e4ca4923c61238cdaced324f0feac782544eb4c6d55ad5cc99ddd", size = 210541, upload-time = "2025-10-02T14:35:48.301Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/58/0f89d149f0bad89def1a8dd38feb50ccdeb643d9797ec84707091d4cb494/xxhash-3.6.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:9176dcaddf4ca963d4deb93866d739a343c01c969231dbe21680e13a5d1a5bf0", size = 198305, upload-time = "2025-10-02T14:35:49.584Z" },
+    { url = "https://files.pythonhosted.org/packages/11/38/5eab81580703c4df93feb5f32ff8fa7fe1e2c51c1f183ee4e48d4bb9d3d7/xxhash-3.6.0-cp314-cp314-musllinux_1_2_ppc64le.whl", hash = "sha256:c1ce4009c97a752e682b897aa99aef84191077a9433eb237774689f14f8ec152", size = 210848, upload-time = "2025-10-02T14:35:50.877Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6b/953dc4b05c3ce678abca756416e4c130d2382f877a9c30a20d08ee6a77c0/xxhash-3.6.0-cp314-cp314-musllinux_1_2_s390x.whl", hash = "sha256:8cb2f4f679b01513b7adbb9b1b2f0f9cdc31b70007eaf9d59d0878809f385b11", size = 414142, upload-time = "2025-10-02T14:35:52.15Z" },
+    { url = "https://files.pythonhosted.org/packages/08/a9/238ec0d4e81a10eb5026d4a6972677cbc898ba6c8b9dbaec12ae001b1b35/xxhash-3.6.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:653a91d7c2ab54a92c19ccf43508b6a555440b9be1bc8be553376778be7f20b5", size = 191547, upload-time = "2025-10-02T14:35:53.547Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/ee/3cf8589e06c2164ac77c3bf0aa127012801128f1feebf2a079272da5737c/xxhash-3.6.0-cp314-cp314-win32.whl", hash = "sha256:a756fe893389483ee8c394d06b5ab765d96e68fbbfe6fde7aa17e11f5720559f", size = 31214, upload-time = "2025-10-02T14:35:54.746Z" },
+    { url = "https://files.pythonhosted.org/packages/02/5d/a19552fbc6ad4cb54ff953c3908bbc095f4a921bc569433d791f755186f1/xxhash-3.6.0-cp314-cp314-win_amd64.whl", hash = "sha256:39be8e4e142550ef69629c9cd71b88c90e9a5db703fecbcf265546d9536ca4ad", size = 32290, upload-time = "2025-10-02T14:35:55.791Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/11/dafa0643bc30442c887b55baf8e73353a344ee89c1901b5a5c54a6c17d39/xxhash-3.6.0-cp314-cp314-win_arm64.whl", hash = "sha256:25915e6000338999236f1eb68a02a32c3275ac338628a7eaa5a269c401995679", size = 28795, upload-time = "2025-10-02T14:35:57.162Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/db/0e99732ed7f64182aef4a6fb145e1a295558deec2a746265dcdec12d191e/xxhash-3.6.0-cp314-cp314t-macosx_10_13_x86_64.whl", hash = "sha256:c5294f596a9017ca5a3e3f8884c00b91ab2ad2933cf288f4923c3fd4346cf3d4", size = 32955, upload-time = "2025-10-02T14:35:58.267Z" },
+    { url = "https://files.pythonhosted.org/packages/55/f4/2a7c3c68e564a099becfa44bb3d398810cc0ff6749b0d3cb8ccb93f23c14/xxhash-3.6.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1cf9dcc4ab9cff01dfbba78544297a3a01dafd60f3bde4e2bfd016cf7e4ddc67", size = 31072, upload-time = "2025-10-02T14:35:59.382Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/d9/72a29cddc7250e8a5819dad5d466facb5dc4c802ce120645630149127e73/xxhash-3.6.0-cp314-cp314t-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:01262da8798422d0685f7cef03b2bd3f4f46511b02830861df548d7def4402ad", size = 196579, upload-time = "2025-10-02T14:36:00.838Z" },
+    { url = "https://files.pythonhosted.org/packages/63/93/b21590e1e381040e2ca305a884d89e1c345b347404f7780f07f2cdd47ef4/xxhash-3.6.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:51a73fb7cb3a3ead9f7a8b583ffd9b8038e277cdb8cb87cf890e88b3456afa0b", size = 215854, upload-time = "2025-10-02T14:36:02.207Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/b8/edab8a7d4fa14e924b29be877d54155dcbd8b80be85ea00d2be3413a9ed4/xxhash-3.6.0-cp314-cp314t-manylinux2014_ppc64le.manylinux_2_17_ppc64le.manylinux_2_28_ppc64le.whl", hash = "sha256:b9c6df83594f7df8f7f708ce5ebeacfc69f72c9fbaaababf6cf4758eaada0c9b", size = 214965, upload-time = "2025-10-02T14:36:03.507Z" },
+    { url = "https://files.pythonhosted.org/packages/27/67/dfa980ac7f0d509d54ea0d5a486d2bb4b80c3f1bb22b66e6a05d3efaf6c0/xxhash-3.6.0-cp314-cp314t-manylinux2014_s390x.manylinux_2_17_s390x.manylinux_2_28_s390x.whl", hash = "sha256:627f0af069b0ea56f312fd5189001c24578868643203bca1abbc2c52d3a6f3ca", size = 448484, upload-time = "2025-10-02T14:36:04.828Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/63/8ffc2cc97e811c0ca5d00ab36604b3ea6f4254f20b7bc658ca825ce6c954/xxhash-3.6.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:aa912c62f842dfd013c5f21a642c9c10cd9f4c4e943e0af83618b4a404d9091a", size = 196162, upload-time = "2025-10-02T14:36:06.182Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/77/07f0e7a3edd11a6097e990f6e5b815b6592459cb16dae990d967693e6ea9/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:b465afd7909db30168ab62afe40b2fcf79eedc0b89a6c0ab3123515dc0df8b99", size = 213007, upload-time = "2025-10-02T14:36:07.733Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/d8/bc5fa0d152837117eb0bef6f83f956c509332ce133c91c63ce07ee7c4873/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:a881851cf38b0a70e7c4d3ce81fc7afd86fbc2a024f4cfb2a97cf49ce04b75d3", size = 200956, upload-time = "2025-10-02T14:36:09.106Z" },
+    { url = "https://files.pythonhosted.org/packages/26/a5/d749334130de9411783873e9b98ecc46688dad5db64ca6e04b02acc8b473/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_ppc64le.whl", hash = "sha256:9b3222c686a919a0f3253cfc12bb118b8b103506612253b5baeaac10d8027cf6", size = 213401, upload-time = "2025-10-02T14:36:10.585Z" },
+    { url = "https://files.pythonhosted.org/packages/89/72/abed959c956a4bfc72b58c0384bb7940663c678127538634d896b1195c10/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_s390x.whl", hash = "sha256:c5aa639bc113e9286137cec8fadc20e9cd732b2cc385c0b7fa673b84fc1f2a93", size = 417083, upload-time = "2025-10-02T14:36:12.276Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/b3/62fd2b586283b7d7d665fb98e266decadf31f058f1cf6c478741f68af0cb/xxhash-3.6.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:5c1343d49ac102799905e115aee590183c3921d475356cb24b4de29a4bc56518", size = 193913, upload-time = "2025-10-02T14:36:14.025Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/9a/c19c42c5b3f5a4aad748a6d5b4f23df3bed7ee5445accc65a0fb3ff03953/xxhash-3.6.0-cp314-cp314t-win32.whl", hash = "sha256:5851f033c3030dd95c086b4a36a2683c2ff4a799b23af60977188b057e467119", size = 31586, upload-time = "2025-10-02T14:36:15.603Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d6/4cc450345be9924fd5dc8c590ceda1db5b43a0a889587b0ae81a95511360/xxhash-3.6.0-cp314-cp314t-win_amd64.whl", hash = "sha256:0444e7967dac37569052d2409b00a8860c2135cff05502df4da80267d384849f", size = 32526, upload-time = "2025-10-02T14:36:16.708Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/c9/7243eb3f9eaabd1a88a5a5acadf06df2d83b100c62684b7425c6a11bcaa8/xxhash-3.6.0-cp314-cp314t-win_arm64.whl", hash = "sha256:bb79b1e63f6fd84ec778a4b1916dfe0a7c3fdb986c06addd5db3a0d413819d95", size = 28898, upload-time = "2025-10-02T14:36:17.843Z" },
+    { url = "https://files.pythonhosted.org/packages/93/1e/8aec23647a34a249f62e2398c42955acd9b4c6ed5cf08cbea94dc46f78d2/xxhash-3.6.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0f7b7e2ec26c1666ad5fc9dbfa426a6a3367ceaf79db5dd76264659d509d73b0", size = 30662, upload-time = "2025-10-02T14:37:01.743Z" },
+    { url = "https://files.pythonhosted.org/packages/b8/0b/b14510b38ba91caf43006209db846a696ceea6a847a0c9ba0a5b1adc53d6/xxhash-3.6.0-pp311-pypy311_pp73-manylinux1_i686.manylinux_2_28_i686.manylinux_2_5_i686.whl", hash = "sha256:5dc1e14d14fa0f5789ec29a7062004b5933964bb9b02aae6622b8f530dc40296", size = 41056, upload-time = "2025-10-02T14:37:02.879Z" },
+    { url = "https://files.pythonhosted.org/packages/50/55/15a7b8a56590e66ccd374bbfa3f9ffc45b810886c8c3b614e3f90bd2367c/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:881b47fc47e051b37d94d13e7455131054b56749b91b508b0907eb07900d1c13", size = 36251, upload-time = "2025-10-02T14:37:04.44Z" },
+    { url = "https://files.pythonhosted.org/packages/62/b2/5ac99a041a29e58e95f907876b04f7067a0242cb85b5f39e726153981503/xxhash-3.6.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6dc31591899f5e5666f04cc2e529e69b4072827085c1ef15294d91a004bc1bd", size = 32481, upload-time = "2025-10-02T14:37:05.869Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/d9/8d95e906764a386a3d3b596f3c68bb63687dfca806373509f51ce8eea81f/xxhash-3.6.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:15e0dac10eb9309508bfc41f7f9deaa7755c69e35af835db9cb10751adebc35d", size = 31565, upload-time = "2025-10-02T14:37:06.966Z" },
+]
+
 [[package]]
 name = "zstandard"
 version = "0.25.0"

libs/cli/examples/graph_prerelease_reqs/deps/zuper_deps/pyproject.toml

@@ -5,5 +5,5 @@ description = "Test for prerelease stuff"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-  "langchain-openai==1.0.1"
+  "langchain-openai==1.1.14"
 ]

libs/cli/examples/graph_prerelease_reqs/pyproject.toml

@@ -5,7 +5,7 @@ description = "Test for prerelease stuff"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-  "langchain-openai==1.0.0a2",
+  "langchain-openai==1.1.14",
   "langchain-anthropic==1.0.0a5",
   "langgraph==1.1.5"
 ]

libs/cli/examples/graph_prerelease_reqs_fail/pyproject.toml

@@ -5,7 +5,7 @@ description = "Test for prerelease stuff"
 readme = "README.md"
 requires-python = ">=3.10"
 dependencies = [
-  "langchain-openai==1.0.0a2",
+  "langchain-openai==1.1.14",
   "langgraph==1.1.2",
   "langchain_community>=0.3.0",
 ]

libs/cli/js-examples/yarn.lock

@@ -3676,9 +3676,9 @@ keyv@^4.5.4:
     json-buffer "3.0.1"
 
 "langsmith@>=0.5.0 <1.0.0":
-  version "0.5.18"
-  resolved "https://registry.yarnpkg.com/langsmith/-/langsmith-0.5.18.tgz#c691ad23614f0b46eaf07d982e0ac988e1f43880"
-  integrity sha512-3zuZUWffTHQ+73EAwnodADtf534VNEZUpXr9jC12qyG8/IQuJET7PRsCpTb9wX2lmBspakwLUpqpj3tNm/0bVA==
+  version "0.5.20"
+  resolved "https://registry.yarnpkg.com/langsmith/-/langsmith-0.5.20.tgz#4021847d2ccd5a86c5eb96060f9bb5f19f80eca5"
+  integrity sha512-ULhLM8RswvQDXufLtNtvclHrWCBx8Cb5UPI6lAZC+8Dq59iHsVPz/3Ac9khWNm1VIvChRsuykixD/WrmzuuA3Q==
   dependencies:
     p-queue "6.6.2"
     uuid "10.0.0"

libs/cli/js-monorepo-example/yarn.lock

@@ -1328,9 +1328,9 @@ keyv@^4.5.4:
     json-buffer "3.0.1"
 
 "langsmith@>=0.5.0 <1.0.0":
-  version "0.5.18"
-  resolved "https://registry.yarnpkg.com/langsmith/-/langsmith-0.5.18.tgz#c691ad23614f0b46eaf07d982e0ac988e1f43880"
-  integrity sha512-3zuZUWffTHQ+73EAwnodADtf534VNEZUpXr9jC12qyG8/IQuJET7PRsCpTb9wX2lmBspakwLUpqpj3tNm/0bVA==
+  version "0.5.20"
+  resolved "https://registry.yarnpkg.com/langsmith/-/langsmith-0.5.20.tgz#4021847d2ccd5a86c5eb96060f9bb5f19f80eca5"
+  integrity sha512-ULhLM8RswvQDXufLtNtvclHrWCBx8Cb5UPI6lAZC+8Dq59iHsVPz/3Ac9khWNm1VIvChRsuykixD/WrmzuuA3Q==
   dependencies:
     p-queue "6.6.2"
     uuid "10.0.0"

libs/cli/langgraph_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.21"
+__version__ = "0.4.23"

libs/cli/langgraph_cli/analytics.py

@@ -26,8 +26,15 @@ class LogData(TypedDict):
     params: dict[str, Any]
 
 
-def get_anonymized_params(kwargs: dict[str, Any]) -> dict[str, bool]:
-    params = {}
+def get_anonymized_params(
+    kwargs: dict[str, Any], *, cli_command: str
+) -> dict[str, bool | str]:
+    params: dict[str, bool | str] = {}
+
+    if cli_command == "deploy" and (
+        analytics_source := os.getenv("LANGGRAPH_CLI_ANALYTICS_SOURCE")
+    ):
+        params["source"] = analytics_source
 
     # anonymize params with values
     if config := kwargs.get("config"):
@@ -88,7 +95,7 @@ def log_command(func):
             "python_version": platform.python_version(),
             "cli_version": __version__,
             "cli_command": func.__name__,
-            "params": get_anonymized_params(kwargs),
+            "params": get_anonymized_params(kwargs, cli_command=func.__name__),
         }
 
         background_thread = threading.Thread(target=log_data, args=(data,))

libs/cli/pyproject.toml

@@ -23,7 +23,7 @@ dependencies = [
 path = "langgraph_cli/__init__.py"
 [project.optional-dependencies]
 inmem = [
-    "langgraph-api>=0.5.35,<0.8.0 ; python_version >= '3.11'",
+    "langgraph-api>=0.5.35,<0.9.0 ; python_version >= '3.11'",
     "langgraph-runtime-inmem>=0.7 ; python_version >= '3.11'",
 ]
 

libs/cli/uv-examples/monorepo/uv.lock

@@ -290,7 +290,7 @@ wheels = [
 
 [[package]]
 name = "langsmith"
-version = "0.7.26"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -303,9 +303,9 @@ dependencies = [
     { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/76/86/6de4f6f0451a9658f26f633e0bb090552a4dafd7df3f1ae7f0d40558e67e/langsmith-0.7.26.tar.gz", hash = "sha256:a3e06f3d689ce7195717aa6b8f91082319819ec7ea9b9a62cdcd3d9dc25bfc7b", size = 1146118, upload-time = "2026-04-06T15:01:03.336Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/8e/7eb7d65ce62e98e74b9f18f193ea7ac3996d4fbd71fffcc67d0f7ba3103e/langsmith-0.7.26-py3-none-any.whl", hash = "sha256:fe5c877972cea450c1c48251c8fae0f18543c8d19dfdb9ff9a9c4263763dde4e", size = 360160, upload-time = "2026-04-06T15:01:01.516Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]

libs/cli/uv-examples/simple/uv.lock

@@ -266,7 +266,7 @@ wheels = [
 
 [[package]]
 name = "langsmith"
-version = "0.7.26"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -279,9 +279,9 @@ dependencies = [
     { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/76/86/6de4f6f0451a9658f26f633e0bb090552a4dafd7df3f1ae7f0d40558e67e/langsmith-0.7.26.tar.gz", hash = "sha256:a3e06f3d689ce7195717aa6b8f91082319819ec7ea9b9a62cdcd3d9dc25bfc7b", size = 1146118, upload-time = "2026-04-06T15:01:03.336Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/81/8e/7eb7d65ce62e98e74b9f18f193ea7ac3996d4fbd71fffcc67d0f7ba3103e/langsmith-0.7.26-py3-none-any.whl", hash = "sha256:fe5c877972cea450c1c48251c8fae0f18543c8d19dfdb9ff9a9c4263763dde4e", size = 360160, upload-time = "2026-04-06T15:01:01.516Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]

libs/langgraph/langgraph/_internal/_constants.py

@@ -66,9 +66,6 @@ CONFIG_KEY_RUNTIME = sys.intern("__pregel_runtime")
 # holds a `Runtime` instance with context, store, stream writer, etc.
 CONFIG_KEY_RESUME_MAP = sys.intern("__pregel_resume_map")
 # holds a mapping of task ns -> resume value for resuming tasks
-CONFIG_KEY_STREAM_MESSAGES_V2 = sys.intern("__pregel_stream_messages_v2")
-# when True, attach StreamMessagesHandlerV2 so content-block (v2) events
-# flow through stream_mode="messages"; set by GraphStreamer only.
 
 # --- Other constants ---
 PUSH = sys.intern("__pregel_push")
@@ -110,7 +107,6 @@ RESERVED = {
     CONFIG_KEY_CHECKPOINT_ID,
     CONFIG_KEY_CHECKPOINT_NS,
     CONFIG_KEY_RESUME_MAP,
-    CONFIG_KEY_STREAM_MESSAGES_V2,
     # other constants
     PUSH,
     PULL,

libs/langgraph/langgraph/callbacks.py

@@ -245,15 +245,6 @@ class _GraphCallbackManager(BaseCallbackManager):
             run_id=run_id,
         )
 
-    def add_handler(
-        self,
-        handler: BaseCallbackHandler,
-        inherit: bool = True,  # noqa: FBT001,FBT002
-    ) -> None:
-        if not isinstance(handler, GraphCallbackHandler):
-            raise TypeError("handlers must inherit GraphCallbackHandler")
-        super().add_handler(handler, inherit=inherit)
-
     def copy(
         self,
         *,
@@ -321,15 +312,6 @@ class _AsyncGraphCallbackManager(BaseCallbackManager):
             run_id=run_id,
         )
 
-    def add_handler(
-        self,
-        handler: BaseCallbackHandler,
-        inherit: bool = True,  # noqa: FBT001,FBT002
-    ) -> None:
-        if not isinstance(handler, GraphCallbackHandler):
-            raise TypeError("handlers must inherit GraphCallbackHandler")
-        super().add_handler(handler, inherit=inherit)
-
     def copy(
         self,
         *,

libs/langgraph/langgraph/channels/__init__.py

@@ -1,6 +1,7 @@
 from langgraph.channels.any_value import AnyValue
 from langgraph.channels.base import BaseChannel
 from langgraph.channels.binop import BinaryOperatorAggregate
+from langgraph.channels.delta import DeltaChannel
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.channels.last_value import LastValue, LastValueAfterFinish
 from langgraph.channels.named_barrier_value import (
@@ -20,6 +21,7 @@ __all__ = (
     "UntrackedValue",
     "EphemeralValue",
     "BinaryOperatorAggregate",
+    "DeltaChannel",
     "NamedBarrierValue",
     "NamedBarrierValueAfterFinish",
     # topics

libs/langgraph/langgraph/channels/delta.py

@@ -0,0 +1,181 @@
+from __future__ import annotations
+
+import copy as _copy
+from collections.abc import Callable, Sequence
+from typing import Any, Generic
+
+from langgraph.checkpoint.base import DELTA_SENTINEL, PendingWrite
+from langgraph.checkpoint.serde.types import _DeltaSnapshot
+from typing_extensions import Self
+
+from langgraph._internal._constants import OVERWRITE
+from langgraph._internal._typing import MISSING
+from langgraph.channels.base import BaseChannel, Value
+from langgraph.errors import (
+    EmptyChannelError,
+    ErrorCode,
+    InvalidUpdateError,
+    create_error_message,
+)
+from langgraph.types import Overwrite
+
+__all__ = ("DeltaChannel",)
+
+
+def _empty(typ: Any) -> Any:
+    try:
+        return typ()
+    except Exception:
+        return []
+
+
+def _get_overwrite(value: Any) -> tuple[bool, Any]:
+    if isinstance(value, Overwrite):
+        return True, value.value
+    if isinstance(value, dict) and set(value.keys()) == {OVERWRITE}:
+        return True, value[OVERWRITE]
+    return False, None
+
+
+class DeltaChannel(Generic[Value], BaseChannel[Any, Any, Any]):
+    """Fold-reducer channel with configurable snapshot cadence.
+
+    `snapshot_frequency=None` (default): pure delta — stores only
+    `DELTA_SENTINEL` in checkpoint blobs; reads replay all ancestor writes.
+
+    `snapshot_frequency=N`: pregel's `create_checkpoint` writes a full
+    `_DeltaSnapshot` blob every N steps (eagerly, even if the channel had
+    no write that step). Reads walk at most N ancestor checkpoints before
+    hitting the snapshot, bounding replay depth to N regardless of thread
+    length.
+
+    Parameters:
+        operator: Binary reducer `(Value, Value) -> Value`.
+        snapshot_frequency: Every Nth pregel step writes a snapshot blob.
+            `None` (default) = pure delta, never snapshot.
+    """
+
+    __slots__ = ("value", "operator", "snapshot_frequency")
+    value: Value | Any
+
+    def __init__(
+        self,
+        operator: Callable[[Any, Any], Any],
+        *,
+        snapshot_frequency: int | None = None,
+    ) -> None:
+        super().__init__(list)
+        self.operator = operator
+        self.snapshot_frequency = snapshot_frequency
+        self.value: Any = []
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, DeltaChannel):
+            return False
+        if self.snapshot_frequency != other.snapshot_frequency:
+            return False
+        if (
+            self.operator.__name__ != "<lambda>"
+            and other.operator.__name__ != "<lambda>"
+        ):
+            return self.operator is other.operator
+        return True
+
+    @property
+    def ValueType(self) -> Any:
+        return self.typ
+
+    @property
+    def UpdateType(self) -> Any:
+        return self.typ
+
+    def is_snapshot_step(self, step: int) -> bool:
+        """True if pregel should write a snapshot blob at this step."""
+        return (
+            self.snapshot_frequency is not None and step % self.snapshot_frequency == 0
+        )
+
+    def _clone_empty(self) -> Self:
+        new = self.__class__.__new__(self.__class__)
+        new.typ = self.typ
+        new.key = self.key
+        new.operator = self.operator
+        new.snapshot_frequency = self.snapshot_frequency
+        new.value = MISSING
+        return new
+
+    def copy(self) -> Self:
+        new = self._clone_empty()
+        new.value = self.value if self.value is MISSING else _copy.copy(self.value)
+        return new
+
+    def _apply_write(self, value: Any, write: Any) -> Any:
+        is_overwrite, overwrite_value = _get_overwrite(write)
+        if is_overwrite:
+            return (
+                _copy.copy(overwrite_value)
+                if overwrite_value is not None
+                else _empty(self.typ)
+            )
+        base = _empty(self.typ) if value is MISSING else value
+        return self.operator(base, write)
+
+    def from_checkpoint(self, checkpoint: Any) -> Self:
+        """Initialize from a stored blob or sentinel.
+
+        Blob types (dispatched via serde ext code, not dict key inspection):
+          * `DELTA_SENTINEL` / `MISSING`: start empty; caller replays writes.
+          * `_DeltaSnapshot(value)`: restore value directly from snapshot.
+          * plain value (migration from old BinOp blobs): use directly.
+        """
+        new = self._clone_empty()
+        if checkpoint is MISSING or checkpoint is DELTA_SENTINEL:
+            new.value = _empty(new.typ)
+        elif isinstance(checkpoint, _DeltaSnapshot):
+            new.value = checkpoint.value
+        else:
+            new.value = checkpoint
+        return new
+
+    def replay_writes(self, writes: Sequence[PendingWrite]) -> None:
+        """Fold ancestor writes oldest→newest into current value."""
+        for _, _, value in writes:
+            self.value = self._apply_write(self.value, value)
+
+    def update(self, values: Sequence[Any]) -> bool:
+        if not values:
+            return False
+        seen_overwrite = False
+        for value in values:
+            is_overwrite, _ = _get_overwrite(value)
+            if is_overwrite:
+                if seen_overwrite:
+                    msg = create_error_message(
+                        message="Can receive only one Overwrite value per super-step.",
+                        error_code=ErrorCode.INVALID_CONCURRENT_GRAPH_UPDATE,
+                    )
+                    raise InvalidUpdateError(msg)
+                seen_overwrite = True
+            elif seen_overwrite:
+                continue
+            self.value = self._apply_write(self.value, value)
+        return True
+
+    def get(self) -> Any:
+        if self.value is MISSING:
+            raise EmptyChannelError()
+        return self.value
+
+    def is_available(self) -> bool:
+        return self.value is not MISSING
+
+    def checkpoint(self) -> Any:
+        """Return stored representation: always `DELTA_SENTINEL`.
+
+        Snapshot decisions are made by `create_checkpoint` in pregel (which
+        has the step number) via `is_snapshot_step`. `checkpoint()` is only
+        called for non-snapshot steps or when no checkpointer is available.
+        """
+        if self.value is MISSING:
+            return MISSING
+        return DELTA_SENTINEL

libs/langgraph/langgraph/config.py

@@ -1,7 +1,5 @@
 import asyncio
 import sys
-from collections.abc import Callable
-from contextvars import ContextVar
 from typing import Any
 
 from langchain_core.runnables import RunnableConfig
@@ -11,18 +9,6 @@ from langgraph.store.base import BaseStore
 from langgraph._internal._constants import CONF, CONFIG_KEY_RUNTIME
 from langgraph.types import StreamWriter
 
-_tool_call_writer: ContextVar[Callable[[Any], None] | None] = ContextVar(
-    "langgraph_tool_call_writer", default=None
-)
-"""ContextVar holding the writer for the currently-executing tool call.
-
-Set by `StreamToolCallHandler.on_tool_start` and reset on end/error.
-Defined here (rather than alongside the handler in `pregel/_tools.py`)
-so `emit_tool_output_delta` can import it without triggering the
-pregel import chain — user tool code does
-`from langgraph.config import emit_tool_output_delta` at import time.
-"""
-
 
 def _no_op_stream_writer(c: Any) -> None:
     pass
@@ -208,30 +194,3 @@ def get_stream_writer() -> StreamWriter:
     """
     runtime = get_config()[CONF][CONFIG_KEY_RUNTIME]
     return runtime.stream_writer
-
-
-def emit_tool_output_delta(delta: Any) -> None:
-    """Emit a `tool-output-delta` event onto the `tools` stream mode.
-
-    Must be called from inside a tool's execution scope (sync or async).
-    While a tool is running, `StreamToolCallHandler.on_tool_start` sets a
-    writer closure on a ContextVar keyed to that call's `tool_call_id`
-    and namespace; this helper reads the ContextVar and forwards `delta`
-    through it.
-
-    When called outside any tool call, or when the graph was not
-    streamed with `"tools"` in `stream_mode`, this is a silent no-op —
-    tool authors can leave `emit_tool_output_delta` calls in place
-    without gating them on stream mode.
-
-    Args:
-        delta: The partial output chunk to stream. Shape is up to the
-            caller — strings are the common case, but any JSON-
-            serializable value is accepted and surfaced as-is on the
-            `tools` channel's `tool-output-delta` payload under
-            `"delta"`.
-    """
-    writer = _tool_call_writer.get()
-    if writer is None:
-        return
-    writer(delta)

libs/langgraph/langgraph/graph/state.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import collections.abc
 import inspect
 import logging
 import typing
@@ -47,7 +48,8 @@ from langgraph._internal._pydantic import create_model
 from langgraph._internal._runnable import coerce_to_runnable
 from langgraph._internal._typing import EMPTY_SEQ, MISSING, DeprecatedKwargs
 from langgraph.channels.base import BaseChannel
-from langgraph.channels.binop import BinaryOperatorAggregate
+from langgraph.channels.binop import BinaryOperatorAggregate, _strip_extras
+from langgraph.channels.delta import DeltaChannel
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.channels.last_value import LastValue, LastValueAfterFinish
 from langgraph.channels.named_barrier_value import (
@@ -1045,7 +1047,6 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
         interrupt_after: All | list[str] | None = None,
         debug: bool = False,
         name: str | None = None,
-        transformers: Sequence[Callable[..., Any]] | None = None,
     ) -> CompiledStateGraph[StateT, ContextT, InputT, OutputT]:
         """Compiles the `StateGraph` into a `CompiledStateGraph` object.
 
@@ -1078,16 +1079,12 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
             interrupt_after: An optional list of node names to interrupt after.
             debug: A flag indicating whether to enable debug mode.
             name: The name to use for the compiled graph.
-            transformers: Optional sequence of zero-arg factories returning
-                `StreamTransformer` instances. Registered on the compiled
-                graph and instantiated per-run whenever `stream_v2` /
-                `astream_v2` is called. Appended after the built-in
-                `ValuesTransformer` and `MessagesTransformer`.
 
         Returns:
             CompiledStateGraph: The compiled `StateGraph`.
         """
         checkpointer = ensure_valid_checkpointer(checkpointer)
+
         serde_allowlist: set[tuple[str, ...]] | None = None
         if _serde.STRICT_MSGPACK_ENABLED:
             schema_types: list[type[Any]] = [
@@ -1165,7 +1162,6 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
             store=store,
             cache=cache,
             name=name or "LangGraph",
-            stream_transformers=transformers,
         )
         compiled._serde_allowlist = serde_allowlist
 
@@ -1674,6 +1670,36 @@ def _is_field_channel(typ: type[Any]) -> BaseChannel | None:
         # Search through all annotated medata to find channel annotations
         for item in meta:
             if isinstance(item, BaseChannel):
+                if isinstance(item, DeltaChannel) and hasattr(typ, "__origin__"):
+                    origin = typ.__origin__
+                    # Unwrap parameterized Required[X]/NotRequired[X] to X
+                    # (e.g. Annotated[NotRequired[dict[...]], ...]).
+                    if hasattr(origin, "__origin__") and origin.__origin__ in (
+                        Required,
+                        NotRequired,
+                    ):
+                        origin = origin.__args__[0]
+                    outer = _strip_extras(origin)
+                    if outer in (
+                        collections.abc.Sequence,
+                        collections.abc.MutableSequence,
+                    ):
+                        outer = list
+                    elif outer in (
+                        collections.abc.Mapping,
+                        collections.abc.MutableMapping,
+                    ):
+                        outer = dict
+                    elif outer in (
+                        collections.abc.Set,
+                        collections.abc.MutableSet,
+                    ):
+                        outer = set
+                    item.typ = outer
+                    try:
+                        item.value = outer()
+                    except Exception:
+                        item.value = []
                 return item
             elif isclass(item) and issubclass(item, BaseChannel):
                 # ex, Annotated[int, EphemeralValue, SomeOtherAnnotation]

libs/langgraph/langgraph/pregel/_algo.py

@@ -210,7 +210,7 @@ def local_read(
     return values
 
 
-def increment(current: int | None, channel: None) -> int:
+def increment(current: int | None, channel: None = None) -> int:
     """Default channel versioning function, increments the current int version."""
     return current + 1 if current is not None else 1
 

libs/langgraph/langgraph/pregel/_checkpoint.py

@@ -1,17 +1,23 @@
 from __future__ import annotations
 
-from collections.abc import Mapping
+from collections.abc import Callable, Mapping
 from datetime import datetime, timezone
+from typing import Any
 
-from langgraph.checkpoint.base import Checkpoint
+from langchain_core.runnables import RunnableConfig
+from langgraph.checkpoint.base import DELTA_SENTINEL, BaseCheckpointSaver, Checkpoint
 from langgraph.checkpoint.base.id import uuid6
+from langgraph.checkpoint.serde.types import _DeltaSnapshot
 
 from langgraph._internal._typing import MISSING
 from langgraph.channels.base import BaseChannel
+from langgraph.channels.delta import DeltaChannel
 from langgraph.managed.base import ManagedValueMapping, ManagedValueSpec
 
 LATEST_VERSION = 4
 
+GetNextVersion = Callable[[Any, None], Any]
+
 
 def empty_checkpoint() -> Checkpoint:
     return Checkpoint(
@@ -31,35 +37,82 @@ def create_checkpoint(
     *,
     id: str | None = None,
     updated_channels: set[str] | None = None,
+    get_next_version: GetNextVersion | None = None,
 ) -> Checkpoint:
-    """Create a checkpoint for the given channels."""
+    """Create a checkpoint for the given channels.
+
+    For `DeltaChannel` with `snapshot_frequency=N`, snapshot steps write a
+    `_DeltaSnapshot` blob rather than `DELTA_SENTINEL`, bounding the ancestor
+    walk to at most N steps. Snapshots are eager: even if the channel had no
+    write this step, a version bump is forced (via `get_next_version`) so the
+    blob is stored by `put()`. Without `get_next_version` (e.g. static
+    contexts), snapshot steps gracefully fall back to sentinel.
+    """
     ts = datetime.now(timezone.utc).isoformat()
     if channels is None:
         values = checkpoint["channel_values"]
+        channel_versions = checkpoint["channel_versions"]
     else:
         values = {}
+        channel_versions = dict(checkpoint["channel_versions"])
         for k in channels:
-            if k not in checkpoint["channel_versions"]:
+            if k not in channel_versions:
                 continue
-            v = channels[k].checkpoint()
-            if v is not MISSING:
-                values[k] = v
+            ch = channels[k]
+            if (
+                isinstance(ch, DeltaChannel)
+                and ch.is_snapshot_step(step)
+                and ch.is_available()
+            ):
+                # Eager snapshot: bump version if not already written this step
+                # so put() includes this channel in new_versions and stores blob.
+                if get_next_version is not None and (
+                    updated_channels is None or k not in updated_channels
+                ):
+                    channel_versions[k] = get_next_version(channel_versions[k], None)
+                values[k] = _DeltaSnapshot(ch.get())
+            else:
+                v = ch.checkpoint()
+                if v is not MISSING:
+                    values[k] = v
     return Checkpoint(
         v=LATEST_VERSION,
         ts=ts,
         id=id or str(uuid6(clock_seq=step)),
         channel_values=values,
-        channel_versions=checkpoint["channel_versions"],
+        channel_versions=channel_versions,
         versions_seen=checkpoint["versions_seen"],
         updated_channels=None if updated_channels is None else sorted(updated_channels),
     )
 
 
+def _needs_replay(spec: BaseChannel, stored: object) -> bool:
+    """True if `spec` is a `DeltaChannel` and the stored blob is a sentinel,
+    requiring an ancestor walk to reconstruct.
+
+    `_DeltaSnapshot` blobs and plain values (migration) resolve directly via
+    `from_checkpoint` — only `DELTA_SENTINEL` / `MISSING` trigger replay.
+    """
+    if not isinstance(spec, DeltaChannel):
+        return False
+    return stored is MISSING or stored is DELTA_SENTINEL
+
+
 def channels_from_checkpoint(
     specs: Mapping[str, BaseChannel | ManagedValueSpec],
     checkpoint: Checkpoint,
+    *,
+    saver: BaseCheckpointSaver | None = None,
+    config: RunnableConfig | None = None,
 ) -> tuple[Mapping[str, BaseChannel], ManagedValueMapping]:
-    """Get channels from a checkpoint."""
+    """Hydrate channels from a checkpoint.
+
+    For most channels, `spec.from_checkpoint(checkpoint["channel_values"][k])`
+    is sufficient. `DeltaChannel` is the exception: sentinel blobs require an
+    ancestor walk via `saver._get_channel_writes_history`. The walk terminates
+    at the nearest `_DeltaSnapshot` blob (step-based) or a pre-migration plain
+    value, so read depth is bounded by `snapshot_frequency`.
+    """
     channel_specs: dict[str, BaseChannel] = {}
     managed_specs: dict[str, ManagedValueSpec] = {}
     for k, v in specs.items():
@@ -67,13 +120,53 @@ def channels_from_checkpoint(
             channel_specs[k] = v
         else:
             managed_specs[k] = v
-    return (
-        {
-            k: v.from_checkpoint(checkpoint["channel_values"].get(k, MISSING))
-            for k, v in channel_specs.items()
-        },
-        managed_specs,
-    )
+
+    channels: dict[str, BaseChannel] = {}
+    for k, spec in channel_specs.items():
+        ch: BaseChannel
+        stored = checkpoint["channel_values"].get(k, MISSING)
+        if _needs_replay(spec, stored) and saver is not None and config is not None:
+            assert isinstance(spec, DeltaChannel)
+            history = saver._get_channel_writes_history(config, k)
+            replay_ch = spec.from_checkpoint(history.seed)
+            replay_ch.replay_writes(history.writes)
+            ch = replay_ch
+        else:
+            ch = spec.from_checkpoint(stored)
+        channels[k] = ch
+    return channels, managed_specs
+
+
+async def achannels_from_checkpoint(
+    specs: Mapping[str, BaseChannel | ManagedValueSpec],
+    checkpoint: Checkpoint,
+    *,
+    saver: BaseCheckpointSaver | None = None,
+    config: RunnableConfig | None = None,
+) -> tuple[Mapping[str, BaseChannel], ManagedValueMapping]:
+    """Async version of `channels_from_checkpoint`. See docstring there."""
+    channel_specs: dict[str, BaseChannel] = {}
+    managed_specs: dict[str, ManagedValueSpec] = {}
+    for k, v in specs.items():
+        if isinstance(v, BaseChannel):
+            channel_specs[k] = v
+        else:
+            managed_specs[k] = v
+
+    channels: dict[str, BaseChannel] = {}
+    for k, spec in channel_specs.items():
+        ch: BaseChannel
+        stored = checkpoint["channel_values"].get(k, MISSING)
+        if _needs_replay(spec, stored) and saver is not None and config is not None:
+            assert isinstance(spec, DeltaChannel)
+            history = await saver._aget_channel_writes_history(config, k)
+            replay_ch = spec.from_checkpoint(history.seed)
+            replay_ch.replay_writes(history.writes)
+            ch = replay_ch
+        else:
+            ch = spec.from_checkpoint(stored)
+        channels[k] = ch
+    return channels, managed_specs
 
 
 def copy_checkpoint(checkpoint: Checkpoint) -> Checkpoint:

libs/langgraph/langgraph/pregel/_lifecycle.py

@@ -1,274 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator, Callable, Iterator
-from typing import Any, TypeVar, cast
-from uuid import UUID
-
-from langchain_core.callbacks import BaseCallbackHandler
-
-from langgraph._internal._constants import NS_SEP
-from langgraph.errors import GraphInterrupt
-from langgraph.pregel.protocol import StreamChunk
-
-try:
-    from langchain_core.tracers._streaming import _StreamingCallbackHandler
-except ImportError:
-    _StreamingCallbackHandler = object  # type: ignore[assignment,misc]
-
-
-T = TypeVar("T")
-
-
-_LANGGRAPH_SENTINEL_NODES = frozenset({"__start__", "__end__"})
-
-
-def _is_nested_pregel_start(
-    name: str | None,
-    metadata: dict[str, Any] | None,
-    parent_run_id: UUID | None,
-    task_run_ids: set[UUID],
-) -> bool:
-    """Recognize a nested `Pregel` invocation from its `on_chain_start` metadata.
-
-    When a compiled graph is added as a node, pregel fires two
-    `on_chain_start` callbacks at that task: first for the node chain
-    (whose `name` matches `metadata["langgraph_node"]`) and second for
-    the inner `Pregel` chain (whose `name` is the graph's `name`, not
-    the node name). Both share the same `langgraph_checkpoint_ns`.
-
-    Primary signal: a `langgraph_checkpoint_ns` is set AND `name`
-    differs from the owning task's `langgraph_node`. This covers the
-    common case where the compiled subgraph's name differs from the
-    node name it was registered under.
-
-    Fallback for name collisions (subgraph compiled with
-    `name == node_name`): the inner `Pregel` start's `parent_run_id`
-    is the run_id of the node chain's start event, which the handler
-    records in `task_run_ids` on the first start. Matching
-    `parent_run_id` to that set identifies the second start as the
-    nested `Pregel` even when names coincide.
-
-    Regular node chains are skipped; the root `Pregel` (which has no
-    `langgraph_node` metadata) isn't observed by this handler because
-    the root's start fires before the handler is attached.
-
-    Metadata-based detection is used because `on_chain_start`'s
-    `serialized` argument is `None` for compiled graphs in this
-    version of langchain-core, so class-based detection via
-    `serialized["id"]` isn't available.
-
-    Sentinel nodes (`__start__` / `__end__`) are excluded: conditional
-    edges from `START` fire an `on_chain_start` with `lg_node=__start__`
-    and the router function's name as `name`, which would otherwise
-    match the discriminator without representing an actual nested
-    `Pregel`.
-
-    Args:
-        name: The `name` kwarg from `on_chain_start`.
-        metadata: The `metadata` kwarg from `on_chain_start`.
-        parent_run_id: The `parent_run_id` kwarg from `on_chain_start`.
-        task_run_ids: The set of run_ids the handler has already seen
-            as node-chain starts (i.e. `name == langgraph_node`).
-    """
-    if not metadata:
-        return False
-    if not metadata.get("langgraph_checkpoint_ns"):
-        return False
-    lg_node = metadata.get("langgraph_node")
-    if lg_node is None or lg_node in _LANGGRAPH_SENTINEL_NODES:
-        return False
-    if name != lg_node:
-        return True
-    # Name collision fallback: the inner Pregel's parent_run_id is
-    # the node chain's run_id, which we recorded when that node
-    # chain's start fired.
-    return parent_run_id is not None and parent_run_id in task_run_ids
-
-
-class StreamLifecycleHandler(BaseCallbackHandler, _StreamingCallbackHandler):
-    """Callback handler that emits subgraph lifecycle events on the stream.
-
-    Pushes `LifecycleData`-shaped payloads onto the pregel stream under
-    the `"lifecycle"` mode, keyed by the subgraph's namespace tuple.
-    Drives the `started` → `running` → `completed` / `failed` /
-    `interrupted` state machine.
-
-    The handler is attached to `run_manager.inheritable_handlers` inside
-    a `Pregel.stream` / `astream` call, so it sees callbacks for every
-    descendant chain (nodes, nested `Pregel` subgraphs) but *not* for
-    the root `Pregel` whose start event has already fired. The root's
-    `started` event is emitted eagerly at construction; its terminal
-    state is emitted by `SubgraphTransformer.finalize` / `fail`.
-
-    `run_inline = True` keeps event ordering deterministic.
-    """
-
-    run_inline = True
-
-    def __init__(
-        self,
-        stream: Callable[[StreamChunk], None],
-        *,
-        root_graph_name: str | None = None,
-    ) -> None:
-        """Initialize the handler and emit the root graph's `started` event.
-
-        Args:
-            stream: Callable that accepts a `StreamChunk` tuple
-                `(namespace, mode, payload)` and enqueues it.
-            root_graph_name: The root `Pregel` instance's `name`, emitted
-                with the root's `started` lifecycle payload.
-        """
-        self.stream = stream
-        # Namespaces awaiting the started→running transition.
-        self._pending_running: set[tuple[str, ...]] = set()
-        # run_id → subgraph namespace; populated only for Pregel chains.
-        self._run_to_ns: dict[UUID, tuple[str, ...]] = {}
-        # run_ids of node-chain starts (name == langgraph_node); used
-        # as the parent_run_id fallback when a subgraph's name equals
-        # its node name. Cleared as each chain ends.
-        self._task_run_ids: set[UUID] = set()
-
-        root_payload: dict[str, Any] = {"event": "started"}
-        if root_graph_name is not None:
-            root_payload["graph_name"] = root_graph_name
-        self.stream(((), "lifecycle", root_payload))
-        self._pending_running.add(())
-
-    @staticmethod
-    def _subgraph_ns_from_metadata(metadata: dict[str, Any] | None) -> tuple[str, ...]:
-        """Return the running subgraph's own namespace from task metadata.
-
-        For a nested `Pregel` invoked as a node, `langgraph_checkpoint_ns`
-        ends at the node segment (no inner task appended yet), so
-        splitting on `NS_SEP` gives the subgraph's own namespace.
-        """
-        if not metadata:
-            return ()
-        nskey = metadata.get("langgraph_checkpoint_ns")
-        if not nskey:
-            return ()
-        return tuple(cast(str, nskey).split(NS_SEP))
-
-    @staticmethod
-    def _containing_ns_from_metadata(
-        metadata: dict[str, Any] | None,
-    ) -> tuple[str, ...]:
-        """Return the namespace of the subgraph that contains this task.
-
-        For an inner task with `langgraph_checkpoint_ns`
-        `"seg_a|seg_b"`, the containing subgraph is `("seg_a",)`.
-        """
-        if not metadata:
-            return ()
-        nskey = metadata.get("langgraph_checkpoint_ns")
-        if not nskey:
-            return ()
-        return tuple(cast(str, nskey).split(NS_SEP))[:-1]
-
-    def _emit(self, ns: tuple[str, ...], payload: dict[str, Any]) -> None:
-        self.stream((ns, "lifecycle", payload))
-
-    def tap_output_aiter(
-        self, run_id: UUID, output: AsyncIterator[T]
-    ) -> AsyncIterator[T]:
-        """Pass-through — required by the `_StreamingCallbackHandler` protocol.
-
-        Returns the iterator unchanged. A missing implementation lets
-        langchain's default `Protocol` body return `None`, which breaks
-        the `_consume_aiter` code path in `_runnable.py:900`.
-        """
-        return output
-
-    def tap_output_iter(self, run_id: UUID, output: Iterator[T]) -> Iterator[T]:
-        """Pass-through — sync counterpart to `tap_output_aiter`."""
-        return output
-
-    def _fire_running_if_pending(self, ns: tuple[str, ...]) -> None:
-        if ns in self._pending_running:
-            self._pending_running.discard(ns)
-            self._emit(ns, {"event": "running"})
-
-    def on_chain_start(
-        self,
-        serialized: dict[str, Any],
-        inputs: dict[str, Any],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        # Any descendant activity transitions the containing subgraph to running.
-        containing = self._containing_ns_from_metadata(metadata)
-        self._fire_running_if_pending(containing)
-
-        name = cast(str | None, kwargs.get("name"))
-        lg_node = (metadata or {}).get("langgraph_node")
-
-        # Record node-chain starts so the name-collision fallback in
-        # `_is_nested_pregel_start` can match the inner Pregel's
-        # parent_run_id to them.
-        if (
-            lg_node is not None
-            and lg_node not in _LANGGRAPH_SENTINEL_NODES
-            and name == lg_node
-        ):
-            self._task_run_ids.add(run_id)
-
-        if not _is_nested_pregel_start(
-            name, metadata, parent_run_id, self._task_run_ids
-        ):
-            return
-
-        ns = self._subgraph_ns_from_metadata(metadata)
-        if not ns:
-            return
-
-        self._run_to_ns[run_id] = ns
-        payload: dict[str, Any] = {"event": "started"}
-        if name:
-            payload["graph_name"] = name
-        # `cause` is intentionally not populated here: pregel does not know
-        # what on the parent namespace triggered this subgraph. Product-
-        # specific stream transformers populate `cause` before events
-        # reach the wire. See LifecycleCause in the protocol definition.
-        self._emit(ns, payload)
-        self._pending_running.add(ns)
-
-    def on_chain_end(
-        self,
-        response: Any,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        self._task_run_ids.discard(run_id)
-        ns = self._run_to_ns.pop(run_id, None)
-        if ns is None:
-            return
-        # Ensure started→running fired even for empty subgraphs.
-        if ns in self._pending_running:
-            self._pending_running.discard(ns)
-            self._emit(ns, {"event": "running"})
-        self._emit(ns, {"event": "completed"})
-
-    def on_chain_error(
-        self,
-        error: BaseException,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        self._task_run_ids.discard(run_id)
-        ns = self._run_to_ns.pop(run_id, None)
-        if ns is None:
-            return
-        self._pending_running.discard(ns)
-        if isinstance(error, GraphInterrupt):
-            self._emit(ns, {"event": "interrupted"})
-        else:
-            self._emit(ns, {"event": "failed", "error": str(error)})

libs/langgraph/langgraph/pregel/_loop.py

@@ -25,6 +25,7 @@ from langchain_core.callbacks import AsyncParentRunManager, ParentRunManager
 from langchain_core.runnables import RunnableConfig
 from langgraph.cache.base import BaseCache
 from langgraph.checkpoint.base import (
+    DELTA_SENTINEL,
     WRITES_IDX_MAP,
     BaseCheckpointSaver,
     ChannelVersions,
@@ -92,6 +93,7 @@ from langgraph.pregel._algo import (
     task_path_str,
 )
 from langgraph.pregel._checkpoint import (
+    achannels_from_checkpoint,
     channels_from_checkpoint,
     copy_checkpoint,
     create_checkpoint,
@@ -197,6 +199,7 @@ class PregelLoop:
     checkpoint_pending_writes: list[PendingWrite]
     checkpoint_previous_versions: dict[str, str | float | int]
     prev_checkpoint_config: RunnableConfig | None
+    _pending_write_futs: list[concurrent.futures.Future]
 
     status: Literal[
         "input",
@@ -406,7 +409,7 @@ class PregelLoop:
                     task = self.tasks.get(task_id)
                 else:
                     task = None
-                self.submit(
+                fut = self.submit(
                     self.checkpointer_put_writes,
                     config,
                     writes_to_save,
@@ -414,12 +417,13 @@ class PregelLoop:
                     task_path_str(task.path) if task else "",
                 )
             else:
-                self.submit(
+                fut = self.submit(
                     self.checkpointer_put_writes,
                     config,
                     writes_to_save,
                     task_id,
                 )
+            self._pending_write_futs.append(fut)
         # output writes
         if hasattr(self, "tasks"):
             self.output_writes(task_id, writes)
@@ -692,7 +696,7 @@ class PregelLoop:
         # writes so that interrupt() calls re-fire instead of returning
         # stale values. But if we're actively resuming, keep them —
         # multi-interrupt scenarios need previously resolved values preserved.
-        if self.is_replaying and (
+        is_time_traveling = self.is_replaying and (
             # Time-travel to a subgraph checkpoint: the parent sets
             # RESUMING=True (it can't distinguish time-travel from resume),
             # so we check if this subgraph's own ns is in checkpoint_map.
@@ -710,7 +714,8 @@ class PregelLoop:
                 # (subgraph input is a Send arg, not a Command)
                 or configurable.get(CONFIG_KEY_RESUMING, False)
             )
-        ):
+        )
+        if is_time_traveling:
             self.checkpoint_pending_writes = [
                 w for w in self.checkpoint_pending_writes if w[1] != RESUME
             ]
@@ -765,6 +770,26 @@ class PregelLoop:
                 if k in self.checkpoint["channel_versions"]:
                     version = self.checkpoint["channel_versions"][k]
                     self.checkpoint["versions_seen"][INTERRUPT][k] = version
+            # When time-traveling (replaying from a specific checkpoint),
+            # save a fork checkpoint so the replayed execution creates a
+            # new branch. Without this, if the execution hits an interrupt
+            # before after_tick() runs, no new checkpoint is created —
+            # the parent's latest checkpoint remains the old one and
+            # subsequent resumes load the wrong state.
+            # Skip for update_state forks (source=update/fork) since they
+            # already have their own fork checkpoint.
+            if is_time_traveling and self.checkpoint_metadata.get("source") not in (
+                "update",
+                "fork",
+            ):
+                # Clear old INTERRUPT writes from the loaded checkpoint.
+                # The fork will have a new checkpoint_id which changes
+                # task IDs — stale interrupt writes would accumulate and
+                # confuse the multiple-interrupt check in future resumes.
+                self.checkpoint_pending_writes = [
+                    w for w in self.checkpoint_pending_writes if w[1] != INTERRUPT
+                ]
+                self._put_checkpoint({"source": "fork"})
             # produce values output
             self._emit(
                 "values", map_output_values, self.output_keys, True, self.channels
@@ -807,14 +832,28 @@ class PregelLoop:
         if not self.is_nested:
             # Pass the resolved before-bound checkpoint ID so subgraphs can
             # find their corresponding checkpoint without re-fetching the
-            # parent. For forks (source=update), use the fork's parent
+            # parent. For forks (source=update/fork), use the fork's parent
             # checkpoint ID since the fork was created after the subgraph's
             # checkpoints from the original execution.
+            #
+            # Only gate on is_time_traveling (not is_replaying). When the
+            # client resumes with an explicit checkpoint_id that happens to
+            # point at the current head (e.g. LangGraph Studio sending
+            # `checkpoint: {checkpoint_id}` alongside Command(resume=...)),
+            # is_replaying is True but is_time_traveling is False. In that
+            # case subgraphs should load their latest checkpoint normally,
+            # not go through ReplayState's before-bound lookup which would
+            # miss subgraph checkpoints created during processing of the
+            # current parent step.
             replay_state: ReplayState | None = None
-            if self.is_replaying:
+            if is_time_traveling:
                 replay_checkpoint_id = self.checkpoint["id"]
                 if (
-                    self.checkpoint_metadata.get("source") == "update"
+                    self.checkpoint_metadata.get("source")
+                    in (
+                        "update",
+                        "fork",
+                    )
                     and self.prev_checkpoint_config
                 ):
                     replay_checkpoint_id = self.prev_checkpoint_config[CONF].get(
@@ -855,6 +894,9 @@ class PregelLoop:
             self.step,
             id=self.checkpoint["id"] if exiting else None,
             updated_channels=self.updated_channels,
+            get_next_version=self.checkpointer_get_next_version
+            if do_checkpoint
+            else None,
         )
         # sanitize TASK channel in the checkpoint before saving (durability=="exit")
         if TASKS in self.checkpoint["channel_values"] and any(
@@ -892,6 +934,17 @@ class PregelLoop:
             )
             self.checkpoint_previous_versions = channel_versions
 
+            # If the checkpoint has any DELTA_SENTINEL blobs, the sentinel is
+            # only meaningful if checkpoint_writes are durable first.  Flush
+            # pending write futures synchronously before committing the blob so
+            # we never end up with a sentinel blob backed by missing writes.
+            if self._pending_write_futs and any(
+                v is DELTA_SENTINEL for v in self.checkpoint["channel_values"].values()
+            ):
+                for fut in self._pending_write_futs:
+                    fut.result()
+                self._pending_write_futs.clear()
+
             # save it, without blocking
             # if there's a previous checkpoint save in progress, wait for it
             # ensuring checkpointers receive checkpoints in order
@@ -1236,9 +1289,13 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
             if saved.pending_writes is not None
             else []
         )
+        self._pending_write_futs = []
         self.submit = self.stack.enter_context(BackgroundExecutor(self.config))
         self.channels, self.managed = channels_from_checkpoint(
-            self.specs, self.checkpoint
+            self.specs,
+            self.checkpoint,
+            saver=self.checkpointer,
+            config=self.checkpoint_config,
         )
         self.stack.push(self._suppress_interrupt)
         self.status = "input"
@@ -1438,11 +1495,15 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
             if saved.pending_writes is not None
             else []
         )
+        self._pending_write_futs = []
         self.submit = await self.stack.enter_async_context(
             AsyncBackgroundExecutor(self.config)
         )
-        self.channels, self.managed = channels_from_checkpoint(
-            self.specs, self.checkpoint
+        self.channels, self.managed = await achannels_from_checkpoint(
+            self.specs,
+            self.checkpoint,
+            saver=self.checkpointer,
+            config=self.checkpoint_config,
         )
         self.stack.push(self._suppress_interrupt)
         self.status = "input"

libs/langgraph/langgraph/pregel/_messages.py

@@ -14,7 +14,7 @@ from langchain_core.messages import BaseMessage
 from langchain_core.outputs import ChatGeneration, ChatGenerationChunk, LLMResult
 from pydantic import BaseModel
 
-from langgraph._internal._constants import NS_END, NS_SEP
+from langgraph._internal._constants import NS_SEP
 from langgraph.constants import TAG_HIDDEN, TAG_NOSTREAM
 from langgraph.pregel.protocol import StreamChunk
 from langgraph.types import Command
@@ -24,11 +24,6 @@ try:
 except ImportError:
     _StreamingCallbackHandler = object  # type: ignore
 
-try:
-    from langchain_core.tracers._streaming import _V2StreamingCallbackHandler
-except ImportError:
-    _V2StreamingCallbackHandler = object  # type: ignore
-
 T = TypeVar("T")
 Meta = tuple[tuple[str, ...], dict[str, Any]]
 
@@ -137,23 +132,15 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         **kwargs: Any,
     ) -> Any:
         if metadata and (not tags or (TAG_NOSTREAM not in tags)):
-            task_checkpoint_ns = cast(str, metadata["langgraph_checkpoint_ns"])
-            checkpoint_ns = (
-                f"{task_checkpoint_ns.rsplit(NS_END, 1)[0]}{NS_END}"
-                if NS_END in task_checkpoint_ns
-                else task_checkpoint_ns
-            )
-            ns = tuple(task_checkpoint_ns.split(NS_SEP))[:-1]
+            ns = tuple(cast(str, metadata["langgraph_checkpoint_ns"]).split(NS_SEP))[
+                :-1
+            ]
             if not self.subgraphs and len(ns) > 0 and ns != self.parent_ns:
                 return
-            stream_metadata = dict(metadata)
-            stream_metadata["langgraph_checkpoint_ns"] = checkpoint_ns
-            # Preserve backwards-compatible streamed checkpoint metadata shape.
-            stream_metadata["checkpoint_ns"] = checkpoint_ns
             if tags:
                 if filtered_tags := [t for t in tags if not t.startswith("seq:step")]:
-                    stream_metadata["tags"] = filtered_tags
-            self.metadata[run_id] = (ns, stream_metadata)
+                    metadata["tags"] = filtered_tags
+            self.metadata[run_id] = (ns, metadata)
 
     def on_llm_new_token(
         self,
@@ -261,185 +248,3 @@ class StreamMessagesHandler(BaseCallbackHandler, _StreamingCallbackHandler):
         **kwargs: Any,
     ) -> Any:
         self.metadata.pop(run_id, None)
-
-
-class StreamMessagesHandlerV2(StreamMessagesHandler, _V2StreamingCallbackHandler):
-    """v2 variant of `StreamMessagesHandler`.
-
-    Declaring `_V2StreamingCallbackHandler` as a base flips
-    `BaseChatModel.invoke` to route through `_stream_chat_model_events`
-    (firing `on_stream_event`) instead of `_stream` (firing
-    `on_llm_new_token`). Inherits `on_stream_event` from the parent,
-    which forwards protocol events onto the messages stream channel.
-
-    Pregel attaches this class instead of the v1 handler only when
-    `GraphStreamer` opts in via the internal
-    `CONFIG_KEY_STREAM_MESSAGES_V2` config key; direct
-    `graph.stream(stream_mode="messages")` callers keep the v1
-    AIMessageChunk shape.
-    """
-
-    def on_chat_model_start(
-        self,
-        serialized: dict[str, Any],
-        messages: list[list[BaseMessage]],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Record metadata with the FULL checkpoint namespace for v2.
-
-        v1's ``on_chat_model_start`` (inherited) slices the ns tuple
-        with ``[:-1]`` to re-position chat model tokens onto the
-        *containing pregel's* namespace — historically convenient for
-        consumers of ``stream_mode="messages"`` who want "where did
-        this node produce its output" rather than the chat-model's
-        own task ns.
-
-        For the protocol-v2 wire shape that is wrong: the client
-        subscribes the root feed at ``namespaces=[[]]`` with
-        ``depth=1``, and any message emitted at depth ``>=1`` that
-        still carries the containing node's ns must appear at the
-        *full* path from root so that depth filtering cleanly isolates
-        subgraph chatter from the root conversation. JS's
-        ``StreamMessagesHandlerV2`` already does
-        ``metadata.langgraph_checkpoint_ns.split("|")`` (no slice); this
-        override brings the Python v2 handler to the same shape.
-
-        Without this, a chat model invoked inside a nested subgraph
-        (e.g. ``research -> researcher``, ``research`` being a root
-        node that ``.ainvoke()``s a ``researcher`` subgraph) emits at
-        ``["research:<task>"]`` — a single level deep — which slips
-        through the root-feed depth-1 filter and pollutes the main
-        conversation with subgraph tokens. With this override we emit
-        at ``["research:<task>", "researcher:<task>"]`` so the client
-        routes those tokens to the subgraph card instead.
-        """
-        if metadata and (not tags or (TAG_NOSTREAM not in tags)):
-            task_checkpoint_ns = cast(str, metadata["langgraph_checkpoint_ns"])
-            # Keep the trailing ``:<task_id>`` segment (unlike the v1
-            # handler which strips it via ``[:-1]``). The client's
-            # lifecycle events land on the same ns, so message deltas
-            # now correlate 1:1 with a ``lifecycle: started`` event —
-            # ``useMessages(stream, subgraph)`` picks them up without
-            # needing to collapse sibling namespaces.
-            ns = tuple(task_checkpoint_ns.split(NS_SEP))
-            if not self.subgraphs and len(ns) > 1 and ns != self.parent_ns:
-                return
-            stream_metadata = dict(metadata)
-            # Preserve the v1-shaped ``langgraph_checkpoint_ns`` (task
-            # id stripped, trailing ``NS_END`` retained) so downstream
-            # consumers reading checkpoint metadata off a streamed
-            # message see the same shape they did pre-v2. Only the ns
-            # tuple emitted on the wire changes.
-            checkpoint_ns = (
-                f"{task_checkpoint_ns.rsplit(NS_END, 1)[0]}{NS_END}"
-                if NS_END in task_checkpoint_ns
-                else task_checkpoint_ns
-            )
-            stream_metadata["langgraph_checkpoint_ns"] = checkpoint_ns
-            stream_metadata["checkpoint_ns"] = checkpoint_ns
-            if tags:
-                if filtered_tags := [t for t in tags if not t.startswith("seq:step")]:
-                    stream_metadata["tags"] = filtered_tags
-            self.metadata[run_id] = (ns, stream_metadata)
-
-    def on_chain_start(
-        self,
-        serialized: dict[str, Any],
-        inputs: dict[str, Any],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Record chain (node) metadata with the FULL checkpoint ns.
-
-        Mirror of :meth:`on_chat_model_start` for the node-start path,
-        so messages returned by ``on_chain_end`` (``Command`` updates
-        and plain state dict outputs) land at the same full-path ns as
-        any chat-model deltas from within that node. See the
-        :meth:`on_chat_model_start` docstring for why the v1 ``[:-1]``
-        slice is dropped here.
-        """
-        if (
-            metadata
-            and kwargs.get("name") == metadata.get("langgraph_node")
-            and (not tags or TAG_HIDDEN not in tags)
-        ):
-            ns = tuple(cast(str, metadata["langgraph_checkpoint_ns"]).split(NS_SEP))
-            if not self.subgraphs and len(ns) > 1:
-                return
-            self.metadata[run_id] = (ns, metadata)
-            for value in _state_values(inputs):
-                if isinstance(value, BaseMessage):
-                    if value.id is not None:
-                        self.seen.add(value.id)
-                elif isinstance(value, Sequence) and not isinstance(value, str):
-                    for item in value:
-                        if isinstance(item, BaseMessage):
-                            if item.id is not None:
-                                self.seen.add(item.id)
-
-    def on_llm_new_token(
-        self,
-        token: str,
-        *,
-        chunk: ChatGenerationChunk | None = None,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Intentional no-op — v1 chunks are not used on v2-flagged runs.
-
-        The v2 marker already steers `invoke` to the event generator, so
-        `on_llm_new_token` should not fire under normal routing. This
-        override stays a pass-through (no call to `super()`) to make
-        the intent explicit and to guard against any caller (e.g. a
-        node that calls `model.stream()` directly, which still fires
-        the v1 callback) leaking AIMessageChunks onto a v2-flagged
-        messages stream.
-        """
-        # Intentionally empty: v2 handler does not forward v1 chunks.
-
-    def on_stream_event(
-        self,
-        event: dict[str, Any],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Forward a protocol event from `stream_v2` as a messages stream part.
-
-        Fires once per `MessagesData` event (`message-start`, per-block
-        `content-block-*`, `message-finish`). The transformer layer
-        correlates events back to a single `ChatModelStream` via
-        `metadata["run_id"]` — attached here so the v1
-        `stream_mode="messages"` output (which emits
-        `(AIMessageChunk, metadata)` via `on_llm_new_token`) keeps its
-        original metadata shape.
-
-        Lives on the v2 handler rather than the v1 base: content-block
-        events are a v2-only concept, and forwarding them only when the
-        v2 handler is attached keeps the message channel's shape
-        predictable for v1 callers.
-        """
-        if meta := self.metadata.get(run_id):
-            # Record message_id on message-start so on_chain_end's
-            # dedupe skips the finalized AIMessage the node returns
-            # (otherwise the messages projection double-counts: once
-            # from streaming, once from the chain output).
-            if event.get("event") == "message-start":
-                msg_id = event.get("message_id")
-                if msg_id:
-                    self.seen.add(msg_id)
-            v2_meta = {**meta[1], "run_id": str(run_id)}
-            self.stream((meta[0], "messages", (event, v2_meta)))

libs/langgraph/langgraph/pregel/_tools.py

@@ -1,223 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator, Callable, Iterator
-from contextvars import Token
-from typing import Any, TypeVar, cast
-from uuid import UUID
-
-from langchain_core.callbacks import BaseCallbackHandler
-
-from langgraph._internal._constants import NS_SEP
-from langgraph.config import _tool_call_writer
-from langgraph.pregel.protocol import StreamChunk
-
-try:
-    from langchain_core.tracers._streaming import _StreamingCallbackHandler
-except ImportError:
-    _StreamingCallbackHandler = object  # type: ignore[assignment,misc]
-
-
-T = TypeVar("T")
-
-ToolCallWriter = Callable[[Any], None]
-"""A closure bound to a single tool call that emits `tool-output-delta` events."""
-
-
-class StreamToolCallHandler(BaseCallbackHandler, _StreamingCallbackHandler):
-    """Callback handler that emits tool-call lifecycle events on the stream.
-
-    Fires on LangChain's `on_tool_*` callbacks and pushes to the `tools`
-    stream mode. Emits `tool-started` / `tool-output-delta` /
-    `tool-finished` / `tool-error` payloads keyed by `tool_call_id`.
-
-    While a tool is executing, this handler sets `_tool_call_writer` to a
-    closure bound to that call's namespace and `tool_call_id`. The
-    `emit_tool_output_delta` helper in `langgraph.config` reads that
-    ContextVar so tool bodies can stream partial output without threading
-    the writer through their own signature.
-
-    Attached by `Pregel.stream` / `astream` when `"tools"` is in
-    `stream_modes`. `run_inline = True` keeps event ordering
-    deterministic.
-    """
-
-    run_inline = True
-
-    def __init__(self, stream: Callable[[StreamChunk], None]) -> None:
-        """Initialize the handler.
-
-        Args:
-            stream: Callable that accepts a `StreamChunk` tuple
-                `(namespace, mode, payload)` and enqueues it.
-        """
-        self.stream = stream
-        # run_id → (namespace, tool_call_id, ContextVar token)
-        # `on_tool_end` does not receive `tool_call_id` in kwargs, so
-        # we correlate by `run_id` which is present on every callback.
-        self._run_to_call: dict[
-            UUID, tuple[tuple[str, ...], str, Token[ToolCallWriter | None]]
-        ] = {}
-
-    @staticmethod
-    def _containing_ns_from_metadata(
-        metadata: dict[str, Any] | None,
-    ) -> tuple[str, ...]:
-        """Return the namespace of the subgraph that contains this tool call.
-
-        `langgraph_checkpoint_ns` on a tool's callback metadata ends with
-        the `node_name:task_id` segment of the node that invoked the
-        tool. Dropping that segment gives the subgraph's own namespace,
-        which matches what other `tools` / `lifecycle` / `messages`
-        emitters use.
-        """
-        if not metadata:
-            return ()
-        nskey = metadata.get("langgraph_checkpoint_ns")
-        if not nskey:
-            return ()
-        return tuple(cast(str, nskey).split(NS_SEP))[:-1]
-
-    def _start(
-        self,
-        serialized: dict[str, Any] | None,
-        input_str: str,
-        *,
-        run_id: UUID,
-        metadata: dict[str, Any] | None,
-        inputs: dict[str, Any] | None,
-        kwargs: dict[str, Any],
-    ) -> None:
-        tool_call_id = cast("str | None", kwargs.get("tool_call_id")) or str(run_id)
-        tool_name = (
-            (serialized or {}).get("name")
-            or cast("str | None", kwargs.get("name"))
-            or ""
-        )
-        ns = self._containing_ns_from_metadata(metadata)
-
-        def writer(delta: Any) -> None:
-            self.stream(
-                (
-                    ns,
-                    "tools",
-                    {
-                        "event": "tool-output-delta",
-                        "tool_call_id": tool_call_id,
-                        "delta": delta,
-                    },
-                )
-            )
-
-        token = _tool_call_writer.set(writer)
-        self._run_to_call[run_id] = (ns, tool_call_id, token)
-
-        payload: dict[str, Any] = {
-            "event": "tool-started",
-            "tool_call_id": tool_call_id,
-            "tool_name": tool_name,
-        }
-        if inputs is not None:
-            payload["input"] = inputs
-        self.stream((ns, "tools", payload))
-
-    def _end(self, output: Any, *, run_id: UUID) -> None:
-        info = self._run_to_call.pop(run_id, None)
-        if info is None:
-            return
-        ns, tool_call_id, token = info
-        self._reset_writer(token)
-        self.stream(
-            (
-                ns,
-                "tools",
-                {
-                    "event": "tool-finished",
-                    "tool_call_id": tool_call_id,
-                    "output": output,
-                },
-            )
-        )
-
-    def _error(self, error: BaseException, *, run_id: UUID) -> None:
-        info = self._run_to_call.pop(run_id, None)
-        if info is None:
-            return
-        ns, tool_call_id, token = info
-        self._reset_writer(token)
-        self.stream(
-            (
-                ns,
-                "tools",
-                {
-                    "event": "tool-error",
-                    "tool_call_id": tool_call_id,
-                    "message": str(error),
-                },
-            )
-        )
-
-    def tap_output_aiter(
-        self, run_id: UUID, output: AsyncIterator[T]
-    ) -> AsyncIterator[T]:
-        """Pass-through — required by the `_StreamingCallbackHandler` protocol."""
-        return output
-
-    def tap_output_iter(self, run_id: UUID, output: Iterator[T]) -> Iterator[T]:
-        """Pass-through — sync counterpart to `tap_output_aiter`."""
-        return output
-
-    @staticmethod
-    def _reset_writer(token: Token[ToolCallWriter | None]) -> None:
-        # Token is invalid if `on_tool_end` runs in a different context
-        # than `on_tool_start` (e.g. langchain may hand off to a thread
-        # worker without copying the context). Swallow that case; the
-        # ContextVar lifetime is bounded by the enclosing task anyway.
-        try:
-            _tool_call_writer.reset(token)
-        except ValueError:
-            pass
-
-    # ------------------------------------------------------------------
-    # Sync callbacks
-    # ------------------------------------------------------------------
-
-    def on_tool_start(
-        self,
-        serialized: dict[str, Any],
-        input_str: str,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        inputs: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        self._start(
-            serialized,
-            input_str,
-            run_id=run_id,
-            metadata=metadata,
-            inputs=inputs,
-            kwargs=kwargs,
-        )
-
-    def on_tool_end(
-        self,
-        output: Any,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        self._end(output, run_id=run_id)
-
-    def on_tool_error(
-        self,
-        error: BaseException,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        self._error(error, run_id=run_id)

libs/langgraph/langgraph/pregel/main.py

@@ -73,7 +73,6 @@ from langgraph._internal._constants import (
     CONFIG_KEY_RUNTIME,
     CONFIG_KEY_SEND,
     CONFIG_KEY_STREAM,
-    CONFIG_KEY_STREAM_MESSAGES_V2,
     CONFIG_KEY_TASK_ID,
     CONFIG_KEY_THREAD_ID,
     ERROR,
@@ -123,6 +122,7 @@ from langgraph.pregel._algo import (
 )
 from langgraph.pregel._call import identifier
 from langgraph.pregel._checkpoint import (
+    achannels_from_checkpoint,
     channels_from_checkpoint,
     copy_checkpoint,
     create_checkpoint,
@@ -130,19 +130,14 @@ from langgraph.pregel._checkpoint import (
 )
 from langgraph.pregel._draw import draw_graph
 from langgraph.pregel._io import map_input, read_channels
-from langgraph.pregel._lifecycle import StreamLifecycleHandler
 from langgraph.pregel._loop import (
     AsyncPregelLoop,
     SyncPregelLoop,
 )
-from langgraph.pregel._messages import (
-    StreamMessagesHandler,
-    StreamMessagesHandlerV2,
-)
+from langgraph.pregel._messages import StreamMessagesHandler
 from langgraph.pregel._read import DEFAULT_BOUND, PregelNode
 from langgraph.pregel._retry import RetryPolicy
 from langgraph.pregel._runner import PregelRunner
-from langgraph.pregel._tools import StreamToolCallHandler
 from langgraph.pregel._utils import get_new_channel_versions
 from langgraph.pregel._validate import validate_graph, validate_keys
 from langgraph.pregel._write import ChannelWrite, ChannelWriteEntry
@@ -346,65 +341,6 @@ class NodeBuilder:
         )
 
 
-def _collect_stream_modes(mux: Any) -> list[StreamMode]:
-    """Return the union of `required_stream_modes` across registered transformers.
-
-    Transformers declare the stream modes they need to function, and
-    `stream_v2` asks the graph for exactly that union — no hardcoded
-    default set. If zero transformers are registered (or none declares
-    a given mode), the graph does not stream events for that mode.
-    """
-    modes: set[str] = set()
-    for transformer in mux._transformers:
-        modes.update(transformer.required_stream_modes)
-    return cast("list[StreamMode]", list(modes))
-
-
-def _build_stream_factories(
-    compile_time: Sequence[Callable[..., Any]],
-    call_site: Sequence[Any] | None,
-) -> list[Callable[..., Any]]:
-    """Assemble the factory list handed to `StreamMux(factories=...)`.
-
-    Prepends the built-in `ValuesTransformer`, `MessagesTransformer`,
-    and `SubgraphTransformer` factories, then appends the graph's
-    compile-time `stream_transformers` followed by any call-site
-    additions. Factories flow down into subgraph mini-muxes, so
-    per-scope instances propagate automatically.
-    """
-    from langgraph.stream.transformers import (
-        MessagesTransformer,
-        SubgraphTransformer,
-        ToolLifecycleTransformer,
-        ValuesTransformer,
-    )
-
-    builtins: list[Callable[..., Any]] = [
-        ValuesTransformer,
-        ToolLifecycleTransformer,
-        MessagesTransformer,
-        SubgraphTransformer,
-    ]
-    return [*builtins, *compile_time, *(call_site or ())]
-
-
-def _merge_v2_messages_flag(
-    config: RunnableConfig | None,
-) -> RunnableConfig:
-    """Return a config with the v2 messages flag set in `configurable`.
-
-    Signals to pregel that `stream_mode="messages"` should attach
-    `StreamMessagesHandlerV2` for this call so invoke-time model runs
-    route through the v2 event generator and their protocol events
-    reach the messages channel.
-    """
-    merged: RunnableConfig = dict(config or {})  # type: ignore[assignment]
-    configurable = dict(merged.get(CONF) or {})
-    configurable[CONFIG_KEY_STREAM_MESSAGES_V2] = True
-    merged[CONF] = configurable
-    return merged
-
-
 class Pregel(
     PregelProtocol[StateT, ContextT, InputT, OutputT],
     Generic[StateT, ContextT, InputT, OutputT],
@@ -736,7 +672,6 @@ class Pregel(
         config: RunnableConfig | None = None,
         trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
         name: str = "LangGraph",
-        stream_transformers: Sequence[Callable[..., Any]] | None = None,
         **deprecated_kwargs: Unpack[DeprecatedKwargs],
     ) -> None:
         if (
@@ -783,9 +718,6 @@ class Pregel(
         self.config = config
         self.trigger_to_nodes = trigger_to_nodes or {}
         self.name = name
-        self._stream_transformers: tuple[Callable[..., Any], ...] = tuple(
-            stream_transformers or ()
-        )
         self._serde_allowlist: set[tuple[str, ...]] | None = None
         if auto_validate:
             self.validate()
@@ -876,15 +808,6 @@ class Pregel(
 
     def copy(self, update: dict[str, Any] | None = None) -> Self:
         attrs = {k: v for k, v in self.__dict__.items() if k != "__orig_class__"}
-        # ``__init__`` accepts ``stream_transformers`` (public parameter) but
-        # the attribute is stored as ``_stream_transformers`` (private). Map
-        # the private key back onto the public kwarg so compile-time
-        # transformers survive ``copy()`` / ``with_config()``. Without this,
-        # ``_stream_transformers`` gets captured by ``**deprecated_kwargs``
-        # and the resulting instance silently has an empty transformer
-        # pipeline.
-        if "_stream_transformers" in attrs:
-            attrs["stream_transformers"] = attrs.pop("_stream_transformers")
         attrs.update(update or {})
         return self.__class__(**attrs)
 
@@ -1130,6 +1053,10 @@ class Pregel(
         channels, managed = channels_from_checkpoint(
             self.channels,
             saved.checkpoint,
+            saver=self.checkpointer
+            if isinstance(self.checkpointer, BaseCheckpointSaver)
+            else None,
+            config=saved.config,
         )
         # tasks for this checkpoint
         next_tasks = prepare_next_tasks(
@@ -1246,9 +1173,13 @@ class Pregel(
 
         step = saved.metadata.get("step", -1) + 1
         stop = step + 2
-        channels, managed = channels_from_checkpoint(
+        channels, managed = await achannels_from_checkpoint(
             self.channels,
             saved.checkpoint,
+            saver=self.checkpointer
+            if isinstance(self.checkpointer, BaseCheckpointSaver)
+            else None,
+            config=saved.config,
         )
         # tasks for this checkpoint
         next_tasks = prepare_next_tasks(
@@ -1619,6 +1550,11 @@ class Pregel(
             channels, managed = channels_from_checkpoint(
                 self.channels,
                 checkpoint,
+                saver=self.checkpointer
+                if saved is not None
+                and isinstance(self.checkpointer, BaseCheckpointSaver)
+                else None,
+                config=saved.config if saved is not None else None,
             )
             values, as_node = updates[0][:2]
 
@@ -2062,9 +1998,14 @@ class Pregel(
             )
             if saved:
                 checkpoint_config = patch_configurable(config, saved.config[CONF])
-            channels, managed = channels_from_checkpoint(
+            channels, managed = await achannels_from_checkpoint(
                 self.channels,
                 checkpoint,
+                saver=self.checkpointer
+                if saved is not None
+                and isinstance(self.checkpointer, BaseCheckpointSaver)
+                else None,
+                config=saved.config if saved is not None else None,
             )
             values, as_node = updates[0][:2]
             # no values, just clear all tasks
@@ -2704,34 +2645,14 @@ class Pregel(
             # set up messages stream mode
             if "messages" in stream_modes:
                 ns_ = cast(str | None, config[CONF].get(CONFIG_KEY_CHECKPOINT_NS))
-                messages_handler_cls = (
-                    StreamMessagesHandlerV2
-                    if config[CONF].get(CONFIG_KEY_STREAM_MESSAGES_V2)
-                    else StreamMessagesHandler
-                )
                 run_manager.inheritable_handlers.append(
-                    messages_handler_cls(
+                    StreamMessagesHandler(
                         stream.put,
                         subgraphs,
                         parent_ns=tuple(ns_.split(NS_SEP)) if ns_ else None,
                     )
                 )
 
-            # set up lifecycle stream mode
-            if "lifecycle" in stream_modes:
-                run_manager.inheritable_handlers.append(
-                    StreamLifecycleHandler(
-                        stream.put,
-                        root_graph_name=self.name,
-                    )
-                )
-
-            # set up tools stream mode
-            if "tools" in stream_modes:
-                run_manager.inheritable_handlers.append(
-                    StreamToolCallHandler(stream.put)
-                )
-
             # set up custom stream mode
             if "custom" in stream_modes:
 
@@ -3101,34 +3022,14 @@ class Pregel(
             if "messages" in stream_modes:
                 # namespace can be None in a root level graph?
                 ns_ = cast(str | None, config[CONF].get(CONFIG_KEY_CHECKPOINT_NS))
-                messages_handler_cls = (
-                    StreamMessagesHandlerV2
-                    if config[CONF].get(CONFIG_KEY_STREAM_MESSAGES_V2)
-                    else StreamMessagesHandler
-                )
                 run_manager.inheritable_handlers.append(
-                    messages_handler_cls(
+                    StreamMessagesHandler(
                         stream_put,
                         subgraphs,
                         parent_ns=tuple(ns_.split(NS_SEP)) if ns_ else None,
                     )
                 )
 
-            # set up lifecycle stream mode
-            if "lifecycle" in stream_modes:
-                run_manager.inheritable_handlers.append(
-                    StreamLifecycleHandler(
-                        stream_put,
-                        root_graph_name=self.name,
-                    )
-                )
-
-            # set up tools stream mode
-            if "tools" in stream_modes:
-                run_manager.inheritable_handlers.append(
-                    StreamToolCallHandler(stream_put)
-                )
-
             # set up custom stream mode
             def stream_writer(c: Any) -> None:
                 aioloop.call_soon_threadsafe(
@@ -3355,106 +3256,6 @@ class Pregel(
             await asyncio.shield(run_manager.on_chain_error(e))
             raise
 
-    def stream_v2(
-        self,
-        input: InputT | Command | None,
-        config: RunnableConfig | None = None,
-        *,
-        interrupt_before: All | Sequence[str] | None = None,
-        interrupt_after: All | Sequence[str] | None = None,
-        transformers: Sequence[Any] | None = None,
-        stream_modes: Sequence[StreamMode] | None = None,
-        output_keys: str | Sequence[str] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Start a sync v2 streaming run driven by transformer projections.
-
-        Builds a `StreamMux` from the built-in `ValuesTransformer` /
-        `MessagesTransformer`, this graph's compile-time
-        `stream_transformers`, and any additional `transformers=`
-        supplied at the call site. Returns a `GraphRunStream` that the
-        caller drives by iterating any projection — no background
-        thread.
-
-        Args:
-            input: Graph input.
-            config: Optional runnable config forwarded to the graph.
-            interrupt_before: Nodes to interrupt before, if any.
-            interrupt_after: Nodes to interrupt after, if any.
-            transformers: Extra transformer instances appended after
-                compile-time `stream_transformers`.
-
-        Returns:
-            A `GraphRunStream` the caller iterates to drive the run.
-        """
-        from langgraph.stream._mux import StreamMux
-        from langgraph.stream.run_stream import GraphRunStream
-
-        factories = _build_stream_factories(self._stream_transformers, transformers)
-        mux = StreamMux(factories=factories, is_async=False)
-        requested_stream_modes = set(_collect_stream_modes(mux))
-        requested_stream_modes.update(stream_modes or ())
-        graph_iter = iter(
-            self.stream(
-                input,
-                _merge_v2_messages_flag(config),
-                stream_mode=list(requested_stream_modes),
-                subgraphs=True,
-                version="v2",
-                output_keys=output_keys,
-                interrupt_before=interrupt_before,
-                interrupt_after=interrupt_after,
-                **kwargs,
-            )
-        )
-        return GraphRunStream(graph_iter, mux)
-
-    async def astream_v2(
-        self,
-        input: InputT | Command | None,
-        config: RunnableConfig | None = None,
-        *,
-        interrupt_before: All | Sequence[str] | None = None,
-        interrupt_after: All | Sequence[str] | None = None,
-        transformers: Sequence[Any] | None = None,
-        stream_modes: Sequence[StreamMode] | None = None,
-        output_keys: str | Sequence[str] | None = None,
-        **kwargs: Any,
-    ) -> Any:
-        """Async counterpart to `stream_v2`.
-
-        Returns an `AsyncGraphRunStream` whose projections can be awaited
-        concurrently; each subscribed cursor drives the pump when its
-        buffer is empty.
-
-        Args:
-            input: Graph input.
-            config: Optional runnable config forwarded to the graph.
-            interrupt_before: Nodes to interrupt before, if any.
-            interrupt_after: Nodes to interrupt after, if any.
-            transformers: Extra transformer instances appended after
-                compile-time `stream_transformers`.
-        """
-        from langgraph.stream._mux import StreamMux
-        from langgraph.stream.run_stream import AsyncGraphRunStream
-
-        factories = _build_stream_factories(self._stream_transformers, transformers)
-        mux = StreamMux(factories=factories, is_async=True)
-        requested_stream_modes = set(_collect_stream_modes(mux))
-        requested_stream_modes.update(stream_modes or ())
-        graph_aiter = self.astream(
-            input,
-            _merge_v2_messages_flag(config),
-            stream_mode=list(requested_stream_modes),
-            subgraphs=True,
-            version="v2",
-            output_keys=output_keys,
-            interrupt_before=interrupt_before,
-            interrupt_after=interrupt_after,
-            **kwargs,
-        ).__aiter__()
-        return AsyncGraphRunStream(graph_aiter, mux)
-
     @overload
     def invoke(
         self,

libs/langgraph/langgraph/pregel/remote.py

@@ -650,46 +650,22 @@ class RemoteGraph(PregelProtocol):
         """
         updated_stream_modes: list[StreamModeSDK] = []
         req_single = True
-        # `"lifecycle"` is emitted locally by the `StreamLifecycleHandler`
-        # attached inside `Pregel.stream` / `astream`. The remote graph
-        # API has no corresponding mode, so requests for it against a
-        # `RemoteGraph` are silently stripped here and a warning is
-        # logged so the caller isn't left wondering why no lifecycle
-        # events arrive.
-        dropped_lifecycle = False
         # coerce to list, or add default stream mode
         if stream_mode:
             if isinstance(stream_mode, str):
-                if stream_mode != "lifecycle":
-                    updated_stream_modes.append(cast(StreamModeSDK, stream_mode))
-                else:
-                    dropped_lifecycle = True
+                updated_stream_modes.append(stream_mode)
             else:
                 req_single = False
-                for m in stream_mode:
-                    if m == "lifecycle":
-                        dropped_lifecycle = True
-                    else:
-                        updated_stream_modes.append(cast(StreamModeSDK, m))
+                updated_stream_modes.extend(stream_mode)
         else:
-            updated_stream_modes.append(default)  # type: ignore[arg-type]
+            updated_stream_modes.append(default)
         requested_stream_modes = updated_stream_modes.copy()
         # add any from parent graph
         stream: StreamProtocol | None = (
             (config or {}).get(CONF, {}).get(CONFIG_KEY_STREAM)
         )
         if stream:
-            for m in stream.modes:
-                if m == "lifecycle":
-                    dropped_lifecycle = True
-                else:
-                    updated_stream_modes.append(cast(StreamModeSDK, m))
-        if dropped_lifecycle:
-            logger.warning(
-                "Stream mode 'lifecycle' is not supported by RemoteGraph "
-                "and was stripped from the request; no lifecycle events "
-                "will be emitted for this remote run."
-            )
+            updated_stream_modes.extend(stream.modes)
         # map "messages" to "messages-tuple"
         if "messages" in updated_stream_modes:
             updated_stream_modes.remove("messages")

libs/langgraph/langgraph/stream/__init__.py

@@ -1,20 +0,0 @@
-"""Streaming infrastructure for LangGraph.
-
-Compile a graph with `transformers=[...]` and call `graph.stream_v2()` /
-`graph.astream_v2()` to drive a transformer pipeline that projects the
-graph's raw events into ergonomic per-channel streams.
-"""
-
-from langgraph.stream._event_log import EventLog
-from langgraph.stream._types import ProtocolEvent, StreamTransformer
-from langgraph.stream.run_stream import AsyncGraphRunStream, GraphRunStream
-from langgraph.stream.stream_channel import StreamChannel
-
-__all__ = [
-    "AsyncGraphRunStream",
-    "EventLog",
-    "GraphRunStream",
-    "ProtocolEvent",
-    "StreamChannel",
-    "StreamTransformer",
-]

libs/langgraph/langgraph/stream/_convert.py

@@ -1,71 +0,0 @@
-from __future__ import annotations
-
-import time
-from typing import Any, cast
-
-from langgraph.stream._types import ProtocolEvent, _ProtocolEventParams
-from langgraph.types import StreamPart
-
-
-def _is_v2_messages_payload(data: Any) -> bool:
-    return isinstance(data, dict) and isinstance(data.get("event"), str)
-
-
-def _normalize_messages_data(data: dict[str, Any]) -> dict[str, Any]:
-    """Normalize Python Core message fields to the protocol wire shape."""
-    normalized = {**data}
-    if (
-        normalized["event"] == "message-start"
-        and "id" not in normalized
-        and isinstance(normalized.get("message_id"), str)
-    ):
-        normalized["id"] = normalized["message_id"]
-    if (
-        normalized["event"]
-        in ("content-block-start", "content-block-delta", "content-block-finish")
-        and "content" not in normalized
-        and isinstance(normalized.get("content_block"), dict)
-    ):
-        normalized["content"] = normalized["content_block"]
-    normalized.pop("message_id", None)
-    normalized.pop("content_block", None)
-    return normalized
-
-
-def convert_to_protocol_event(part: StreamPart) -> ProtocolEvent:
-    """Convert a v2 StreamPart to a ProtocolEvent.
-
-    Args:
-        part: A stream part with keys `type`, `ns`, `data`, and
-            optionally `interrupts` (present on values events).
-
-    Returns:
-        The equivalent ProtocolEvent.
-    """
-    part_dict = cast(dict[str, Any], part)
-    data = part_dict["data"]
-    params: _ProtocolEventParams = {
-        "namespace": list(part_dict["ns"]),
-        "timestamp": int(time.time() * 1000),
-        "data": data,
-    }
-    if (
-        part_dict["type"] == "messages"
-        and isinstance(data, tuple)
-        and len(data) == 2
-        and _is_v2_messages_payload(data[0])
-        and isinstance(data[1], dict)
-    ):
-        payload, metadata = data
-        params["data"] = _normalize_messages_data(payload)
-        if isinstance(metadata.get("langgraph_node"), str):
-            params["node"] = metadata["langgraph_node"]
-        if isinstance(metadata.get("run_id"), str):
-            params["run_id"] = metadata["run_id"]
-    if "interrupts" in part_dict:
-        params["interrupts"] = part_dict["interrupts"]
-    return {
-        "type": "event",
-        "method": part_dict["type"],
-        "params": params,
-    }

libs/langgraph/langgraph/stream/_event_log.py

@@ -1,306 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections import deque
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator
-from typing import Generic, TypeVar
-
-T = TypeVar("T")
-
-
-class EventLog(Generic[T]):
-    """Single-consumer drainable queue for streaming events.
-
-    Items are popped off the front as the consumer advances — there is
-    no retention beyond what's currently queued. A log accepts exactly
-    one subscriber; a second `__iter__` / `__aiter__` call raises. Use
-    `tee(n)` / `atee(n)` for fan-out.
-
-    Starts unbound — neither `__iter__` nor `__aiter__` is available
-    until the StreamMux calls `_bind(is_async)`. After binding, only
-    the matching iteration protocol works; the other raises `TypeError`.
-
-    Pump wiring (set by the run stream, not by `_bind`):
-        - `_request_more`: sync pump callable, returns True if a new
-          event was produced.
-        - `_arequest_more`: async pump coroutine factory, same contract.
-
-    Memory is bounded by caller pace: both sync and async use caller-
-    driven pumps, so each cursor advance produces at most one event.
-    The only shape where a log can accumulate meaningfully is
-    concurrent async consumers at unequal rates — a slow consumer's
-    log grows while fast consumers drive the shared pump. That's the
-    documented tradeoff for concurrent consumption; consume at similar
-    rates or use a single consumer if memory matters.
-
-    Lazy-subscribe: `push` is a no-op when no subscriber has registered.
-    Transformers still execute `process()` (so scalar state like
-    `ValuesTransformer._latest` stays current); only the log append is
-    skipped.
-    """
-
-    def __init__(self, maxlen: int | None = None) -> None:
-        """Initialize an empty, unbound log.
-
-        Args:
-            maxlen: Accepted for forward compatibility; currently unused.
-                The caller-driven pump bounds memory naturally for
-                single-consumer use.
-
-        Raises:
-            ValueError: If `maxlen` is not a positive integer or `None`.
-        """
-        if maxlen is not None and maxlen <= 0:
-            raise ValueError("EventLog maxlen must be a positive int or None")
-        self._items: deque[T] = deque()
-        self._maxlen: int | None = maxlen
-        self._closed = False
-        self._error: BaseException | None = None
-
-        # Binding state — None means unbound.
-        self._is_async: bool | None = None
-
-        # Flipped on first __iter__ / __aiter__. Pre-subscription
-        # pushes are silent no-ops.
-        self._subscribed = False
-
-        # Pump wiring set by the run stream after bind.
-        self._request_more: Callable[[], bool] | None = None
-        self._arequest_more: Callable[[], Awaitable[bool]] | None = None
-
-    # ------------------------------------------------------------------
-    # Binding
-    # ------------------------------------------------------------------
-
-    def _bind(self, *, is_async: bool) -> None:
-        """Bind this log to sync or async mode.
-
-        Called by the StreamMux after transformer registration. Must be
-        called exactly once before any iteration.
-
-        Args:
-            is_async: True to enable async iteration, False for sync.
-
-        Raises:
-            RuntimeError: If the log has already been bound.
-        """
-        if self._is_async is not None:
-            raise RuntimeError("EventLog is already bound")
-        self._is_async = is_async
-
-    # ------------------------------------------------------------------
-    # Producer API
-    # ------------------------------------------------------------------
-
-    def push(self, item: T) -> None:
-        """Append an item. No-op when no subscriber is registered.
-
-        Non-blocking in both sync and async — matches v1's
-        `put_nowait` producer shape. Memory is bounded by caller pace
-        via the caller-driven pump.
-
-        Raises:
-            RuntimeError: If the log is closed (and subscribed).
-        """
-        if not self._subscribed:
-            return
-        if self._closed:
-            raise RuntimeError("Cannot push to a closed EventLog")
-        self._items.append(item)
-
-    def close(self) -> None:
-        """Mark the log as complete."""
-        self._closed = True
-
-    def fail(self, err: BaseException) -> None:
-        """Mark the log as errored.
-
-        Args:
-            err: The exception to surface to the subscriber.
-        """
-        self._error = err
-        self._closed = True
-
-    # ------------------------------------------------------------------
-    # Sync iteration (caller-driven pump)
-    # ------------------------------------------------------------------
-
-    def __iter__(self) -> Iterator[T]:
-        """Subscribe and return a sync cursor. Can be called only once.
-
-        Raises:
-            TypeError: If the log is unbound or bound to async mode.
-            RuntimeError: If the log already has a subscriber.
-        """
-        if self._is_async is None:
-            raise TypeError(
-                "EventLog has not been bound yet. "
-                "Register the transformer with a StreamMux first."
-            )
-        if self._is_async:
-            raise TypeError(
-                "This EventLog is bound to async mode — use 'async for' instead."
-            )
-        if self._subscribed:
-            raise RuntimeError(
-                "EventLog already has a subscriber; use .tee(n) for fan-out."
-            )
-        self._subscribed = True
-        return self._sync_cursor()
-
-    def _sync_cursor(self) -> Iterator[T]:
-        while True:
-            if self._items:
-                yield self._items.popleft()
-            elif self._closed:
-                if self._error is not None:
-                    raise self._error
-                return
-            elif self._request_more is not None:
-                if not self._request_more():
-                    if not self._items and not self._closed:
-                        return
-            else:
-                return
-
-    # ------------------------------------------------------------------
-    # Async iteration (caller-driven pump)
-    # ------------------------------------------------------------------
-
-    def __aiter__(self) -> AsyncIterator[T]:
-        """Subscribe and return an async cursor. Can be called only once.
-
-        Raises:
-            TypeError: If the log is unbound or bound to sync mode.
-            RuntimeError: If the log already has a subscriber.
-        """
-        if self._is_async is None:
-            raise TypeError(
-                "EventLog has not been bound yet. "
-                "Register the transformer with a StreamMux first."
-            )
-        if not self._is_async:
-            raise TypeError("This EventLog is bound to sync mode — use 'for' instead.")
-        if self._subscribed:
-            raise RuntimeError(
-                "EventLog already has a subscriber; use .atee(n) for fan-out."
-            )
-        self._subscribed = True
-        return self._async_cursor()
-
-    async def _async_cursor(self) -> AsyncIterator[T]:
-        while True:
-            if self._items:
-                yield self._items.popleft()
-            elif self._closed:
-                if self._error is not None:
-                    raise self._error
-                return
-            elif self._arequest_more is not None:
-                if not await self._arequest_more():
-                    if not self._items and not self._closed:
-                        return
-            else:
-                return
-
-    # ------------------------------------------------------------------
-    # Fan-out via tee
-    # ------------------------------------------------------------------
-
-    def tee(self, n: int = 2) -> tuple[Iterator[T], ...]:
-        """Subscribe and return `n` independent sync iterators.
-
-        Each branch has its own buffer; items pulled from the
-        underlying cursor are copied into every branch. Branches are
-        naturally bounded by caller pace since the sync pump is
-        caller-driven.
-
-        Args:
-            n: Number of branches to create. Must be >= 1.
-
-        Returns:
-            A tuple of `n` iterators over the same underlying stream.
-
-        Raises:
-            TypeError: If the log is unbound or bound to async mode.
-            RuntimeError: If the log already has a subscriber.
-            ValueError: If `n` < 1.
-        """
-        if n < 1:
-            raise ValueError("tee() requires n >= 1")
-        source = self.__iter__()
-        buffers: list[deque[T]] = [deque() for _ in range(n)]
-        exhausted = [False]
-
-        def branch(i: int) -> Iterator[T]:
-            buf = buffers[i]
-            while True:
-                if buf:
-                    yield buf.popleft()
-                elif exhausted[0]:
-                    return
-                else:
-                    try:
-                        item = next(source)
-                    except StopIteration:
-                        exhausted[0] = True
-                        return
-                    for b in buffers:
-                        b.append(item)
-
-        return tuple(branch(i) for i in range(n))
-
-    def atee(self, n: int = 2) -> tuple[AsyncIterator[T], ...]:
-        """Subscribe and return `n` independent async iterators.
-
-        Caller-driven fan-out: each branch's `__anext__` either pops
-        from its own buffer or, under a shared `asyncio.Lock`, pulls
-        one item from the underlying cursor and distributes it to
-        every branch's buffer.
-
-        Args:
-            n: Number of branches to create. Must be >= 1.
-
-        Returns:
-            A tuple of `n` async iterators over the same underlying
-            stream.
-
-        Raises:
-            TypeError: If the log is unbound or bound to sync mode.
-            RuntimeError: If the log already has a subscriber.
-            ValueError: If `n` < 1.
-        """
-        if n < 1:
-            raise ValueError("atee() requires n >= 1")
-        source = self.__aiter__()
-        buffers: list[deque[T]] = [deque() for _ in range(n)]
-        exhausted = [False]
-        error: list[BaseException | None] = [None]
-        lock = asyncio.Lock()
-
-        async def branch(i: int) -> AsyncIterator[T]:
-            buf = buffers[i]
-            while True:
-                if buf:
-                    yield buf.popleft()
-                    continue
-                if exhausted[0]:
-                    if error[0] is not None:
-                        raise error[0]
-                    return
-                async with lock:
-                    if buf or exhausted[0]:
-                        continue
-                    try:
-                        item = await source.__anext__()
-                    except StopAsyncIteration:
-                        exhausted[0] = True
-                        continue
-                    except Exception as e:
-                        error[0] = e
-                        exhausted[0] = True
-                        continue
-                    for b in buffers:
-                        b.append(item)
-
-        return tuple(branch(i) for i in range(n))

libs/langgraph/langgraph/stream/_mux.py

@@ -1,497 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import time
-from collections.abc import Awaitable, Callable
-from typing import Any
-
-from langgraph.stream._event_log import EventLog
-from langgraph.stream._types import (
-    ProtocolEvent,
-    StreamTransformer,
-    transformer_requires_async,
-)
-from langgraph.stream.stream_channel import StreamChannel
-
-TransformerFactory = Callable[["tuple[str, ...]"], StreamTransformer]
-"""Factory that builds a scoped transformer for a mux.
-
-Called once per `StreamMux` (root or mini-mux) with the mux's scope
-— typically a subgraph's namespace or `()` for the root. Standard
-transformer classes (`ValuesTransformer`, `MessagesTransformer`,
-`SubgraphTransformer`) accept a single positional scope argument, so
-the class itself is a valid factory. User transformers can close over
-their config: `lambda scope: MyTransformer(scope, foo=...)`.
-"""
-
-
-class StreamMux:
-    """Central event dispatcher for the streaming infrastructure.
-
-    Owns the main event log and routes events through a transformer
-    pipeline. StreamChannels discovered in transformer projections are
-    auto-wired so that every `push()` also injects a `ProtocolEvent`
-    into the main log.
-
-    Pass `is_async=True` when the mux will be consumed via async
-    iteration (`handler.astream()`). All EventLog and StreamChannel
-    instances discovered during registration are automatically bound
-    to the matching mode.
-
-    Attributes:
-        extensions: Merged projection dict across all registered
-            transformers. Treat as read-only — mutations won't be
-            reflected back in individual transformers' state.
-        native_keys: Projection keys contributed by transformers with
-            `_native = True`.
-    """
-
-    def __init__(
-        self,
-        transformers: list[StreamTransformer] | None = None,
-        *,
-        is_async: bool = False,
-        factories: list[TransformerFactory] | None = None,
-        scope: tuple[str, ...] = (),
-    ) -> None:
-        """Initialize the mux and register transformers in order.
-
-        Callers pass either `transformers` (pre-built instances) or
-        `factories` (callables producing fresh instances per mux). A
-        factory list is preferred — mini-muxes built by `make_child()`
-        inherit the factory list, so transformers propagate naturally
-        into every subgraph's scope. `transformers` is kept for
-        back-compat tests that exercise the mux directly.
-
-        Each transformer's `init()` is called once during registration,
-        projections are merged into `extensions`, `_native` keys are
-        recorded in `native_keys`, and any EventLog / StreamChannel
-        instances are bound and wired.
-
-        Args:
-            transformers: Already-built transformer instances. Mutually
-                exclusive with `factories`.
-            is_async: True for async dispatch (`apush` / `aclose` /
-                `afail`), False for the sync path.
-            factories: Zero-or-one-argument callables producing
-                transformers. Called with this mux's `scope`.
-            scope: The namespace the mux operates within. The root mux
-                is `()`; mini-muxes for subgraphs use the subgraph's
-                namespace tuple.
-
-        Raises:
-            RuntimeError: If any transformer requires an async run but
-                the mux is in sync mode.
-            TypeError: If a transformer's `init()` doesn't return a dict.
-            ValueError: If transformers' projection keys collide, or if
-                both `transformers` and `factories` are supplied.
-        """
-        if transformers is not None and factories is not None:
-            raise ValueError("Pass either `transformers` or `factories`, not both.")
-
-        self._is_async = is_async
-        self._factories: list[TransformerFactory] = list(factories or ())
-        self.scope: tuple[str, ...] = scope
-        self._pump_fn: Callable[[], bool] | None = None
-        self._apump_fn: Callable[[], Awaitable[bool]] | None = None
-
-        self._events: EventLog[ProtocolEvent] = EventLog()
-        self._events._bind(is_async=is_async)
-        self._transformers: list[StreamTransformer] = []
-        self._channels: list[StreamChannel[Any]] = []
-        self._logs: list[EventLog[Any]] = []
-        self._seq = 0
-
-        self.extensions: dict[str, Any] = {}
-        self.native_keys: set[str] = set()
-        self._projection_owners: dict[str, str] = {}
-        self._transformer_by_key: dict[str, StreamTransformer] = {}
-
-        if factories is not None:
-            for factory in factories:
-                self._register(factory(scope))
-        else:
-            for transformer in transformers or ():
-                self._register(transformer)
-
-    def make_child(self, scope: tuple[str, ...]) -> StreamMux:
-        """Build a mini-mux with the same factories scoped to `scope`.
-
-        Used by `SubgraphTransformer` to attach a fresh transformer
-        pipeline to each discovered subgraph handle. The child mux
-        inherits the current pump binding (so cursors on its projection
-        logs drive the root pump) and carries the same factory list
-        forward to any grandchild subgraphs.
-
-        Raises:
-            RuntimeError: If the mux was not built from a factory list
-                (i.e., constructed with `transformers=`). Mini-muxes
-                require factories so each scope gets its own fresh
-                transformer instances.
-        """
-        if not self._factories:
-            raise RuntimeError(
-                "StreamMux.make_child requires the mux to be constructed "
-                "with factories; pre-built transformers can't be cloned "
-                "to a new scope."
-            )
-        child = StreamMux(
-            factories=self._factories,
-            is_async=self._is_async,
-            scope=scope,
-        )
-        if self._pump_fn is not None:
-            child.bind_pump(self._pump_fn)
-        if self._apump_fn is not None:
-            child.bind_apump(self._apump_fn)
-        return child
-
-    def bind_pump(self, fn: Callable[[], bool]) -> None:
-        """Wire the sync pull callback onto every EventLog in the mux.
-
-        Also propagates to transformers that expose `_bind_pump` so
-        nested handles (e.g., `ChatModelStream` instances produced by
-        `MessagesTransformer`) can drive the graph pump from their
-        projection cursors.
-        """
-        self._pump_fn = fn
-        self._events._request_more = fn
-        for value in self.extensions.values():
-            if isinstance(value, EventLog):
-                value._request_more = fn
-            elif isinstance(value, StreamChannel):
-                value._log._request_more = fn
-        for transformer in self._transformers:
-            bind = getattr(transformer, "_bind_pump", None)
-            if bind is not None:
-                bind(fn)
-
-    def bind_apump(self, fn: Callable[[], Awaitable[bool]]) -> None:
-        """Async counterpart to `bind_pump`."""
-        self._apump_fn = fn
-        self._events._arequest_more = fn
-        for value in self.extensions.values():
-            if isinstance(value, EventLog):
-                value._arequest_more = fn
-            elif isinstance(value, StreamChannel):
-                value._log._arequest_more = fn
-        for transformer in self._transformers:
-            abind = getattr(transformer, "_bind_apump", None)
-            if abind is not None:
-                abind(fn)
-
-    def _register(self, transformer: StreamTransformer) -> None:
-        """Register a single transformer.
-
-        Calls `transformer.init()`, stores the transformer for event
-        processing, binds any EventLog or StreamChannel instances in
-        the projection, and merges the projection into `extensions`.
-        """
-        if transformer_requires_async(transformer) and not self._is_async:
-            raise RuntimeError(
-                f"{type(transformer).__name__} requires an async run — "
-                "it overrides aprocess/afinalize/afail or sets "
-                "requires_async=True. Use astream(), not stream()."
-            )
-        projection = transformer.init()
-        if not isinstance(projection, dict):
-            raise TypeError(
-                f"StreamTransformer.init() must return a dict, "
-                f"got {type(projection).__name__}"
-            )
-        conflicts = set(projection) & set(self.extensions)
-        if conflicts:
-            attributions = ", ".join(
-                f"{key!r} (owned by {self._projection_owners[key]})"
-                for key in sorted(conflicts)
-            )
-            raise ValueError(
-                f"Transformer {type(transformer).__name__} returned "
-                f"projection keys that conflict with already-registered "
-                f"keys: {attributions}"
-            )
-        self._transformers.append(transformer)
-        self._bind_and_wire(projection)
-        self.extensions.update(projection)
-        owner_name = type(transformer).__name__
-        for key in projection:
-            self._projection_owners[key] = owner_name
-            self._transformer_by_key[key] = transformer
-        if getattr(transformer, "_native", False):
-            self.native_keys.update(projection.keys())
-        on_register = getattr(transformer, "_on_register", None)
-        if on_register is not None:
-            on_register(self)
-
-    def transformer_by_key(self, key: str) -> StreamTransformer | None:
-        """Return the transformer that owns the projection at `key`, if any."""
-        return self._transformer_by_key.get(key)
-
-    def emit(self, event: ProtocolEvent) -> None:
-        """Append a protocol event directly to the main log.
-
-        Built-in transformers use this for protocol repair events that
-        must appear before the source event they are processing. Direct
-        emission intentionally bypasses the transformer pipeline, but
-        still lets this mux remain the only local sequencing authority.
-        """
-        self._seq += 1
-        event["seq"] = self._seq
-        self._events.push(event)
-
-    def push(self, event: ProtocolEvent) -> None:
-        """Route an event through all transformers, then append to the main log.
-
-        Each transformer's `process()` is called in registration order
-        — except when the transformer has `scope_exact = True` (the
-        default) and the event's namespace differs from the mux's
-        `scope`, in which case the transformer is skipped. Transformers
-        that need to see cross-scope events opt out by setting
-        `scope_exact = False` (e.g. `SubgraphTransformer`).
-
-        If any transformer returns False, the event is suppressed from
-        the main log, but transformers that already saw it keep their
-        side effects.
-
-        Seq is assigned right before an event enters the main log, not
-        before the transformer pipeline runs. This ensures that events
-        auto-forwarded from StreamChannels during `process()` get
-        earlier seq numbers than the original event, preserving
-        monotonic ordering in the log.
-
-        Args:
-            event: The protocol event to dispatch.
-        """
-        ns = tuple(event["params"]["namespace"])
-        in_scope = ns == self.scope
-        keep = True
-        for transformer in self._transformers:
-            if transformer.scope_exact and not in_scope:
-                continue
-            if not transformer.process(event):
-                keep = False
-        if keep:
-            self._seq += 1
-            event["seq"] = self._seq
-            self._events.push(event)
-
-    def close(self) -> None:
-        """Finalize all transformers, close all projections and the main log.
-
-        EventLogs and StreamChannels discovered in transformer
-        projections are auto-closed after `finalize()` runs —
-        transformers don't need to close them manually. If any
-        transformer's `finalize()` raises, the remaining transformers,
-        projections, and the main log are still closed; the first error
-        is re-raised after cleanup completes.
-
-        Raises:
-            BaseException: The first error raised by a transformer's
-                `finalize()`, re-raised after cleanup finishes.
-        """
-        first_error: BaseException | None = None
-        for transformer in self._transformers:
-            try:
-                transformer.finalize()
-            except BaseException as e:
-                if first_error is None:
-                    first_error = e
-        for log in self._logs:
-            if not log._closed:
-                log.close()
-        for ch in self._channels:
-            if not ch._log._closed:
-                ch._close()
-        self._events.close()
-        if first_error is not None:
-            raise first_error
-
-    def fail(self, err: BaseException) -> None:
-        """Fail all transformers, projections, and the main log.
-
-        EventLogs and StreamChannels discovered in transformer
-        projections are auto-failed — transformers don't need to fail
-        them manually. If any transformer's `fail()` raises, the
-        remaining transformers, projections, and the main log are still
-        failed.
-
-        Args:
-            err: The exception that ended the run.
-        """
-        for transformer in self._transformers:
-            try:
-                transformer.fail(err)
-            except BaseException:
-                pass
-        for log in self._logs:
-            if not log._closed:
-                log.fail(err)
-        for ch in self._channels:
-            if not ch._log._closed:
-                ch._fail(err)
-        self._events.fail(err)
-
-    # ------------------------------------------------------------------
-    # Async dispatch
-    # ------------------------------------------------------------------
-
-    async def apush(self, event: ProtocolEvent) -> None:
-        """Dispatch an event on the async lane.
-
-        Awaits each transformer's `aprocess` in registration order
-        before appending to the main log — except when the transformer
-        has `scope_exact = True` and the event's namespace differs from
-        `self.scope`, in which case it is skipped. A slow `aprocess`
-        serializes the pipeline by design — that's the guarantee that
-        lets a later transformer (or a synchronous consumer) see the
-        result of the async work. For decoupled work, use `schedule()`
-        from inside `process` / `aprocess` instead.
-
-        The main log append is a non-blocking `push` — matching v1's
-        `put_nowait` shape. Memory is bounded by caller pace via the
-        caller-driven pump; see `EventLog` for the full tradeoff story.
-
-        Args:
-            event: The protocol event to dispatch.
-        """
-        ns = tuple(event["params"]["namespace"])
-        in_scope = ns == self.scope
-        keep = True
-        for transformer in self._transformers:
-            if transformer.scope_exact and not in_scope:
-                continue
-            if not await transformer.aprocess(event):
-                keep = False
-        if keep:
-            self._seq += 1
-            event["seq"] = self._seq
-            self._events.push(event)
-
-    async def aclose(self) -> None:
-        """Finalize on the async lane.
-
-        Awaits every task started via `StreamTransformer.schedule()`
-        across all transformers, then calls `afinalize()` on each,
-        then auto-closes logs, channels, and the main event log.
-
-        If any scheduled task raised under `on_error="raise"`, or any
-        transformer's `afinalize` raises, the exception propagates.
-        The caller (the pump) handles it by routing into `afail`.
-
-        Raises:
-            BaseException: The first scheduled-task or `afinalize`
-                error, re-raised after cleanup.
-        """
-        pending = self._collect_scheduled_tasks()
-        if pending:
-            results = await asyncio.gather(*pending, return_exceptions=True)
-            first_err = next(
-                (
-                    r
-                    for r in results
-                    if isinstance(r, BaseException)
-                    and not isinstance(r, asyncio.CancelledError)
-                ),
-                None,
-            )
-            if first_err is not None:
-                raise first_err
-
-        first_error: BaseException | None = None
-        for transformer in self._transformers:
-            try:
-                await transformer.afinalize()
-            except BaseException as e:
-                if first_error is None:
-                    first_error = e
-        for log in self._logs:
-            if not log._closed:
-                log.close()
-        for ch in self._channels:
-            if not ch._log._closed:
-                ch._close()
-        self._events.close()
-        if first_error is not None:
-            raise first_error
-
-    async def afail(self, err: BaseException) -> None:
-        """Fail on the async lane.
-
-        Cancels every scheduled task across all transformers, awaits
-        them to completion, then runs each transformer's `afail` hook
-        and auto-fails logs, channels, and the main event log.
-
-        Args:
-            err: The exception that ended the run.
-        """
-        pending = self._collect_scheduled_tasks()
-        for task in pending:
-            task.cancel()
-        if pending:
-            await asyncio.gather(*pending, return_exceptions=True)
-
-        for transformer in self._transformers:
-            try:
-                await transformer.afail(err)
-            except BaseException:
-                pass
-        for log in self._logs:
-            if not log._closed:
-                log.fail(err)
-        for ch in self._channels:
-            if not ch._log._closed:
-                ch._fail(err)
-        if not self._events._closed:
-            self._events.fail(err)
-
-    def _collect_scheduled_tasks(self) -> list[asyncio.Task[Any]]:
-        """Return a snapshot of in-flight tasks scheduled via transformers."""
-        return [
-            task
-            for transformer in self._transformers
-            for task in getattr(transformer, "_stream_scheduled_tasks", ())
-            if not task.done()
-        ]
-
-    # ------------------------------------------------------------------
-    # Binding and StreamChannel auto-wiring
-    # ------------------------------------------------------------------
-
-    def _bind_and_wire(self, projection: dict[str, Any]) -> None:
-        """Bind and wire EventLog / StreamChannel instances in a projection."""
-        for value in projection.values():
-            if isinstance(value, StreamChannel):
-                value._bind(is_async=self._is_async)
-                self._channels.append(value)
-                channel_name = value.name
-
-                def _make_forward(name: str) -> Callable[[Any], None]:
-                    def _forward(item: Any) -> None:
-                        self._forward(name, item)
-
-                    return _forward
-
-                value._wire(_make_forward(channel_name))
-            elif isinstance(value, EventLog):
-                value._bind(is_async=self._is_async)
-                self._logs.append(value)
-
-    def _forward(self, channel_name: str, item: Any) -> None:
-        """Inject a ProtocolEvent for a StreamChannel push.
-
-        Forwarded events bypass the transformer pipeline to avoid
-        infinite recursion (a transformer that pushes to a channel
-        during `process()` would re-trigger itself). These events are
-        visible in the main event log but are not passed through
-        transformers' `process()` methods.
-        """
-        event: ProtocolEvent = {
-            "type": "event",
-            "method": f"custom:{channel_name}",
-            "params": {
-                "namespace": [],
-                "timestamp": int(time.time() * 1000),
-                "data": item,
-            },
-        }
-        self.emit(event)

libs/langgraph/langgraph/stream/_types.py

@@ -1,312 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-import logging
-from abc import ABC, abstractmethod
-from collections.abc import Coroutine
-from typing import Any, ClassVar, Literal
-
-from typing_extensions import NotRequired, TypedDict
-
-_logger = logging.getLogger(__name__)
-
-
-class _ProtocolEventParams(TypedDict):
-    """Parameters for a protocol event.
-
-    `timestamp` is wall-clock milliseconds since the epoch and can go
-    backwards across NTP adjustments — use `ProtocolEvent.seq` for
-    ordering.
-    """
-
-    namespace: list[str]
-    timestamp: int
-    data: Any
-    node: NotRequired[str]
-    run_id: NotRequired[str]
-    interrupts: NotRequired[tuple[Any, ...]]
-
-
-class ProtocolEvent(TypedDict):
-    """A protocol event emitted by the streaming infrastructure.
-
-    Wraps a raw stream part (values, messages, custom, etc.) in a uniform
-    envelope with a monotonic sequence number assigned by the StreamMux.
-    Consumers that need a total order across events should use `seq`, not
-    `params.timestamp` (which is wall-clock and not monotonic).
-    """
-
-    type: Literal["event"]
-    event_id: NotRequired[str]
-    seq: NotRequired[int]
-    method: str  # StreamMode value: "values", "messages", "custom", etc.
-    params: _ProtocolEventParams
-
-
-class StreamTransformer(ABC):
-    """Extension point for custom stream projections.
-
-    Transformers observe protocol events flowing through the StreamMux and
-    build typed derived projections (EventLogs, StreamChannels, promises,
-    etc.).
-
-    Set `_native = True` on a transformer to have its projection keys
-    exposed as direct attributes on the run stream (in addition to
-    appearing in `run.extensions`).
-
-    Subclasses must implement `init` and override at least one of
-    `process` / `aprocess`. The `finalize` / `afinalize` and `fail` /
-    `afail` hooks are optional — the default implementations are no-ops.
-    EventLog and StreamChannel instances in the projection dict are
-    auto-closed / auto-failed by the mux, so most transformers don't
-    need `finalize` or `fail` at all.
-
-    Transformers that need async work pick the async lane by:
-
-    1. Overriding `aprocess` (and optionally `afinalize` / `afail`), or
-    2. Calling `self.schedule(coro)` from inside a sync `process`, or
-    3. Setting `requires_async = True` explicitly.
-
-    The mux detects these cases at registration and raises if they're
-    used under sync `stream()` — they only work under `astream()`.
-
-    Use `aprocess` when the pump must wait for async work before the
-    next transformer sees the event (e.g. PII redaction that mutates
-    `event` in place). Use `schedule()` for decoupled async work whose
-    result lands on an independent projection (e.g. async moderation
-    scoring, cost lookup, external tracing).
-
-    Attributes:
-        scope: Namespace the transformer operates within — `()` for the
-            root mux, a subgraph's namespace tuple inside a mini-mux.
-            Set at construction from the mux's scope (each factory is
-            called as `factory(scope)`). Transformers that only care
-            about events at their own namespace compare against
-            `self.scope`; subgraph-aware transformers can treat it as
-            a parent path.
-        scope_exact: If True (the default), the mux only calls
-            `process` / `aprocess` for events whose namespace equals
-            `self.scope` — user transformers get scope-scoped events
-            for free with no boilerplate. Set False for transformers
-            that need to see events across scopes (e.g.
-            `SubgraphTransformer` forwards deeper events into child
-            mini-muxes).
-        requires_async: Explicit opt-in for transformers that need a
-            running event loop but don't override any async method (for
-            example, transformers that call `schedule()` from a sync
-            `process`). The mux also auto-detects the async lane when
-            `aprocess`, `afinalize`, or `afail` is overridden.
-        required_stream_modes: Stream modes the graph must emit for
-            this transformer to have anything to process. Computed as
-            the union across all registered transformers to determine
-            which modes a `GraphStreamer` run requests from the
-            graph. Empty tuple means the transformer consumes only
-            synthetic events (or is purely passive).
-    """
-
-    requires_async: ClassVar[bool] = False
-    scope_exact: ClassVar[bool] = True
-    required_stream_modes: ClassVar[tuple[str, ...]] = ()
-
-    def __init__(self, scope: tuple[str, ...] = ()) -> None:
-        """Initialize the transformer with its mux's scope.
-
-        Args:
-            scope: The namespace tuple the owning mux is scoped to.
-                `()` for the root, the subgraph's namespace inside a
-                mini-mux. Factories receive this at construction time
-                (`factory(scope)` in `StreamMux`).
-        """
-        self.scope: tuple[str, ...] = scope
-
-    @abstractmethod
-    def init(self) -> dict[str, Any]:
-        """Return the projection dict.
-
-        Keys become entries in `run.extensions`. If the transformer has
-        `_native = True`, keys are also set as direct attributes on the
-        run stream.
-
-        StreamChannel instances in the return value are automatically
-        wired by the StreamMux for protocol event auto-forwarding.
-        """
-        ...
-
-    def process(self, event: ProtocolEvent) -> bool:
-        """Handle an event on the sync lane.
-
-        Called for every event before it is appended to the main event
-        log. Subclasses must override either `process` or `aprocess`.
-        The default raises so a missing override fails loudly rather
-        than silently passing every event through.
-
-        Args:
-            event: The protocol event to observe.
-
-        Returns:
-            True to keep the event in the main log, False to suppress it.
-        """
-        raise NotImplementedError(
-            f"{type(self).__name__} must override process() or aprocess()"
-        )
-
-    async def aprocess(self, event: ProtocolEvent) -> bool:
-        """Handle an event on the async lane.
-
-        The mux awaits this before dispatching to the next transformer,
-        so a slow `aprocess` serializes the pipeline. Use it only when
-        a later transformer — or a consumer reading the event
-        synchronously — must see the result of the async work (e.g.
-        PII redaction that mutates `event` in place).
-
-        The default delegates to `process`, so purely-sync transformers
-        run unchanged under `astream()`.
-
-        Args:
-            event: The protocol event to observe.
-
-        Returns:
-            True to keep the event in the main log, False to suppress it.
-        """
-        return self.process(event)
-
-    def finalize(self) -> None:
-        """Called when the run ends normally (sync lane).
-
-        Override to close EventLogs, resolve promises, or perform other
-        teardown. StreamChannel instances are auto-closed by the mux.
-        """
-
-    async def afinalize(self) -> None:
-        """Called when the run ends normally (async lane).
-
-        By the time this runs, the mux has already awaited every task
-        started via `schedule()`, so EventLogs can be closed here
-        without a last-task-wins race.
-
-        The default delegates to `finalize`.
-        """
-        self.finalize()
-
-    def fail(self, err: BaseException) -> None:
-        """Called when the run ends with an error (sync lane).
-
-        Override to fail EventLogs, reject promises, or perform other
-        teardown. StreamChannel instances are auto-failed by the mux.
-
-        Args:
-            err: The exception that ended the run.
-        """
-
-    async def afail(self, err: BaseException) -> None:
-        """Called when the run ends with an error (async lane).
-
-        The mux cancels and awaits every task started via `schedule()`
-        before calling this, so cleanup doesn't race with in-flight work.
-
-        The default delegates to `fail`.
-
-        Args:
-            err: The exception that ended the run.
-        """
-        self.fail(err)
-
-    # ------------------------------------------------------------------
-    # Scheduled async work
-    # ------------------------------------------------------------------
-
-    def schedule(
-        self,
-        coro: Coroutine[Any, Any, Any],
-        *,
-        on_error: Literal["log", "raise"] = "log",
-    ) -> asyncio.Task[Any]:
-        """Schedule a coroutine tied to this transformer's lifecycle.
-
-        The mux holds the task reference, awaits all scheduled tasks
-        during `aclose()` before calling `afinalize()`, and cancels
-        them on `afail()`. Authors don't need to track tasks or
-        implement the last-task-closes-the-log dance.
-
-        Requires a running event loop — call only under `astream()`.
-        Set `requires_async = True` on the class so registration under
-        sync `stream()` fails fast with a clear message.
-
-        Args:
-            coro: The coroutine to run. Its lifecycle is owned by the
-                mux from this point on.
-            on_error: `"log"` (default) catches and logs any exception
-                the coroutine raises, so a single failure doesn't tear
-                down the run. `"raise"` lets the exception propagate
-                when the mux joins pendings, converting the close path
-                into the fail path.
-
-        Returns:
-            The asyncio Task. Authors rarely need to await it directly
-            — consumers read results from whatever projection the
-            coroutine pushes into.
-
-        Raises:
-            RuntimeError: If called without a running event loop (i.e.
-                under sync `stream()` rather than `astream()`).
-        """
-        try:
-            asyncio.get_running_loop()
-        except RuntimeError:
-            raise RuntimeError(
-                f"{type(self).__name__}.schedule() requires a running "
-                "event loop; this transformer must run under astream(), "
-                "not stream(). Set requires_async=True on the class so "
-                "this fails at registration rather than at first event."
-            ) from None
-
-        wrapped = self._wrap_scheduled(coro) if on_error == "log" else coro
-        task = asyncio.create_task(wrapped)
-        tasks = self._scheduled_task_set()
-        tasks.add(task)
-        task.add_done_callback(tasks.discard)
-        return task
-
-    @staticmethod
-    async def _wrap_scheduled(coro: Coroutine[Any, Any, Any]) -> Any:
-        try:
-            return await coro
-        except asyncio.CancelledError:
-            raise
-        except BaseException:
-            _logger.exception("Scheduled StreamTransformer task failed")
-
-    def _scheduled_task_set(self) -> set[asyncio.Task[Any]]:
-        """Return the lazily-allocated task set.
-
-        Avoids requiring subclasses to call `super().__init__()`.
-        """
-        tasks: set[asyncio.Task[Any]] | None = getattr(
-            self, "_stream_scheduled_tasks", None
-        )
-        if tasks is None:
-            tasks = set()
-            self._stream_scheduled_tasks = tasks
-        return tasks
-
-
-def transformer_requires_async(transformer: StreamTransformer) -> bool:
-    """Return True if the transformer needs a running event loop.
-
-    A transformer requires async if it explicitly opts in
-    (`requires_async = True`) or overrides any of the async-lane methods
-    (`aprocess`, `afinalize`, `afail`).
-
-    Args:
-        transformer: The transformer to inspect.
-
-    Returns:
-        True if the transformer cannot run under sync `stream()`.
-    """
-    if transformer.requires_async:
-        return True
-    cls = type(transformer)
-    for name in ("aprocess", "afinalize", "afail"):
-        if getattr(cls, name) is not getattr(StreamTransformer, name):
-            return True
-    return False

libs/langgraph/langgraph/stream/run_stream.py

@@ -1,412 +0,0 @@
-from __future__ import annotations
-
-import asyncio
-from collections.abc import AsyncIterator, Awaitable, Callable, Iterator, Mapping
-from types import MappingProxyType, TracebackType
-from typing import TYPE_CHECKING, Any
-
-from langgraph.stream._convert import convert_to_protocol_event
-from langgraph.stream._mux import StreamMux
-from langgraph.stream._types import ProtocolEvent
-
-if TYPE_CHECKING:
-    from langgraph.stream.transformers import ValuesTransformer
-
-
-def _drive_until_done(pump: Callable[[], bool]) -> None:
-    """Call the sync pump until it returns False."""
-    while pump():
-        pass
-
-
-async def _adrive_until_done(pump: Callable[[], Awaitable[bool]]) -> None:
-    """Call the async pump until it returns False."""
-    while await pump():
-        pass
-
-
-class BaseRunStream:
-    """Shared shape for any object that wraps a `StreamMux`.
-
-    Root (`GraphRunStream` / `AsyncGraphRunStream`) and scoped
-    (`SubgraphRunStream`) streams both compose a `StreamMux`. The mux
-    owns the projections — `values`, `messages`, `subgraphs`, and any
-    user-registered keys — all exposed via `extensions`. Native
-    projections (`_native = True`) are also bound as direct attributes
-    (`run.values`, `run.messages`, …) for ergonomics.
-
-    Raw iteration (`for event in run` / `async for event in run`) and
-    the `interleave(...)` helper both live here so every subclass
-    behaves consistently. Subclasses only add pump ownership, scope
-    metadata, or sync/async flavor.
-    """
-
-    def __init__(self, mux: StreamMux) -> None:
-        self._mux = mux
-        self.extensions: Mapping[str, Any] = MappingProxyType(mux.extensions)
-        for key in mux.native_keys:
-            setattr(self, key, mux.extensions[key])
-
-    @property
-    def _values_transformer(self) -> ValuesTransformer:
-        """Look up the `ValuesTransformer` backing `output` / `interrupted`.
-
-        Resolved lazily off the mux so subclasses don't have to thread
-        it through their constructors. Raises if no `ValuesTransformer`
-        is registered — `output` / `interrupted` / `interrupts` have
-        nothing to return in that case, so failing loudly is better
-        than returning `None` silently.
-        """
-        from langgraph.stream.transformers import ValuesTransformer
-
-        vt = self._mux.transformer_by_key("values")
-        if not isinstance(vt, ValuesTransformer):
-            raise RuntimeError(
-                "No ValuesTransformer is registered on this mux — "
-                "`output`, `interrupted`, and `interrupts` require one. "
-                "Add it to your GraphStreamer subclass's "
-                "`builtin_factories` or pass it via `transformers=`."
-            )
-        return vt
-
-    def __iter__(self) -> Iterator[ProtocolEvent]:
-        """Sync iteration of protocol events on this mux's main log.
-
-        Raises at the EventLog level if the mux is async-bound.
-        """
-        return iter(self._mux._events)
-
-    def __aiter__(self) -> AsyncIterator[ProtocolEvent]:
-        """Async iteration of protocol events on this mux's main log.
-
-        Raises at the EventLog level if the mux is sync-bound.
-        """
-        return self._mux._events.__aiter__()
-
-    def interleave(self, *names: str) -> Iterator[tuple[str, Any]]:
-        """Iterate multiple projections round-robin, yielding ``(name, item)``.
-
-        Each turn advances one projection's cursor; when a cursor's
-        buffer is empty, pulling from it drives the pump once, which
-        fans out to every subscribed projection log. Projections whose
-        items aren't consumed on this turn sit in their own buffers
-        only until the next turn reaches them, bounding memory by the
-        skew between projection rates rather than letting any single
-        log grow to the full run length.
-
-        Projections are exhausted independently; a projection that
-        finishes early drops out of the rotation while others
-        continue. The overall iterator ends once all named projections
-        are done.
-
-        Args:
-            *names: Projection keys to interleave. Must match keys in
-                `extensions`.
-
-        Yields:
-            `(name, item)` tuples in round-robin order across the named
-            projections.
-
-        Raises:
-            KeyError: If a name doesn't match a registered projection.
-
-        Example:
-            ```python
-            for name, item in run.interleave("messages", "values"):
-                if name == "messages":
-                    print("msg:", item)
-                else:
-                    print("val:", item)
-            ```
-        """
-        cursors: dict[str, Iterator[Any]] = {
-            name: iter(self.extensions[name]) for name in names
-        }
-        done: set[str] = set()
-        while len(done) < len(cursors):
-            for name, cursor in cursors.items():
-                if name in done:
-                    continue
-                try:
-                    item = next(cursor)
-                except StopIteration:
-                    done.add(name)
-                    continue
-                yield (name, item)
-
-
-class GraphRunStream(BaseRunStream):
-    """Sync run stream with caller-driven pumping.
-
-    The caller's iteration on any projection (`values`, `messages`,
-    raw events, or `output`) drives the graph forward. No background
-    thread is used — the caller's `for` loop is the pump.
-
-    Projections are single-consumer — iterating `run.values` twice
-    raises. Use `projection.tee(n)` if you genuinely need fan-out.
-    """
-
-    def __init__(
-        self,
-        graph_iter: Iterator[Any],
-        mux: StreamMux,
-    ) -> None:
-        """Initialize the run stream.
-
-        Args:
-            graph_iter: Pull-based iterator over the graph's stream.
-            mux: The StreamMux owning projections and the main log.
-                Must have a `ValuesTransformer` registered under the
-                `"values"` key — `output` / `interrupted` / `interrupts`
-                read from it lazily.
-        """
-        super().__init__(mux)
-        self._graph_iter = graph_iter
-        self._exhausted = False
-        mux.bind_pump(self._pump_next)
-
-    def _pump_next(self) -> bool:
-        """Pull one event from the graph and push it through the mux.
-
-        Returns:
-            True if an event was pulled, False if the graph is
-            exhausted or has raised.
-        """
-        if self._exhausted:
-            return False
-        try:
-            part = next(self._graph_iter)
-        except StopIteration:
-            self._mux.close()
-            self._exhausted = True
-            return False
-        except Exception as e:
-            self._mux.fail(e)
-            self._exhausted = True
-            return False
-        self._mux.push(convert_to_protocol_event(part))
-        return True
-
-    def abort(self) -> None:
-        """Stop the run early.
-
-        Closes the mux and marks the stream exhausted. The graph
-        iterator is dropped; any in-flight nodes see the closure on
-        their next yield point. Idempotent.
-        """
-        if self._exhausted:
-            return
-        self._exhausted = True
-        try:
-            self._mux.close()
-        except Exception:
-            pass
-
-    def __enter__(self) -> GraphRunStream:
-        return self
-
-    def __exit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc: BaseException | None,
-        tb: TracebackType | None,
-    ) -> None:
-        self.abort()
-
-    @property
-    def output(self) -> dict[str, Any] | None:
-        """Drive the run to completion and return the final state."""
-        _drive_until_done(self._pump_next)
-        vt = self._values_transformer
-        if vt.error is not None:
-            raise vt.error
-        return vt._latest
-
-    @property
-    def interrupted(self) -> bool:
-        """Drive the run to completion, then return whether it was interrupted.
-
-        Raises:
-            BaseException: If the run ended with an error.
-        """
-        _drive_until_done(self._pump_next)
-        vt = self._values_transformer
-        if vt.error is not None:
-            raise vt.error
-        return vt._interrupted
-
-    @property
-    def interrupts(self) -> list[Any]:
-        """Drive the run to completion, then return interrupt payloads.
-
-        Raises:
-            BaseException: If the run ended with an error.
-        """
-        _drive_until_done(self._pump_next)
-        vt = self._values_transformer
-        if vt.error is not None:
-            raise vt.error
-        return vt._interrupts
-
-
-class AsyncGraphRunStream(BaseRunStream):
-    """Async run stream with caller-driven pumping.
-
-    Async iteration on any projection drives the graph forward — there
-    is no background task. Concurrent consumers share a single-flight
-    pump via an `asyncio.Lock`, so each awaiting cursor contributes
-    one event per acquisition. Backpressure comes from the logs: when
-    a subscribed log's buffer reaches `maxlen`, `apush` awaits the
-    subscriber to drain, which holds back the pump and paces the
-    graph.
-
-    Projections are single-consumer — a second `aiter(run.values)`
-    raises. Use `projection.tee(n)` for fan-out.
-
-    Use as an async context manager to guarantee clean shutdown on
-    early exit:
-
-    ```python
-    async with await handler.astream(input) as run:
-        async for msg in run.messages:
-            ...
-    ```
-    """
-
-    def __init__(
-        self,
-        graph_aiter: AsyncIterator[Any],
-        mux: StreamMux,
-    ) -> None:
-        """Initialize the async run stream.
-
-        Args:
-            graph_aiter: Async iterator over the graph's stream.
-            mux: The StreamMux owning projections and the main log.
-                Must have a `ValuesTransformer` registered under the
-                `"values"` key — `output` / `interrupted` / `interrupts`
-                read from it lazily.
-        """
-        super().__init__(mux)
-        self._graph_aiter = graph_aiter
-        self._exhausted = False
-        self._pump_cond = asyncio.Condition()
-        self._pumping = False
-        mux.bind_apump(self._apump_next)
-
-    async def _apump_next(self) -> bool:
-        """Drive one pump step, or wait for the active pumper to drive one.
-
-        "Take-a-number" semantics: at most one task at a time calls
-        `graph_aiter.__anext__()` (asyncio iterators can't be advanced
-        concurrently). Other callers wait on a Condition that the
-        active pumper notifies after each step. This lets a "passive"
-        consumer — one whose projection's buffer is being filled by the
-        active pumper's push — wake up as soon as its data lands,
-        instead of queueing on the pump and only observing its data one
-        graph event late.
-
-        `except Exception` is intentional — `CancelledError` and other
-        `BaseException` subclasses propagate, matching asyncio's
-        cancellation contract.
-
-        Returns:
-            True if a pump step completed (by this task or another),
-            False if the graph is exhausted.
-        """
-        async with self._pump_cond:
-            if self._exhausted:
-                return False
-            if self._pumping:
-                # Another task is pumping; wait for its progress signal.
-                await self._pump_cond.wait()
-                return not self._exhausted
-            self._pumping = True
-
-        try:
-            try:
-                part = await self._graph_aiter.__anext__()
-            except StopAsyncIteration:
-                self._exhausted = True
-                await self._mux.aclose()
-                return False
-            except Exception as e:
-                self._exhausted = True
-                await self._mux.afail(e)
-                return False
-            await self._mux.apush(convert_to_protocol_event(part))
-            return True
-        finally:
-            async with self._pump_cond:
-                self._pumping = False
-                self._pump_cond.notify_all()
-
-    async def abort(self) -> None:
-        """Stop the run early.
-
-        Marks the stream exhausted, wakes any pump-waiters, and closes
-        the mux. Any `apush` blocked on backpressure wakes and returns
-        without appending. Idempotent.
-        """
-        async with self._pump_cond:
-            if self._exhausted:
-                return
-            self._exhausted = True
-            self._pump_cond.notify_all()
-        try:
-            await self._mux.aclose()
-        except Exception:
-            pass
-
-    async def __aenter__(self) -> AsyncGraphRunStream:
-        return self
-
-    async def __aexit__(
-        self,
-        exc_type: type[BaseException] | None,
-        exc: BaseException | None,
-        tb: TracebackType | None,
-    ) -> None:
-        await self.abort()
-
-    async def output(self) -> dict[str, Any] | None:
-        """Drive the run to completion and return the final state.
-
-        Methods (not properties) on the async lane so `run.output`
-        without `await` raises at type-check time instead of silently
-        yielding a coroutine object.
-
-        Example:
-            ```python
-            output = await run.output()
-            ```
-
-        Raises:
-            BaseException: If the run ended with an error.
-        """
-        await _adrive_until_done(self._apump_next)
-        if (err := self._values_transformer.error) is not None:
-            raise err
-        return self._values_transformer._latest
-
-    async def interrupted(self) -> bool:
-        """Drive the run to completion and return whether it was interrupted.
-
-        Raises:
-            BaseException: If the run ended with an error.
-        """
-        await _adrive_until_done(self._apump_next)
-        if (err := self._values_transformer.error) is not None:
-            raise err
-        return self._values_transformer._interrupted
-
-    async def interrupts(self) -> list[Any]:
-        """Drive the run to completion and return interrupt payloads.
-
-        Raises:
-            BaseException: If the run ended with an error.
-        """
-        await _adrive_until_done(self._apump_next)
-        if (err := self._values_transformer.error) is not None:
-            raise err
-        return self._values_transformer._interrupts

libs/langgraph/langgraph/stream/stream_channel.py

@@ -1,109 +0,0 @@
-from __future__ import annotations
-
-from collections.abc import AsyncIterator, Callable, Iterator
-from typing import Generic, TypeVar
-
-from langgraph.stream._event_log import EventLog
-
-T = TypeVar("T")
-
-
-class StreamChannel(Generic[T]):
-    """A named projection channel with optional protocol auto-forwarding.
-
-    Wraps an event log and declares a protocol channel name. When the
-    StreamMux detects a StreamChannel in a transformer's `init()`
-    return value, it automatically wires every `push()` to inject a
-    `ProtocolEvent` into the main event stream using the channel's
-    name as the method.
-
-    Auto-forwarded events bypass the transformer pipeline — other
-    transformers' `process()` / `aprocess()` methods do not see
-    `custom:<name>` events produced by a channel push. This prevents a
-    transformer that pushes to its own channel during `process()` from
-    re-triggering itself, but it also means filter- or tap-style
-    transformers cannot observe channel output from peer transformers.
-    Consumers that need that should iterate the main event stream.
-
-    In-process consumers iterate the channel directly (`for item in ch`
-    or `async for item in ch`). Remote SDK clients subscribe via
-    `session.subscribe("custom:<channelName>")`.
-
-    Like EventLog, a StreamChannel starts unbound. The mux calls
-    `_bind(is_async)` during registration so the correct iteration
-    protocol is available by the time user code sees it.
-
-    Lifecycle (`_close` / `_fail`) is managed by the mux — transformers
-    using only StreamChannels don't need `finalize` or `fail` hooks.
-    """
-
-    def __init__(self, name: str, *, maxlen: int | None = None) -> None:
-        """Initialize the channel with an empty inner log.
-
-        Args:
-            name: The protocol channel name used for auto-forwarded
-                events (`custom:<name>` on the wire).
-            maxlen: Optional retention cap on the inner EventLog. See
-                `EventLog.__init__` for semantics.
-        """
-        self.name = name
-        self._log: EventLog[T] = EventLog(maxlen=maxlen)
-        self._wire_fn: Callable[[T], None] | None = None
-
-    def _bind(self, *, is_async: bool) -> None:
-        """Bind the underlying event log to sync or async mode.
-
-        Args:
-            is_async: True for async iteration, False for sync.
-        """
-        self._log._bind(is_async=is_async)
-
-    def push(self, item: T) -> None:
-        """Append an item to the log and auto-forward if wired.
-
-        Args:
-            item: The item to push.
-        """
-        self._log.push(item)
-        if self._wire_fn is not None:
-            self._wire_fn(item)
-
-    # ------------------------------------------------------------------
-    # Mux lifecycle hooks (not called by transformers directly)
-    # ------------------------------------------------------------------
-
-    def _wire(self, fn: Callable[[T], None]) -> None:
-        """Install the auto-forward callback (called by StreamMux)."""
-        self._wire_fn = fn
-
-    def _close(self) -> None:
-        """Close the underlying log (called by StreamMux on run end)."""
-        self._log.close()
-
-    def _fail(self, err: BaseException) -> None:
-        """Fail the underlying log (called by StreamMux on run error)."""
-        self._log.fail(err)
-
-    # ------------------------------------------------------------------
-    # Iteration — delegates to the inner event log (multi-cursor)
-    # ------------------------------------------------------------------
-
-    def __iter__(self) -> Iterator[T]:
-        return iter(self._log)
-
-    def __aiter__(self) -> AsyncIterator[T]:
-        return self._log.__aiter__()
-
-    def tee(self, n: int = 2) -> tuple[Iterator[T], ...]:
-        """Fan out the channel into `n` independent sync iterators.
-
-        Delegates to the underlying EventLog's `tee()`.
-        """
-        return self._log.tee(n)
-
-    def atee(self, n: int = 2) -> tuple[AsyncIterator[T], ...]:
-        """Fan out the channel into `n` independent async iterators.
-
-        Delegates to the underlying EventLog's `atee()`.
-        """
-        return self._log.atee(n)

libs/langgraph/langgraph/stream/transformers.py

@@ -1,750 +0,0 @@
-from __future__ import annotations
-
-import logging
-from typing import TYPE_CHECKING, Any, Literal, cast
-
-from langchain_core.language_models._compat_bridge import message_to_events
-from langchain_core.language_models.chat_model_stream import (
-    AsyncChatModelStream,
-    ChatModelStream,
-)
-from langchain_core.messages import AIMessageChunk, BaseMessage
-from langchain_protocol.protocol import (
-    CheckpointRef,
-    LifecycleCause,
-    LifecycleData,
-    MessagesData,
-)
-
-from langgraph.errors import GraphInterrupt
-from langgraph.stream._event_log import EventLog
-from langgraph.stream._types import ProtocolEvent, StreamTransformer
-from langgraph.stream.run_stream import BaseRunStream
-
-if TYPE_CHECKING:
-    from collections.abc import Awaitable, Callable
-
-    from langgraph.stream._mux import StreamMux
-
-
-logger = logging.getLogger(__name__)
-
-
-SubgraphStatus = Literal["started", "running", "completed", "failed", "interrupted"]
-_TERMINAL_STATUSES: frozenset[SubgraphStatus] = frozenset(
-    {"completed", "failed", "interrupted"}
-)
-
-
-def _is_record(value: Any) -> bool:
-    return isinstance(value, dict)
-
-
-def _to_chat_model_stream_event(event: MessagesData) -> MessagesData:
-    """Convert wire-shaped message fields to ChatModelStream's internal shape."""
-    event_type = event.get("event")
-    converted: dict[str, Any] = dict(event)
-    if (
-        event_type == "message-start"
-        and "message_id" not in converted
-        and isinstance(converted.get("id"), str)
-    ):
-        converted["message_id"] = converted["id"]
-    if (
-        event_type in ("content-block-start", "content-block-delta", "content-block-finish")
-        and "content_block" not in converted
-        and isinstance(converted.get("content"), dict)
-    ):
-        converted["content_block"] = converted["content"]
-    return cast("MessagesData", converted)
-
-
-def _message_event_id(event: MessagesData) -> str | None:
-    raw_id = event.get("id") or event.get("message_id")
-    return str(raw_id) if raw_id is not None else None
-
-
-def _content_block_start_skeleton(content: Any) -> dict[str, Any] | None:
-    """Return a minimal content-block-start payload for a delta/finish block."""
-    if not _is_record(content) or not isinstance(content.get("type"), str):
-        return None
-
-    block_type = content["type"]
-    skeleton: dict[str, Any] = {"type": block_type}
-    if block_type == "text":
-        skeleton["text"] = ""
-    elif block_type == "reasoning":
-        skeleton["reasoning"] = ""
-    elif block_type in ("tool_call", "tool_call_chunk"):
-        skeleton["type"] = "tool_call_chunk"
-        if isinstance(content.get("id"), str):
-            skeleton["id"] = content["id"]
-        if isinstance(content.get("name"), str):
-            skeleton["name"] = content["name"]
-        skeleton["args"] = ""
-    elif block_type in ("server_tool_call", "server_tool_call_chunk"):
-        skeleton["type"] = "server_tool_call_chunk"
-        if isinstance(content.get("id"), str):
-            skeleton["id"] = content["id"]
-        if isinstance(content.get("name"), str):
-            skeleton["name"] = content["name"]
-        skeleton["args"] = ""
-    return skeleton
-
-
-def _copy_event(
-    source: ProtocolEvent,
-    *,
-    method: str,
-    namespace: list[str],
-    data: Any,
-) -> ProtocolEvent:
-    params = {**source["params"], "namespace": namespace, "data": data}
-    return {"type": "event", "method": method, "params": params}
-
-
-def _message_repair_key(event: ProtocolEvent, run_id: str) -> str:
-    namespace_key = "\x1f".join(event["params"]["namespace"])
-    return f"{namespace_key}\x1e{run_id}"
-
-
-def _extract_tool_calls_from_values(data: Any) -> dict[str, dict[str, Any]]:
-    if not _is_record(data):
-        return {}
-    messages = data.get("messages")
-    if not isinstance(messages, list):
-        return {}
-    known: dict[str, dict[str, Any]] = {}
-    for message in messages:
-        if not _is_record(message):
-            continue
-        tool_calls = message.get("tool_calls")
-        if not isinstance(tool_calls, list):
-            continue
-        for tool_call in tool_calls:
-            if not _is_record(tool_call):
-                continue
-            tool_call_id = tool_call.get("id")
-            if not isinstance(tool_call_id, str):
-                continue
-            name = tool_call.get("name")
-            args = tool_call.get("args")
-            known[tool_call_id] = {
-                "tool_name": name if isinstance(name, str) else "",
-                "input": args if _is_record(args) else {},
-            }
-    return known
-
-
-class ValuesTransformer(StreamTransformer):
-    """Capture values events as a drainable stream of state snapshots.
-
-    Keeps `_latest` / `_interrupted` / `_interrupts` as scalar state
-    regardless of whether the log has a subscriber — so `run.output()`
-    and `run.interrupted` work without forcing the caller to iterate
-    `run.values`. Log pushes are silent no-ops when unsubscribed.
-
-    Native transformer — projection keys are exposed as direct
-    attributes on the run stream (e.g. `run.values`).
-
-    `scope` (inherited from `StreamTransformer`) is the namespace the
-    transformer captures values for. `()` matches the root graph;
-    subgraph mini-muxes pass their subgraph's namespace, so each
-    instance sees only its own level.
-    """
-
-    _native = True
-    required_stream_modes = ("values",)
-
-    def __init__(self, scope: tuple[str, ...] = ()) -> None:
-        super().__init__(scope)
-        self._log: EventLog[dict[str, Any]] = EventLog()
-        self._latest: dict[str, Any] | None = None
-        self._interrupted = False
-        self._interrupts: list[Any] = []
-
-    def init(self) -> dict[str, Any]:
-        return {"values": self._log}
-
-    @property
-    def error(self) -> BaseException | None:
-        """The error that ended the run, or `None` if it succeeded.
-
-        Set by the mux when it auto-fails the projection log.
-        """
-        return self._log._error
-
-    def process(self, event: ProtocolEvent) -> bool:
-        # Namespace filtering is handled by the mux via `scope_exact`.
-        if event["method"] != "values":
-            return True
-        params = event["params"]
-        self._latest = params["data"]
-        interrupts = params.get("interrupts", ())
-        if interrupts:
-            self._interrupted = True
-            self._interrupts.extend(interrupts)
-        self._log.push(params["data"])
-        return True
-
-
-class ToolLifecycleTransformer(StreamTransformer):
-    """Repair tool-start events needed for deterministic subagent discovery.
-
-    Some subagent frameworks expose a tool-caused subgraph lifecycle before
-    a LangChain tool callback has emitted the matching `tool-started`
-    frame. Core can infer the missing start from the latest values snapshot
-    (`messages[*].tool_calls`) and emit it before the lifecycle event leaves
-    the mux, keeping remote clients from guessing from values snapshots.
-    """
-
-    scope_exact = False
-    required_stream_modes = ("values", "tools", "lifecycle")
-
-    def __init__(self, scope: tuple[str, ...] = ()) -> None:
-        super().__init__(scope)
-        self._known_tool_calls: dict[str, dict[str, Any]] = {}
-        self._emitted_tool_starts: set[str] = set()
-        self._mux: StreamMux | None = None
-
-    def init(self) -> dict[str, Any]:
-        return {}
-
-    def _on_register(self, mux: StreamMux) -> None:
-        self._mux = mux
-
-    def process(self, event: ProtocolEvent) -> bool:
-        method = event["method"]
-        data = event["params"]["data"]
-        if method == "values":
-            self._known_tool_calls.update(_extract_tool_calls_from_values(data))
-            return True
-        if method == "tools" and _is_record(data):
-            if (
-                data.get("event") == "tool-started"
-                and isinstance(data.get("tool_call_id"), str)
-            ):
-                tool_call_id = cast("str", data["tool_call_id"])
-                if tool_call_id in self._emitted_tool_starts:
-                    return False
-                self._emitted_tool_starts.add(tool_call_id)
-            return True
-        if method == "lifecycle":
-            self._emit_missing_tool_started(event)
-        return True
-
-    def _emit_missing_tool_started(self, event: ProtocolEvent) -> None:
-        if self._mux is None:
-            return
-        data = event["params"]["data"]
-        if not _is_record(data) or data.get("event") != "started":
-            return
-        cause = data.get("cause")
-        if not _is_record(cause) or cause.get("type") != "toolCall":
-            return
-        tool_call_id = cause.get("tool_call_id")
-        if not isinstance(tool_call_id, str):
-            return
-        if tool_call_id in self._emitted_tool_starts:
-            return
-        known = self._known_tool_calls.get(tool_call_id)
-        if known is None:
-            return
-
-        self._emitted_tool_starts.add(tool_call_id)
-        namespace = event["params"]["namespace"]
-        self._mux.emit(
-            _copy_event(
-                event,
-                method="tools",
-                namespace=namespace[:-1],
-                data={
-                    "event": "tool-started",
-                    "tool_call_id": tool_call_id,
-                    "tool_name": known["tool_name"],
-                    "input": known["input"],
-                },
-            )
-        )
-
-
-class MessagesTransformer(StreamTransformer):
-    """Capture messages events as ChatModelStream objects.
-
-    The messages projection yields one `ChatModelStream` (or
-    `AsyncChatModelStream`) per LLM call. Consumers iterate
-    `run.messages` to get stream handles, then use each handle's typed
-    projections (`.text`, `.reasoning`, `.tool_calls`, `.usage`,
-    `.output`) for per-message content.
-
-    Two input shapes are handled (via `params["data"] = (payload,
-    metadata)` from `StreamMessagesHandler`):
-
-    1. Protocol event (dict with `"event"` key) — emitted by
-       `stream_v2()` / `astream_v2()` via the `on_stream_event`
-       callback. Routed to an existing `ChatModelStream` by
-       `metadata["run_id"]`. A `message-start` event creates a new
-       stream; `message-finish` closes it.
-    2. Whole `AIMessage` — emitted from `on_chain_end` when a node
-       returns a finalized message. Replayed as a synthetic protocol
-       event lifecycle via `message_to_events`, then the
-       already-complete stream is pushed to the log.
-
-    V1 `AIMessageChunk` tuples (from `on_llm_new_token`) are not
-    streamed into this projection: chat models that want to populate
-    `run.messages` with content-block streaming must use
-    `stream_v2()` / `astream_v2()`. Models called via the legacy
-    `stream()` method still surface their final `AIMessage` via
-    `on_chain_end` when a node returns it as state.
-
-    `scope` (inherited from `StreamTransformer`) is the namespace the
-    transformer captures messages for. `()` matches the root graph;
-    subgraph mini-muxes pass their subgraph's namespace, so each
-    instance sees only its own level.
-
-    Native transformer — the `messages` projection is exposed as a
-    direct attribute on the run stream.
-
-    `scope_exact = False`: matches events at the transformer's own
-    namespace **or** exactly one segment deeper (the chat-model /
-    node's own task ns). Mirrors JS's root-feed filter
-    (`namespaces=[[]], depth=1`) — root accepts depth-0 events plus
-    its own nodes' depth-1 tokens; subgraph mini-muxes accept their
-    own scope plus their internal nodes' tokens. Events deeper than
-    scope + 1 are dropped (the enclosing `SubgraphTransformer` has
-    already forwarded them to the matching child mini-mux).
-    """
-
-    _native = True
-    scope_exact = False
-    required_stream_modes = ("messages",)
-
-    def __init__(self, scope: tuple[str, ...] = ()) -> None:
-        super().__init__(scope)
-        self._log: EventLog[ChatModelStream] = EventLog()
-        # Correlate protocol events back to a ChatModelStream by run_id
-        # (attached to the event's metadata by StreamMessagesHandler).
-        self._by_run: dict[str, ChatModelStream] = {}
-        self._started_blocks: dict[str, set[int]] = {}
-        self._mux: StreamMux | None = None
-        self._pump_fn: Callable[[], bool] | None = None
-        self._apump_fn: Callable[[], Awaitable[bool]] | None = None
-
-    def init(self) -> dict[str, Any]:
-        return {"messages": self._log}
-
-    def _on_register(self, mux: StreamMux) -> None:
-        self._mux = mux
-
-    def _bind_pump(self, fn: Callable[[], bool]) -> None:
-        """Wire the sync pull callback. Called by GraphRunStream._wire_request_more."""
-        self._pump_fn = fn
-
-    def _bind_apump(self, fn: Callable[[], Awaitable[bool]]) -> None:
-        """Wire the async pull callback.
-
-        Called by `AsyncGraphRunStream._wire_arequest_more` so each
-        `AsyncChatModelStream` this transformer creates can drive the
-        shared graph pump from its projection cursors.
-        """
-        self._apump_fn = fn
-
-    def _make_stream(
-        self,
-        *,
-        namespace: list[str],
-        node: str | None,
-        message_id: str | None,
-    ) -> ChatModelStream:
-        """Create a ChatModelStream (sync) or AsyncChatModelStream (async).
-
-        Wires whichever pump is bound. Prefers the async pump so nested
-        iteration under `AsyncGraphRunStream` drives the graph forward
-        without a background task. The unwired fallback (no pump bound)
-        is used by unit tests that dispatch events manually.
-        """
-        if self._apump_fn is not None:
-            astream = AsyncChatModelStream(
-                namespace=namespace,
-                node=node,
-                message_id=message_id,
-            )
-            astream.set_arequest_more(self._apump_fn)
-            return astream
-        if self._pump_fn is not None:
-            stream: ChatModelStream = ChatModelStream(
-                namespace=namespace,
-                node=node,
-                message_id=message_id,
-            )
-            stream.set_request_more(self._pump_fn)
-            return stream
-        return AsyncChatModelStream(
-            namespace=namespace,
-            node=node,
-            message_id=message_id,
-        )
-
-    def process(self, event: ProtocolEvent) -> bool:
-        if event["method"] != "messages":
-            return True
-        params = event["params"]
-        # Accept events at our scope or exactly one segment deeper
-        # (the chat-model / node's own task ns). Deeper events belong
-        # to a subgraph and are routed by `SubgraphTransformer`.
-        ns = tuple(params["namespace"])
-        depth = len(self.scope)
-        if ns[:depth] != self.scope:
-            return True
-
-        raw_data = params["data"]
-        metadata: dict[str, Any] = {}
-        if isinstance(raw_data, tuple) and len(raw_data) == 2:
-            payload, raw_metadata = raw_data
-            metadata = raw_metadata if isinstance(raw_metadata, dict) else {}
-        else:
-            payload = raw_data
-        node = params.get("node")
-        if not isinstance(node, str):
-            node = metadata.get("langgraph_node")
-            if not isinstance(node, str):
-                node = None
-        raw_run_id = params.get("run_id", metadata.get("run_id"))
-        run_id = str(raw_run_id) if raw_run_id is not None else ""
-
-        if isinstance(payload, dict) and "event" in payload:
-            self._repair_content_block_lifecycle(
-                event, cast("MessagesData", payload), run_id=run_id
-            )
-            if len(ns) > depth + 1:
-                return True
-            self._route_protocol_event(
-                cast("MessagesData", payload), run_id=run_id, node=node
-            )
-        elif isinstance(payload, BaseMessage) and not isinstance(
-            payload, AIMessageChunk
-        ):
-            self._route_whole_message(payload, node=node)
-        # Legacy AIMessageChunk tuples (from on_llm_new_token) are ignored;
-        # v1 streaming callers must switch to stream_v2() to populate this
-        # projection.
-
-        return True
-
-    def _route_protocol_event(
-        self,
-        event: MessagesData,
-        *,
-        run_id: str,
-        node: str | None,
-    ) -> None:
-        stream_event = _to_chat_model_stream_event(event)
-        event_type = event.get("event")
-        if event_type == "message-start":
-            message_id = _message_event_id(event)
-            stream = self._make_stream(
-                namespace=list(self.scope),
-                node=node,
-                message_id=message_id,
-            )
-            self._by_run[run_id or message_id or ""] = stream
-            self._log.push(stream)
-            stream.dispatch(stream_event)
-        elif run_id in self._by_run:
-            stream = self._by_run[run_id]
-            stream.dispatch(stream_event)
-            if event_type == "message-finish":
-                del self._by_run[run_id]
-
-    def _repair_content_block_lifecycle(
-        self,
-        source: ProtocolEvent,
-        event: MessagesData,
-        *,
-        run_id: str,
-    ) -> None:
-        if self._mux is None:
-            return
-        event_type = event.get("event")
-        key = _message_repair_key(source, run_id)
-        if event_type == "message-start":
-            self._started_blocks[key] = set()
-            return
-        if event_type == "content-block-start":
-            index = event.get("index")
-            if isinstance(index, int):
-                self._started_blocks.setdefault(key, set()).add(index)
-            return
-        if event_type in ("content-block-delta", "content-block-finish"):
-            index = event.get("index")
-            if not isinstance(index, int):
-                return
-            started = self._started_blocks.setdefault(key, set())
-            if index in started:
-                return
-            skeleton = _content_block_start_skeleton(event.get("content"))
-            if skeleton is None:
-                return
-            started.add(index)
-            self._mux.emit(
-                _copy_event(
-                    source,
-                    method="messages",
-                    namespace=list(source["params"]["namespace"]),
-                    data={
-                        "event": "content-block-start",
-                        "index": index,
-                        "content": skeleton,
-                    },
-                )
-            )
-        elif event_type == "message-finish":
-            self._started_blocks.pop(key, None)
-
-    def _route_whole_message(self, message: BaseMessage, *, node: str | None) -> None:
-        stream = self._make_stream(
-            namespace=list(self.scope),
-            node=node,
-            message_id=message.id,
-        )
-        for evt in message_to_events(message, message_id=message.id):
-            stream.dispatch(evt)
-        self._log.push(stream)
-
-    def finalize(self) -> None:
-        """Clear any routing state — streams close themselves via `message-finish`."""
-        self._by_run.clear()
-        self._started_blocks.clear()
-
-    def fail(self, err: BaseException) -> None:
-        """Propagate run error to any streams still open when the graph fails."""
-        for stream in list(self._by_run.values()):
-            stream.fail(err)
-        self._by_run.clear()
-        self._started_blocks.clear()
-
-
-class SubgraphRunStream(BaseRunStream):
-    """Scoped view of a single nested subgraph execution.
-
-    Yielded on `run.subgraphs` (or `parent.subgraphs` for grandchildren)
-    when a nested `Pregel` spawns. Wraps a mini-`StreamMux` built with
-    the same transformer factories as the root mux, so `.values`,
-    `.messages`, `.subgraphs` are populated by the standard
-    transformers scoped to this handle's namespace — no duplicated
-    routing logic. The mini-mux borrows the root's pump via
-    `make_child`'s pump inheritance, so any cursor on a subagent
-    projection drives the whole run forward.
-
-    Lifecycle fields update in place as events arrive:
-
-    - `path`: the namespace tuple — stable for the life of the handle.
-    - `graph_name` / `cause`: set once from the `started` payload.
-      `cause` is populated by product-specific stream transformers
-      (see `LifecycleCause` in the protocol definition); pregel itself
-      emits no `cause`, so it may be `None` for subgraphs not covered
-      by a product transformer.
-    - `status`: advances `started` → `running` → `completed` /
-      `failed` / `interrupted`.
-    - `error` / `checkpoint`: set on the terminal event when present.
-
-    `.output` is a snapshot of the latest values seen at this
-    namespace — it doesn't drive the pump (unlike root's
-    `GraphRunStream.output`), because advancing a subgraph to
-    completion is only meaningful as part of advancing the whole run.
-    """
-
-    def __init__(
-        self,
-        path: tuple[str, ...],
-        mux: StreamMux,
-        *,
-        graph_name: str | None = None,
-        cause: LifecycleCause | None = None,
-    ) -> None:
-        super().__init__(mux)
-        self.path: tuple[str, ...] = path
-        self.graph_name: str | None = graph_name
-        self.cause: LifecycleCause | None = cause
-        self.status: SubgraphStatus = "started"
-        self.error: str | None = None
-        self.checkpoint: CheckpointRef | None = None
-
-    @property
-    def output(self) -> dict[str, Any] | None:
-        """Latest values snapshot at this namespace, or `None`.
-
-        Snapshot-only — iterating other projections or the root's
-        `.output` is what drives the pump.
-        """
-        values_t = self._mux.transformer_by_key("values")
-        if isinstance(values_t, ValuesTransformer):
-            return values_t._latest
-        return None
-
-
-class SubgraphTransformer(StreamTransformer):
-    """Discover subgraphs and route events into per-subgraph mini-muxes.
-
-    Thin state-machine + dispatcher. At its own `scope` (inherited
-    from `StreamTransformer`, determined by the enclosing mux), it
-    watches for `lifecycle` events at exactly one level deeper to
-    discover direct children. Each discovered child gets its own
-    `SubgraphRunStream` backed by a mini-`StreamMux` — built via
-    `parent_mux.make_child(path)`, so the same factory list produces
-    fresh transformer instances at the child's scope.
-
-    Every incoming event that falls under one of the direct children
-    (ns starts with a child's `path`) is forwarded into that child's
-    mini-mux via `push`. The standard transformers in that mini-mux
-    (`ValuesTransformer`, `MessagesTransformer`, and another
-    `SubgraphTransformer` for grandchildren) handle the rest. No
-    duplicated routing or assembly logic.
-
-    Lifecycle state for each handle (running / completed / failed /
-    interrupted) is updated in place as events fire. On terminal
-    events, the handle's mini-mux is closed so any subscribed cursors
-    unblock. `finalize` / `fail` handle dangling handles left mid-run.
-
-    Native transformer — `subgraphs` exposes the direct-children log.
-
-    `scope_exact = False`: this transformer sees events at any
-    namespace, because it forwards out-of-scope events to the matching
-    direct-child mini-mux.
-    """
-
-    _native = True
-    scope_exact = False
-    required_stream_modes = ("lifecycle",)
-
-    def __init__(self, scope: tuple[str, ...] = ()) -> None:
-        super().__init__(scope)
-        self._root_log: EventLog[SubgraphRunStream] = EventLog()
-        # Direct children only (namespace = scope + one segment).
-        self._by_ns: dict[tuple[str, ...], SubgraphRunStream] = {}
-        self._mux: StreamMux | None = None
-
-    def init(self) -> dict[str, Any]:
-        return {"subgraphs": self._root_log}
-
-    def _on_register(self, mux: StreamMux) -> None:
-        """Capture the enclosing mux so we can build child mini-muxes."""
-        self._mux = mux
-
-    def process(self, event: ProtocolEvent) -> bool:
-        ns = tuple(event["params"]["namespace"])
-        method = event["method"]
-        depth = len(self.scope)
-
-        # 1. On `started` for a direct child (ns depth = mine + 1 and
-        #    ns prefix matches mine), register the handle.
-        if method == "lifecycle" and len(ns) == depth + 1 and ns[:-1] == self.scope:
-            data = cast(LifecycleData, event["params"]["data"])
-            if data.get("event") == "started":
-                self._on_started(ns, data)
-
-        # 2. Forward the event to the matching direct-child mini-mux
-        #    before the status-change step below so that terminal events
-        #    reach the child's log and grandchild transformers *before*
-        #    the child's mini-mux is closed. Prefix-match: ns must start
-        #    with some child's path.
-        direct_child_ns = ns[: depth + 1] if len(ns) > depth else None
-        if direct_child_ns is not None and direct_child_ns in self._by_ns:
-            self._by_ns[direct_child_ns]._mux.push(event)
-
-        # 3. Status change for a direct child (ns = child's path, method
-        #    = lifecycle). Update handle fields, close mini-mux on
-        #    terminal.
-        if (
-            method == "lifecycle"
-            and ns in self._by_ns
-            and len(ns) == depth + 1
-            and ns[:-1] == self.scope
-        ):
-            data = cast(LifecycleData, event["params"]["data"])
-            event_type = data.get("event")
-            if event_type in ("running", "completed", "failed", "interrupted"):
-                self._on_status_change(ns, event_type, data)
-
-        return True
-
-    def _on_started(self, ns: tuple[str, ...], data: LifecycleData) -> None:
-        if ns in self._by_ns:
-            # Duplicate started — ignore.
-            return
-        # `_on_register` is called by the mux during registration, which
-        # happens before any event can be dispatched — so this should
-        # always be set by the time we process an event.
-        assert self._mux is not None, (
-            "SubgraphTransformer processed an event before _on_register; "
-            "transformer registration ordering is broken."
-        )
-        child_mux = self._mux.make_child(ns)
-        handle = SubgraphRunStream(
-            path=ns,
-            mux=child_mux,
-            graph_name=data.get("graph_name"),
-            cause=data.get("cause"),
-        )
-        self._by_ns[ns] = handle
-        self._root_log.push(handle)
-
-    def _on_status_change(
-        self,
-        ns: tuple[str, ...],
-        event_type: SubgraphStatus,
-        data: LifecycleData,
-    ) -> None:
-        handle = self._by_ns[ns]
-        handle.status = event_type
-        err = data.get("error")
-        if err is not None:
-            handle.error = err
-        checkpoint = data.get("checkpoint")
-        if checkpoint is not None:
-            handle.checkpoint = checkpoint
-        if event_type in _TERMINAL_STATUSES:
-            self._close_handle_mux(handle)
-
-    @staticmethod
-    def _close_handle_mux(handle: SubgraphRunStream) -> None:
-        # Idempotent close — mux.close() runs finalize on its transformers
-        # (which cascades through grandchildren) and closes projection logs.
-        if not handle._mux._events._closed:
-            try:
-                handle._mux.close()
-            except Exception:
-                logger.warning(
-                    "Error closing subgraph mini-mux at %s; subscribers "
-                    "may not see a clean close.",
-                    handle.path,
-                    exc_info=True,
-                )
-
-    def finalize(self) -> None:
-        """Transition any still-open direct children to `completed`."""
-        for handle in self._by_ns.values():
-            if handle.status not in _TERMINAL_STATUSES:
-                handle.status = "completed"
-            self._close_handle_mux(handle)
-
-    def fail(self, err: BaseException) -> None:
-        """Transition any still-open direct children to `failed` / `interrupted`."""
-        is_interrupt = isinstance(err, GraphInterrupt)
-        terminal: SubgraphStatus = "interrupted" if is_interrupt else "failed"
-        error_str = None if is_interrupt else str(err)
-        for handle in self._by_ns.values():
-            if handle.status not in _TERMINAL_STATUSES:
-                handle.status = terminal
-                if error_str is not None and handle.error is None:
-                    handle.error = error_str
-            if not handle._mux._events._closed:
-                try:
-                    handle._mux.fail(err)
-                except Exception:
-                    logger.warning(
-                        "Error failing subgraph mini-mux at %s; subscribers "
-                        "may not see the terminal error.",
-                        handle.path,
-                        exc_info=True,
-                    )

libs/langgraph/langgraph/types.py

@@ -116,15 +116,7 @@ def ensure_valid_checkpointer(checkpointer: Checkpointer) -> Checkpointer:
 
 
 StreamMode = Literal[
-    "values",
-    "updates",
-    "checkpoints",
-    "tasks",
-    "debug",
-    "messages",
-    "custom",
-    "lifecycle",
-    "tools",
+    "values", "updates", "checkpoints", "tasks", "debug", "messages", "custom"
 ]
 """How the stream method should emit outputs.
 
@@ -137,8 +129,6 @@ StreamMode = Literal[
 - `"checkpoints"`: Emit an event when a checkpoint is created, in the same format as returned by `get_state()`.
 - `"tasks"`: Emit events when tasks start and finish, including their results and errors.
 - `"debug"`: Emit `"checkpoints"` and `"tasks"` events for debugging purposes.
-- `"lifecycle"`: Emit subgraph lifecycle events (`started`, `running`, `completed`, `failed`, `interrupted`) with payloads matching `LifecycleData`.
-- `"tools"`: Emit tool-call lifecycle events (`tool-started`, `tool-output-delta`, `tool-finished`, `tool-error`) keyed by `tool_call_id`.
 """
 
 StreamWriter = Callable[[Any], None]

libs/langgraph/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "1.1.7a2"
+version = "1.1.9"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.10"
@@ -24,7 +24,7 @@ classifiers = [
     'Programming Language :: Python :: 3.13',
 ]
 dependencies = [
-    "langchain-core>=1.3.2",
+    "langchain-core>=1.3.0,<2",
     "langgraph-checkpoint>=2.1.0,<5.0.0",
     "langgraph-sdk>=0.3.0,<0.4.0",
     "langgraph-prebuilt>=1.0.9,<1.1.0",

libs/langgraph/tests/test_channels.py

@@ -2,13 +2,17 @@ import operator
 from collections.abc import Sequence
 
 import pytest
+from langchain_core.messages import AIMessage, HumanMessage
+from langgraph.checkpoint.base import DELTA_SENTINEL
 
 from langgraph._internal._typing import MISSING
 from langgraph.channels.binop import BinaryOperatorAggregate
+from langgraph.channels.delta import DeltaChannel
 from langgraph.channels.last_value import LastValue
 from langgraph.channels.topic import Topic
 from langgraph.channels.untracked_value import UntrackedValue
 from langgraph.errors import EmptyChannelError, InvalidUpdateError
+from langgraph.graph.message import add_messages
 
 pytestmark = pytest.mark.anyio
 
@@ -117,3 +121,594 @@ def test_untracked_value() -> None:
     new_channel = UntrackedValue(dict).from_checkpoint(checkpoint)
     with pytest.raises(EmptyChannelError):
         new_channel.get()
+
+
+def test_delta_channel_basic_two_steps() -> None:
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.base import DELTA_SENTINEL
+
+    from langgraph.graph.message import add_messages
+
+    ch = DeltaChannel(add_messages).from_checkpoint(MISSING)
+
+    # Step 1: one message added
+    ch.update([HumanMessage(content="hi", id="h1")])
+    d1 = ch.checkpoint()
+    assert d1 is DELTA_SENTINEL
+
+    # Step 2: another message
+    ch.update([AIMessage(content="hello", id="a1")])
+    d2 = ch.checkpoint()
+    assert d2 is DELTA_SENTINEL
+
+    # Full accumulated value is preserved in memory
+    assert len(ch.get()) == 2
+    assert ch.get()[0].content == "hi"
+    assert ch.get()[1].content == "hello"
+
+
+def test_delta_channel_from_checkpoint_writes_list() -> None:
+    """replay_writes on a fresh channel replays through the operator."""
+    from langchain_core.messages import AIMessage, HumanMessage
+
+    from langgraph.graph.message import add_messages
+
+    spec = DeltaChannel(add_messages)
+    ch = spec.from_checkpoint(DELTA_SENTINEL)
+    ch.replay_writes(
+        [
+            ("t0", "messages", HumanMessage(content="hi", id="h1")),
+            ("t1", "messages", AIMessage(content="hello", id="a1")),
+            ("t2", "messages", HumanMessage(content="bye", id="h2")),
+        ]
+    )
+    msgs = ch.get()
+    assert len(msgs) == 3
+    assert msgs[0].content == "hi"
+    assert msgs[1].content == "hello"
+    assert msgs[2].content == "bye"
+
+
+def test_delta_channel_from_checkpoint_backwards_compat() -> None:
+    from langchain_core.messages import HumanMessage
+
+    from langgraph.graph.message import add_messages
+
+    # Old BinaryOperatorAggregate checkpoint: plain list treated as backward compat
+    spec = DeltaChannel(add_messages)
+    old_value = [HumanMessage(content="old", id="h1")]
+    ch = spec.from_checkpoint(old_value)
+    assert ch.get() == old_value
+
+
+def test_delta_channel_overwrite() -> None:
+    from langchain_core.messages import HumanMessage
+    from langgraph.checkpoint.base import DELTA_SENTINEL
+
+    from langgraph.graph.message import add_messages
+    from langgraph.types import Overwrite
+
+    ch = DeltaChannel(add_messages).from_checkpoint(MISSING)
+    ch.update([HumanMessage(content="old", id="h1")])
+
+    ch.update([Overwrite([HumanMessage(content="new", id="h2")])])
+    d = ch.checkpoint()
+    assert d is DELTA_SENTINEL
+    # After overwrite, value is reset to only the new message
+    assert len(ch.get()) == 1
+    assert ch.get()[0].content == "new"
+
+
+def test_delta_channel_remove_message_and_replay() -> None:
+    """RemoveMessage must round-trip correctly when writes are replayed."""
+    from langchain_core.messages import AIMessage, HumanMessage, RemoveMessage
+
+    from langgraph.graph.message import add_messages
+
+    spec = DeltaChannel(add_messages)
+    ch = spec.from_checkpoint(MISSING)
+
+    # Step 1: add two messages
+    ch.update([HumanMessage(content="hi", id="h1")])
+    ch.update([AIMessage(content="hello", id="a1")])
+    assert ch.get() == [
+        HumanMessage(content="hi", id="h1"),
+        AIMessage(content="hello", id="a1"),
+    ]
+
+    # Step 2: remove the AI message
+    ch.update([RemoveMessage(id="a1")])
+    assert ch.get() == [HumanMessage(content="hi", id="h1")]
+
+    # Replay the writes list from scratch — must reproduce the post-remove state
+    ch2 = spec.from_checkpoint(DELTA_SENTINEL)
+    ch2.replay_writes(
+        [
+            ("t0", "messages", HumanMessage(content="hi", id="h1")),
+            ("t1", "messages", AIMessage(content="hello", id="a1")),
+            ("t2", "messages", RemoveMessage(id="a1")),
+        ]
+    )
+    assert ch2.get() == [HumanMessage(content="hi", id="h1")]
+
+
+def test_delta_channel_update_by_id_and_replay() -> None:
+    """Updating a message by ID must round-trip correctly through writes replay."""
+    from langchain_core.messages import HumanMessage
+
+    from langgraph.graph.message import add_messages
+
+    spec = DeltaChannel(add_messages)
+    ch = spec.from_checkpoint(MISSING)
+
+    # Step 1: add a message
+    ch.update([HumanMessage(content="original", id="h1")])
+
+    # Step 2: update the same message by ID
+    ch.update([HumanMessage(content="updated", id="h1")])
+    assert ch.get() == [HumanMessage(content="updated", id="h1")]
+
+    # Replay writes — must produce the updated message, not the original
+    ch2 = spec.from_checkpoint(DELTA_SENTINEL)
+    ch2.replay_writes(
+        [
+            ("t0", "messages", HumanMessage(content="original", id="h1")),
+            ("t1", "messages", HumanMessage(content="updated", id="h1")),
+        ]
+    )
+    assert len(ch2.get()) == 1
+    assert ch2.get()[0].content == "updated"
+
+
+def test_delta_channel_checkpoint_returns_sentinel() -> None:
+    """checkpoint() always returns DELTA_SENTINEL regardless of state."""
+    from langgraph.checkpoint.base import DELTA_SENTINEL
+
+    from langgraph.graph.message import add_messages
+
+    ch = DeltaChannel(add_messages).from_checkpoint(MISSING)
+    assert ch.checkpoint() is DELTA_SENTINEL
+
+    from langchain_core.messages import HumanMessage
+
+    ch.update([HumanMessage(content="hi", id="h1")])
+    assert ch.checkpoint() is DELTA_SENTINEL
+
+
+def test_delta_channel_snapshot_step_based() -> None:
+    """Snapshots fire on every Nth step regardless of whether the channel was written.
+
+    With snapshot_frequency=N, every Nth pregel step produces a _DeltaSnapshot
+    blob — even if the channel had no write that step (eager snapshot). This
+    bounds the ancestor walk to at most N steps on any read.
+    """
+    from typing import Annotated
+
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+    from langgraph.checkpoint.serde.types import _DeltaSnapshot
+    from typing_extensions import TypedDict
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    # snapshot_frequency=5: snapshot every 5 pregel steps
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages, snapshot_frequency=5)]
+        other: str
+
+    def node_a(state: State) -> dict:
+        # writes to messages
+        i = len(state["messages"]) // 2
+        return {"messages": [AIMessage(content=f"a{i}", id=f"a{i}")]}
+
+    def node_b(state: State) -> dict:
+        # writes ONLY to other, not messages — snapshot must still fire at step N
+        return {"other": "y"}
+
+    g = StateGraph(State)
+    g.add_node("a", node_a)
+    g.add_node("b", node_b)
+    g.add_edge(START, "a")
+    g.add_edge("a", "b")
+    saver = InMemorySaver()
+    graph = g.compile(checkpointer=saver)
+
+    config = {"configurable": {"thread_id": "t1"}}
+    for i in range(6):
+        graph.invoke(
+            {"messages": [HumanMessage(content=f"h{i}", id=f"h{i}")], "other": ""},
+            config,
+        )
+
+    # Confirm at least one snapshot blob exists for messages
+    msg_blob_values = [
+        saver.serde.loads_typed((type_tag, blob))
+        for k, (type_tag, blob) in saver.blobs.items()
+        if k[2] == "messages" and type_tag == "msgpack" and blob
+    ]
+    snapshots = [v for v in msg_blob_values if isinstance(v, _DeltaSnapshot)]
+    assert snapshots, "expected at least one _DeltaSnapshot blob for messages"
+
+    # Final state must be correct regardless of snapshot cadence
+    state = graph.get_state(config)
+    assert len(state.values["messages"]) == 12  # 6 human + 6 AI
+
+
+def test_delta_channel_snapshot_fires_even_when_not_written() -> None:
+    """Eager snapshot: _DeltaSnapshot stored at snapshot step even when the
+    channel had no write that step (node_b doesn't touch messages).
+    """
+    from typing import Annotated
+
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+    from langgraph.checkpoint.serde.types import _DeltaSnapshot
+    from typing_extensions import TypedDict
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages, snapshot_frequency=3)]
+        tick: int
+
+    def writer(state: State) -> dict:
+        i = len(state["messages"]) // 2
+        return {"messages": [AIMessage(content=f"a{i}", id=f"a{i}")]}
+
+    def ticker(state: State) -> dict:
+        # never writes messages
+        return {"tick": state["tick"] + 1}
+
+    g = StateGraph(State)
+    g.add_node("writer", writer)
+    g.add_node("ticker", ticker)
+    g.add_edge(START, "writer")
+    g.add_edge("writer", "ticker")
+    saver = InMemorySaver()
+    graph = g.compile(checkpointer=saver)
+
+    config = {"configurable": {"thread_id": "t1"}}
+    for i in range(5):
+        graph.invoke(
+            {"messages": [HumanMessage(content=f"h{i}", id=f"h{i}")], "tick": 0},
+            config,
+        )
+
+    # Count distinct message channel blob versions
+    msg_blobs = {
+        k: saver.serde.loads_typed((t, b))
+        for k, (t, b) in saver.blobs.items()
+        if k[2] == "messages" and t == "msgpack" and b
+    }
+    snapshots = {k: v for k, v in msg_blobs.items() if isinstance(v, _DeltaSnapshot)}
+    # There must be snapshots (ticker steps are snapshot steps too)
+    assert snapshots, (
+        "eager snapshots must fire even on steps where messages wasn't written"
+    )
+
+    # All get_state calls must return the correct accumulated value
+    state = graph.get_state(config)
+    assert len(state.values["messages"]) == 10  # 5 human + 5 AI
+
+
+def test_delta_channel_inmemory_saver_assembles_writes() -> None:
+    """InMemorySaver assembles writes from checkpoint_writes inside get_tuple."""
+    from typing import Annotated
+
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+    from typing_extensions import TypedDict
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    n = {"v": 0}
+
+    def respond(state: State) -> dict:
+        n["v"] += 1
+        return {"messages": [AIMessage(content=f"ok{n['v']}", id=f"ai{n['v']}")]}
+
+    builder = StateGraph(State)
+    builder.add_node("respond", respond)
+    builder.add_edge(START, "respond")
+    saver = InMemorySaver()
+    graph = builder.compile(checkpointer=saver)
+    config = {"configurable": {"thread_id": "t1"}}
+
+    graph.invoke({"messages": [HumanMessage(content="hi", id="h1")]}, config)
+    graph.invoke({"messages": [HumanMessage(content="bye", id="h2")]}, config)
+
+    # get_tuple returns raw storage shape — channel_values stores DELTA_SENTINEL
+    # for delta channels; the reconstructed writes flow separately via
+    # saver._get_channel_writes_history.
+    saved = saver.get_tuple(config)
+    assert saved is not None
+    assert "messages" in saved.checkpoint["channel_values"]
+    assert saved.checkpoint["channel_values"]["messages"] is DELTA_SENTINEL
+
+    state = graph.get_state(config)
+    assert len(state.values["messages"]) == 4  # 2 human + 2 AI
+
+
+# ---------------------------------------------------------------------------
+# Dict-reducer tests
+# ---------------------------------------------------------------------------
+
+
+def _delta_channel_with_type(operator, typ):
+    """Build a DeltaChannel with an explicit type via the Annotated injection path."""
+    from typing import Annotated
+
+    from langgraph.channels.delta import DeltaChannel
+    from langgraph.graph.state import _get_channel
+
+    return _get_channel("_test", Annotated[typ, DeltaChannel(operator)])
+
+
+def test_delta_channel_dict_reducer_fresh_channel() -> None:
+    """DeltaChannel with a dict reducer starts as empty dict on MISSING checkpoint."""
+
+    def merge_dicts(left: dict, right: dict) -> dict:
+        return {**left, **right}
+
+    ch = _delta_channel_with_type(merge_dicts, dict).from_checkpoint(MISSING)
+    assert ch.is_available()
+    assert ch.get() == {}
+
+
+def test_delta_channel_dict_reducer_basic_updates() -> None:
+    """DeltaChannel with a dict reducer accumulates key/value pairs across steps."""
+
+    def merge_dicts(left: dict, right: dict) -> dict:
+        return {**left, **right}
+
+    ch = _delta_channel_with_type(merge_dicts, dict).from_checkpoint(MISSING)
+
+    ch.update([{"a": 1}])
+    d1 = ch.checkpoint()
+    assert d1 is DELTA_SENTINEL
+
+    ch.update([{"b": 2}])
+    d2 = ch.checkpoint()
+    assert d2 is DELTA_SENTINEL
+
+    assert ch.get() == {"a": 1, "b": 2}
+
+
+def test_delta_channel_dict_reducer_writes_reconstruction() -> None:
+    """replay_writes on a fresh channel replays through a dict merge reducer."""
+
+    def merge_dicts(left: dict, right: dict) -> dict:
+        return {**left, **right}
+
+    spec = _delta_channel_with_type(merge_dicts, dict)
+    ch = spec.from_checkpoint(DELTA_SENTINEL)
+    ch.replay_writes(
+        [
+            ("t0", "files", {"a": 1}),
+            ("t1", "files", {"b": 2}),
+            ("t2", "files", {"c": 3}),
+        ]
+    )
+    assert ch.get() == {"a": 1, "b": 2, "c": 3}
+
+
+def test_delta_channel_dict_reducer_with_deletions() -> None:
+    """Dict reducer that treats None values as deletions works end-to-end."""
+
+    def merge_files(left: dict | None, right: dict) -> dict:
+        if left is None:
+            return {k: v for k, v in right.items() if v is not None}
+        result = {**left}
+        for k, v in right.items():
+            if v is None:
+                result.pop(k, None)
+            else:
+                result[k] = v
+        return result
+
+    ch = _delta_channel_with_type(merge_files, dict).from_checkpoint(MISSING)
+    ch.update([{"file1.py": "content1", "file2.py": "content2"}])
+    ch.update([{"file1.py": None, "file3.py": "content3"}])
+    assert ch.get() == {"file2.py": "content2", "file3.py": "content3"}
+
+    spec = _delta_channel_with_type(merge_files, dict)
+    ch2 = spec.from_checkpoint(DELTA_SENTINEL)
+    ch2.replay_writes(
+        [
+            ("t0", "files", {"file1.py": "content1", "file2.py": "content2"}),
+            ("t1", "files", {"file1.py": None, "file3.py": "content3"}),
+        ]
+    )
+    assert ch2.get() == {"file2.py": "content2", "file3.py": "content3"}
+
+
+def test_delta_channel_dict_reducer_overwrite_in_update() -> None:
+    """Overwrite(dict) in update() must preserve dict shape, not coerce to list."""
+    from langgraph.types import Overwrite
+
+    def merge_dicts(left: dict, right: dict) -> dict:
+        return {**left, **right}
+
+    ch = _delta_channel_with_type(merge_dicts, dict).from_checkpoint(MISSING)
+    ch.update([{"a": 1}])
+    ch.update([Overwrite({"b": 2, "c": 3})])
+    assert ch.get() == {"b": 2, "c": 3}
+
+
+def test_delta_channel_dict_reducer_overwrite_in_writes_replay() -> None:
+    """Overwrite(dict) embedded in replayed writes must reconstruct as dict."""
+    from langgraph.types import Overwrite
+
+    def merge_dicts(left: dict, right: dict) -> dict:
+        return {**left, **right}
+
+    spec = _delta_channel_with_type(merge_dicts, dict)
+    ch = spec.from_checkpoint(DELTA_SENTINEL)
+    ch.replay_writes(
+        [
+            ("t0", "files", {"a": 1}),
+            ("t1", "files", Overwrite({"x": 10, "y": 20})),
+            ("t2", "files", {"z": 30}),
+        ]
+    )
+    assert ch.get() == {"x": 10, "y": 20, "z": 30}
+
+
+def test_delta_channel_dict_reducer_with_notrequired_annotation() -> None:
+    """DeltaChannel infers dict type through `Annotated[NotRequired[dict[...]], ch]`."""
+    from typing import Annotated
+
+    from typing_extensions import NotRequired
+
+    from langgraph.channels.delta import DeltaChannel
+    from langgraph.graph.state import _get_channel
+
+    def merge_dicts(left: dict | None, right: dict) -> dict:
+        if left is None:
+            return dict(right)
+        return {**left, **right}
+
+    annotation = Annotated[NotRequired[dict[str, int]], DeltaChannel(merge_dicts)]
+    ch = _get_channel("files", annotation).from_checkpoint(MISSING)
+    assert ch.get() == {}
+    ch.update([{"a": 1}])
+    ch.update([{"b": 2}])
+    assert ch.get() == {"a": 1, "b": 2}
+
+
+def test_delta_channel_dict_reducer_end_to_end_filesystem() -> None:
+    """End-to-end: graph with dict-reducer (filesystem-style) channel wrapped in DeltaChannel."""
+    from typing import Annotated
+
+    from langgraph.checkpoint.memory import InMemorySaver
+    from typing_extensions import TypedDict
+
+    from langgraph.channels.delta import DeltaChannel
+    from langgraph.graph import START, StateGraph
+
+    def merge_files(left: dict | None, right: dict) -> dict:
+        if left is None:
+            return {k: v for k, v in right.items() if v is not None}
+        result = {**left}
+        for k, v in right.items():
+            if v is None:
+                result.pop(k, None)
+            else:
+                result[k] = v
+        return result
+
+    class State(TypedDict):
+        files: Annotated[dict[str, str], DeltaChannel(merge_files)]
+
+    turn = {"v": 0}
+
+    def write_file(state: State) -> dict:
+        turn["v"] += 1
+        n = turn["v"]
+        return {"files": {f"/doc_{n}.txt": f"content for turn {n}"}}
+
+    builder = StateGraph(State)
+    builder.add_node("write_file", write_file)
+    builder.add_edge(START, "write_file")
+    saver = InMemorySaver()
+    graph = builder.compile(checkpointer=saver)
+    config = {"configurable": {"thread_id": "fs"}}
+
+    for _ in range(3):
+        graph.invoke({"files": {}}, config)
+
+    saved = saver.get_tuple(config)
+    assert saved is not None
+    assert saved.checkpoint["channel_values"]["files"] is DELTA_SENTINEL
+    state = graph.get_state(config)
+    assert state.values["files"] == {
+        "/doc_1.txt": "content for turn 1",
+        "/doc_2.txt": "content for turn 2",
+        "/doc_3.txt": "content for turn 3",
+    }
+
+    def delete_file(state: State) -> dict:
+        return {"files": {"/doc_1.txt": None}}
+
+    builder2 = StateGraph(State)
+    builder2.add_node("write_file", write_file)
+    builder2.add_node("delete_file", delete_file)
+    builder2.add_edge(START, "write_file")
+    builder2.add_edge("write_file", "delete_file")
+    turn["v"] = 0
+    saver2 = InMemorySaver()
+    graph2 = builder2.compile(checkpointer=saver2)
+    config2 = {"configurable": {"thread_id": "fs2"}}
+    graph2.invoke({"files": {}}, config2)
+    state2 = graph2.get_state(config2)
+    assert state2.values["files"] == {}
+
+
+def test_delta_channel_dict_reducer_backwards_compat() -> None:
+    """A pre-DeltaChannel dict checkpoint must load as a dict, not be listified."""
+
+    def merge_dicts(left: dict, right: dict) -> dict:
+        return {**left, **right}
+
+    spec = _delta_channel_with_type(merge_dicts, dict)
+    old_value = {"a": 1, "b": 2}
+    ch = spec.from_checkpoint(old_value)
+    assert ch.get() == {"a": 1, "b": 2}
+
+
+# ---------------------------------------------------------------------------
+# seed / pre-delta migration
+# ---------------------------------------------------------------------------
+
+
+def test_delta_channel_from_checkpoint_honors_seed() -> None:
+    """A non-sentinel value to from_checkpoint is used as the pre-delta seed.
+
+    Guards the pre-delta migration path: when the saver's ancestor walk hits
+    a pre-DeltaChannel blob it passes it as `seed` so replay reconstructs
+    the post-migration state correctly rather than replaying from empty.
+    """
+    spec = DeltaChannel(add_messages)
+    seed = [HumanMessage(content="pre-delta", id="p1")]
+    ch = spec.from_checkpoint(seed)
+    ch.replay_writes(
+        [
+            ("t0", "messages", AIMessage(content="delta-1", id="d1")),
+            ("t1", "messages", HumanMessage(content="delta-2", id="d2")),
+        ]
+    )
+    msgs = ch.get()
+    assert [m.content for m in msgs] == ["pre-delta", "delta-1", "delta-2"]
+
+
+def test_delta_channel_from_checkpoint_seed_without_writes() -> None:
+    """Reconstruction at a pre-delta ancestor with no newer deltas returns
+    just the seed — the saver's terminator fired immediately."""
+    spec = DeltaChannel(add_messages)
+    seed = [HumanMessage(content="only-snap", id="s1")]
+    ch = spec.from_checkpoint(seed)
+    ch.replay_writes([])
+    assert ch.get() == seed
+
+
+def test_delta_channel_from_checkpoint_seed_none_is_distinct_from_sentinel() -> None:
+    """`seed=None` must start replay from None, not from an empty channel.
+
+    The DELTA_SENTINEL / MISSING sentinels mean 'no seed'; passing `None`
+    explicitly should feed None to the reducer as the left operand.
+    """
+
+    def replace(left, right):
+        return right
+
+    spec = DeltaChannel(replace)
+    ch = spec.from_checkpoint(None)
+    ch.replay_writes([("t0", "x", "after")])
+    # Reducer replaces; seed=None → first write produces "after".
+    assert ch.get() == "after"

libs/langgraph/tests/test_delta_channel_benchmark.py

@@ -0,0 +1,472 @@
+"""Benchmark: DeltaChannel snapshot_frequency — storage vs. read-depth tradeoff.
+
+Run directly:  python tests/test_delta_channel_benchmark.py
+Run via pytest: pytest tests/test_delta_channel_benchmark.py -s
+
+Part 1 — baseline (original): DeltaChannel(inf) vs add_messages (BinOp).
+Part 2 — snapshot_frequency sweep: shows the storage/read-latency tradeoff
+  across frequencies [1, 5, 10, 50, inf] at scale.
+
+Key insight:
+  snapshot_frequency=inf  → O(N) storage, O(N) read depth (pure delta)
+  snapshot_frequency=N    → O(N²/N) storage, O(N) read depth bounded by freq
+  snapshot_frequency=1    → O(N²) storage, O(1) read depth (full snapshot)
+"""
+
+from __future__ import annotations
+
+import contextlib
+import math
+import sys
+import time
+from typing import Annotated, Any
+
+import pytest
+from langchain_core.messages import AIMessage, HumanMessage
+from langgraph.checkpoint.memory import MemorySaver
+from typing_extensions import TypedDict
+
+from langgraph.channels.delta import DeltaChannel
+from langgraph.graph import END, StateGraph
+from langgraph.graph.message import add_messages
+
+try:
+    from langgraph.checkpoint.postgres import PostgresSaver
+
+    _POSTGRES_AVAILABLE = True
+    _POSTGRES_URI = "postgres://sydney_runkle@localhost:5441/postgres?sslmode=disable"
+except ImportError:
+    _POSTGRES_AVAILABLE = False
+
+# ---------------------------------------------------------------------------
+# Realistic message payload (~100 tokens / ~400 chars each)
+# ---------------------------------------------------------------------------
+
+_HUMAN_TEMPLATE = (
+    "I need help understanding the implications of {topic} on our system architecture. "
+    "Specifically, I'm concerned about how this interacts with our existing {concern} "
+    "and whether we need to refactor the {component} layer before proceeding. "
+    "We've had prior incidents in this area and want to be deliberate. "
+    "What should we prioritize first, and are there known failure modes we should design around from the start?"
+)
+
+_AI_TEMPLATE = (
+    "Great question about {topic}. The key insight here is that {concern} introduces "
+    "a subtle ordering dependency that most teams overlook until they hit it in production. "
+    "For your {component} layer specifically, I'd recommend starting with a careful audit "
+    "of the interface boundaries before making any structural changes. This will give you "
+    "a clear picture of the blast radius and let you sequence the migration safely."
+)
+
+_TOPICS = [
+    "distributed tracing",
+    "eventual consistency",
+    "schema migration",
+    "backpressure handling",
+    "idempotency guarantees",
+    "cache invalidation",
+    "connection pooling",
+    "rate limiting",
+    "circuit breaking",
+    "observability pipelines",
+]
+
+_CONCERNS = [
+    "concurrency model",
+    "retry semantics",
+    "state management",
+    "error propagation",
+    "latency budget",
+]
+
+_COMPONENTS = [
+    "persistence",
+    "routing",
+    "ingestion",
+    "aggregation",
+    "serialization",
+]
+
+
+def _human_content(i: int) -> str:
+    return _HUMAN_TEMPLATE.format(
+        topic=_TOPICS[i % len(_TOPICS)],
+        concern=_CONCERNS[i % len(_CONCERNS)],
+        component=_COMPONENTS[i % len(_COMPONENTS)],
+    )
+
+
+def _ai_content(i: int) -> str:
+    return _AI_TEMPLATE.format(
+        topic=_TOPICS[i % len(_TOPICS)],
+        concern=_CONCERNS[i % len(_CONCERNS)],
+        component=_COMPONENTS[i % len(_COMPONENTS)],
+    )
+
+
+# ---------------------------------------------------------------------------
+# State definitions
+# ---------------------------------------------------------------------------
+
+
+class BinaryState(TypedDict):
+    messages: Annotated[list, add_messages]
+
+
+class DeltaState(TypedDict):
+    messages: Annotated[list, DeltaChannel(add_messages)]
+
+
+def _make_delta_state(snapshot_frequency: int | float) -> type:
+    """Create a TypedDict with DeltaChannel at the given snapshot_frequency."""
+    channel = DeltaChannel(add_messages, snapshot_frequency=snapshot_frequency)
+    # Use the functional TypedDict form so the Annotated type is stored as an
+    # already-evaluated object rather than a forward-reference string (which
+    # would fail when get_type_hints tries to resolve 'snapshot_frequency').
+    return TypedDict(  # type: ignore[return-value]
+        f"DeltaState_freq{snapshot_frequency}",
+        {"messages": Annotated[list, channel]},
+    )
+
+
+# ---------------------------------------------------------------------------
+# Graph factory
+# ---------------------------------------------------------------------------
+
+
+def _make_graph(state_cls: type, checkpointer: Any = None) -> Any:
+    def human_node(state: Any) -> dict:
+        return {}
+
+    def ai_node(state: Any) -> dict:
+        i = len(state["messages"]) // 2
+        return {"messages": [AIMessage(content=_ai_content(i), id=f"a{i}")]}
+
+    g = StateGraph(state_cls)
+    g.add_node("human", human_node)
+    g.add_node("ai", ai_node)
+    g.add_edge("human", "ai")
+    g.add_edge("ai", END)
+    g.set_entry_point("human")
+    return g.compile(checkpointer=checkpointer or MemorySaver())
+
+
+# ---------------------------------------------------------------------------
+# Measurement helpers
+# ---------------------------------------------------------------------------
+
+
+def _total_blob_bytes(saver: MemorySaver) -> int:
+    total = 0
+    for (_, _, _, _), (type_tag, blob) in saver.blobs.items():
+        if blob is not None:
+            total += len(blob)
+    return total
+
+
+def _run_turns(
+    n_turns: int,
+    state_cls: type,
+    checkpointer: Any = None,
+) -> tuple[float, float, int]:
+    """Run n_turns conversation turns.
+
+    Returns (write_elapsed_s, read_elapsed_s, total_blob_bytes).
+    Read latency is the average of 5 get_state calls after the full history
+    is built — forces state rehydration including ancestor replay if needed.
+    """
+    graph = _make_graph(state_cls, checkpointer)
+    config = {"configurable": {"thread_id": "bench"}}
+
+    t0 = time.perf_counter()
+    for i in range(n_turns):
+        graph.invoke(
+            {"messages": [HumanMessage(content=_human_content(i), id=f"h{i}")]},
+            config,
+        )
+    write_elapsed = time.perf_counter() - t0
+
+    t1 = time.perf_counter()
+    for _ in range(5):
+        graph.get_state(config)
+    read_elapsed = (time.perf_counter() - t1) / 5
+
+    blob_bytes = (
+        _total_blob_bytes(graph.checkpointer)
+        if isinstance(graph.checkpointer, MemorySaver)
+        else -1
+    )
+    return write_elapsed, read_elapsed, blob_bytes
+
+
+def _fmt_bytes(n: int) -> str:
+    if n >= 1_000_000:
+        return f"{n / 1_000_000:.1f} MB"
+    if n >= 1_000:
+        return f"{n / 1_000:.1f} KB"
+    return f"{n} B"
+
+
+def _approx_tokens(n_turns: int) -> str:
+    tokens = n_turns * 200
+    if tokens >= 1_000_000:
+        return f"~{tokens / 1_000_000:.1f}M tok"
+    if tokens >= 1_000:
+        return f"~{tokens / 1_000:.0f}K tok"
+    return f"~{tokens} tok"
+
+
+# ---------------------------------------------------------------------------
+# Checkpointer factories
+# ---------------------------------------------------------------------------
+
+
+@contextlib.contextmanager
+def _pg_saver(thread_id: str = "bench"):
+    """Context manager that yields a fresh PostgresSaver and cleans up after."""
+    with PostgresSaver.from_conn_string(_POSTGRES_URI) as saver:
+        saver.setup()
+        with saver._cursor() as cur:
+            for tbl in ("checkpoints", "checkpoint_blobs", "checkpoint_writes"):
+                cur.execute(f"DELETE FROM {tbl} WHERE thread_id = %s", (thread_id,))
+        yield saver
+        with saver._cursor() as cur:
+            for tbl in ("checkpoints", "checkpoint_blobs", "checkpoint_writes"):
+                cur.execute(f"DELETE FROM {tbl} WHERE thread_id = %s", (thread_id,))
+
+
+def _checkpointers() -> list[tuple[str, Any]]:
+    """Return (label, saver_or_None) pairs for available checkpointers."""
+    result: list[tuple[str, Any]] = [("InMemory", None)]
+    if _POSTGRES_AVAILABLE:
+        try:
+            import psycopg
+
+            psycopg.connect(_POSTGRES_URI).close()
+            result.append(("Postgres", "postgres"))
+        except Exception:
+            pass
+    return result
+
+
+# ---------------------------------------------------------------------------
+# Part 1: baseline DeltaChannel(inf) vs add_messages
+# ---------------------------------------------------------------------------
+
+BASELINE_TURN_COUNTS = [10, 25, 50, 100, 500]
+DELTA_ONLY_TURN_COUNTS = [1000]
+
+
+def _run_baseline_for_checkpointer(cp_label: str, cp_hint: Any) -> None:
+    W = 72
+
+    def _make_saver():
+        if cp_hint is None:
+            return contextlib.nullcontext(None)
+        return _pg_saver()
+
+    rows: list[tuple[int, Any, Any, Any, Any, Any, Any]] = []
+    for turns in BASELINE_TURN_COUNTS:
+        with _make_saver() as saver:
+            b_wt, b_rt, b_bytes = _run_turns(turns, BinaryState, saver)
+        with _make_saver() as saver:
+            d_wt, d_rt, d_bytes = _run_turns(turns, DeltaState, saver)
+        rows.append((turns, b_bytes, d_bytes, b_rt, d_rt, b_wt, d_wt))
+    for turns in DELTA_ONLY_TURN_COUNTS:
+        with _make_saver() as saver:
+            d_wt, d_rt, d_bytes = _run_turns(turns, DeltaState, saver)
+        rows.append((turns, None, d_bytes, None, d_rt, None, d_wt))
+
+    def _bytes_or_na(v: Any) -> str:
+        if v is None or v < 0:
+            return "n/a"
+        return _fmt_bytes(v)
+
+    def _ms_or_na(v: Any) -> str:
+        return "n/a" if v is None else f"{v * 1000:.1f}ms"
+
+    print(f"\n  [{cp_label}] Storage (blob bytes)")
+    print(
+        f"  {'turns':>6}  {'ctx':>10}  {'add_msgs':>12}  {'delta(inf)':>12}  {'savings':>8}"
+    )
+    print("  " + "-" * (W - 2))
+    for turns, b_bytes, d_bytes, b_rt, d_rt, b_wt, d_wt in rows:
+        if b_bytes is None or b_bytes < 0 or d_bytes is None or d_bytes < 0:
+            ratio_str = "n/a"
+        else:
+            ratio = b_bytes / d_bytes if d_bytes else float("inf")
+            ratio_str = f"{ratio:.0f}x"
+        print(
+            f"  {turns:>6}  {_approx_tokens(turns):>10}  "
+            f"{_bytes_or_na(b_bytes):>12}  {_bytes_or_na(d_bytes):>12}  {ratio_str:>8}"
+        )
+
+    print(f"\n  [{cp_label}] Read latency (avg of 5 get_state calls)")
+    print(f"  {'turns':>6}  {'ctx':>10}  {'add_msgs':>12}  {'delta(inf)':>12}")
+    print("  " + "-" * (W - 2))
+    for turns, b_bytes, d_bytes, b_rt, d_rt, b_wt, d_wt in rows:
+        print(
+            f"  {turns:>6}  {_approx_tokens(turns):>10}  "
+            f"{_ms_or_na(b_rt):>12}  {_ms_or_na(d_rt):>12}"
+        )
+
+
+def run_baseline_benchmark() -> None:
+    print()
+    print("Part 1 — DeltaChannel(inf) vs add_messages: storage & latency")
+    print("=" * 72)
+    for cp_label, cp_hint in _checkpointers():
+        _run_baseline_for_checkpointer(cp_label, cp_hint)
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Part 2: snapshot_frequency sweep
+# ---------------------------------------------------------------------------
+
+# Frequencies to test. 1 = always snapshot (like BinOp), inf = pure delta.
+SNAPSHOT_FREQUENCIES: list[int | float] = [1, 5, 10, 50, math.inf]
+
+# Turn counts for the sweep — high enough to show storage divergence.
+SWEEP_TURN_COUNTS = [50, 100, 500]
+
+
+def _freq_label(freq: int | float) -> str:
+    if freq == math.inf:
+        return "inf"
+    return str(int(freq))
+
+
+def _run_sweep_for_checkpointer(cp_label: str, cp_hint: Any) -> None:
+    def _make_saver():
+        if cp_hint is None:
+            return contextlib.nullcontext(None)
+        return _pg_saver()
+
+    # Collect results: {turns: {freq_label: (write_s, read_s, bytes)}}
+    results: dict[int, dict[str, tuple[float, float, int]]] = {}
+    for turns in SWEEP_TURN_COUNTS:
+        results[turns] = {}
+        for freq in SNAPSHOT_FREQUENCIES:
+            state_cls = _make_delta_state(freq)
+            with _make_saver() as saver:
+                wt, rt, bb = _run_turns(turns, state_cls, saver)
+            results[turns][_freq_label(freq)] = (wt, rt, bb)
+
+    freq_labels = [_freq_label(f) for f in SNAPSHOT_FREQUENCIES]
+    col_w = 12
+
+    header = f"  {'turns':>6}  {'ctx':>10}" + "".join(
+        f"  {f'freq={freq_label}':>{col_w}}" for freq_label in freq_labels
+    )
+
+    print(f"\n  [{cp_label}] Storage (blob bytes) — lower is better")
+    print(header)
+    print("  " + "-" * (len(header) - 2))
+    for turns in SWEEP_TURN_COUNTS:
+        row = f"  {turns:>6}  {_approx_tokens(turns):>10}"
+        for label in freq_labels:
+            _, _, bb = results[turns][label]
+            row += f"  {_fmt_bytes(bb) if bb >= 0 else 'n/a':>{col_w}}"
+        print(row)
+
+    print(f"\n  [{cp_label}] Read latency (avg of 5 get_state) — lower is better")
+    print(header)
+    print("  " + "-" * (len(header) - 2))
+    for turns in SWEEP_TURN_COUNTS:
+        row = f"  {turns:>6}  {_approx_tokens(turns):>10}"
+        for label in freq_labels:
+            _, rt, _ = results[turns][label]
+            row += f"  {f'{rt * 1000:.1f}ms':>{col_w}}"
+        print(row)
+
+    print(
+        f"\n  [{cp_label}] Per-invoke write latency (total / turns) — lower is better"
+    )
+    print(header)
+    print("  " + "-" * (len(header) - 2))
+    for turns in SWEEP_TURN_COUNTS:
+        row = f"  {turns:>6}  {_approx_tokens(turns):>10}"
+        for label in freq_labels:
+            wt, _, _ = results[turns][label]
+            row += f"  {f'{(wt / turns) * 1000:.1f}ms':>{col_w}}"
+        print(row)
+
+
+def run_snapshot_freq_benchmark() -> None:
+    print()
+    print("Part 2 — DeltaChannel snapshot_frequency sweep")
+    print("Lower freq → fewer snapshots → less storage but deeper read replay")
+    print("=" * 80)
+    for cp_label, cp_hint in _checkpointers():
+        _run_sweep_for_checkpointer(cp_label, cp_hint)
+    print()
+    print("Legend:")
+    print(
+        "  freq=1    snapshot every write (full blob always — same as add_messages / BinOp)"
+    )
+    print("  freq=N    snapshot every N writes; read walks at most N ancestor writes")
+    print("  freq=inf  pure delta; read walks entire ancestor chain")
+    print()
+
+
+# ---------------------------------------------------------------------------
+# Pytest entry points
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.skip(
+    reason="slow benchmark — run manually with: python tests/test_delta_channel_benchmark.py"
+)
+def test_delta_channel_baseline_benchmark(capsys: Any) -> None:
+    """DeltaChannel(inf) uses less storage than add_messages at scale."""
+    with capsys.disabled():
+        run_baseline_benchmark()
+
+    for turns in [25, 50]:
+        _, _, b_bytes = _run_turns(turns, BinaryState)
+        _, _, d_bytes = _run_turns(turns, DeltaState)
+        assert d_bytes < b_bytes, (
+            f"DeltaChannel should use less storage at {turns} turns, "
+            f"got delta={d_bytes} binary={b_bytes}"
+        )
+
+
+@pytest.mark.skip(
+    reason="slow benchmark — run manually with: python tests/test_delta_channel_benchmark.py"
+)
+def test_snapshot_freq_benchmark(capsys: Any) -> None:
+    """snapshot_frequency trades storage for bounded read depth."""
+    with capsys.disabled():
+        run_snapshot_freq_benchmark()
+
+    # Correctness: results at all frequencies should agree on final state.
+    n_turns = 20
+    states: dict[str, list] = {}
+    for freq in SNAPSHOT_FREQUENCIES:
+        state_cls = _make_delta_state(freq)
+        graph = _make_graph(state_cls)
+        config = {"configurable": {"thread_id": "correctness"}}
+        for i in range(n_turns):
+            graph.invoke(
+                {"messages": [HumanMessage(content=_human_content(i), id=f"h{i}")]},
+                config,
+            )
+        state = graph.get_state(config)
+        states[_freq_label(freq)] = [m.id for m in state.values["messages"]]
+
+    ref = states["inf"]
+    for label, msg_ids in states.items():
+        assert msg_ids == ref, (
+            f"freq={label} produced different message IDs than freq=inf"
+        )
+
+
+# ---------------------------------------------------------------------------
+# Script entry point
+# ---------------------------------------------------------------------------
+
+if __name__ == "__main__":
+    run_baseline_benchmark()
+    run_snapshot_freq_benchmark()
+    sys.exit(0)

libs/langgraph/tests/test_delta_channel_migration.py

@@ -0,0 +1,504 @@
+"""Tests for the BinaryOperatorAggregate -> DeltaChannel migration path.
+
+A thread written under `BinaryOperatorAggregate(...)` must keep working
+after its annotation is swapped to `DeltaChannel(...)` on the same
+checkpointer — pre-migration state visible at each *settled* ancestor
+checkpoint is preserved, and post-migration writes fold on top through
+the reducer.
+
+Mechanism under test: the saver's `_get_channel_writes_history(config,
+channel)` walks the parent chain; when it encounters an ancestor whose
+`channel_values[channel]` is a real value (not `DELTA_SENTINEL`), it
+returns that as the `seed`. `DeltaChannel.from_checkpoint(seed)` uses
+it as the base value, and `replay_writes(writes)` folds on-path deltas.
+
+Scenarios covered:
+
+1. **Basic migration (sync + async)**: build pre-migration state with
+   `BinaryOperatorAggregate`, swap the annotation to `DeltaChannel` on
+   the same checkpointer, and verify that every settled pre-migration
+   super-step boundary (`next=('__start__',)`) round-trips exactly
+   under the delta-channel view.
+2. **Time travel into a pre-migration checkpoint** after migration —
+   `graph.get_state(pre_migration_config)` at a settled ancestor
+   returns the same state as under the binop channel.
+3. **Continuing a migrated thread**: driving one more super-step after
+   migration produces a state that includes the pre-migration settled
+   prefix plus the new delta write — proving `from_checkpoint(seed)` +
+   `replay_writes` correctly fold post-migration deltas onto the
+   pre-migration seed.
+4. **Base-saver fallback path**: a third-party-style subclass that
+   removes the optimized `InMemorySaver` override and falls back to
+   `BaseCheckpointSaver._get_channel_writes_history` must produce the
+   same result as the optimized path.
+5. **Channel-type isolation across threads**: two threads on the same
+   checkpointer under the delta-channel graph — one freshly-started,
+   one migrated from pre-migration state — don't cross-contaminate.
+   The parent-chain walk is scoped to the thread.
+
+TODO: add postgres variants in the existing `libs/checkpoint-postgres`
+test files (different fixture setup; not this file).
+"""
+
+from __future__ import annotations
+
+import operator
+from typing import Annotated, Any
+
+import pytest
+from langgraph.checkpoint.memory import InMemorySaver
+from typing_extensions import TypedDict
+
+from langgraph.channels.binop import BinaryOperatorAggregate
+from langgraph.channels.delta import DeltaChannel
+from langgraph.graph import END, START, StateGraph
+
+pytestmark = pytest.mark.anyio
+
+
+# ---------------------------------------------------------------------------
+# Graph factories
+#
+# A minimal reducer (`operator.add` on lists of str) with a noop node keeps
+# state change localized to the HumanMessage-like payload passed through
+# `invoke`. That isolates the pre/post-migration parity assertions to
+# channel-hydration semantics.
+# ---------------------------------------------------------------------------
+
+
+def _noop(_state: Any) -> dict:
+    return {}
+
+
+def _binop_graph(checkpointer: Any) -> Any:
+    class BinopState(TypedDict):
+        items: Annotated[list, BinaryOperatorAggregate(list, operator.add)]
+
+    return (
+        StateGraph(BinopState)
+        .add_node("noop", _noop)
+        .add_edge(START, "noop")
+        .add_edge("noop", END)
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _delta_graph(checkpointer: Any) -> Any:
+    class DeltaState(TypedDict):
+        items: Annotated[list, DeltaChannel(operator.add)]
+
+    return (
+        StateGraph(DeltaState)
+        .add_node("noop", _noop)
+        .add_edge(START, "noop")
+        .add_edge("noop", END)
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _drive(graph: Any, config: dict, tag: str, n: int) -> None:
+    for i in range(n):
+        graph.invoke({"items": [f"{tag}{i}"]}, config)
+
+
+async def _adrive(graph: Any, config: dict, tag: str, n: int) -> None:
+    for i in range(n):
+        await graph.ainvoke({"items": [f"{tag}{i}"]}, config)
+
+
+def _settled_boundaries(history: list) -> list[tuple[dict, list]]:
+    """Return `[(config, items), ...]` for every checkpoint in `history`
+    whose `next == ('__start__',)` — the stable boundaries between invokes.
+    """
+    return [
+        (s.config, list(s.values.get("items", [])))
+        for s in history
+        if s.next == ("__start__",)
+    ]
+
+
+# ---------------------------------------------------------------------------
+# 1. Basic migration (sync + async)
+# ---------------------------------------------------------------------------
+
+
+def test_basic_migration_preserves_pre_migration_state() -> None:
+    """Build state under `BinaryOperatorAggregate`, migrate to
+    `DeltaChannel` on the same checkpointer, and verify that every
+    settled pre-migration super-step boundary round-trips exactly.
+
+    Settled boundaries (`next=('__start__',)`) are the stable hydration
+    targets for the migration path: writes that produced the NEXT
+    super-step are kept as `pending_writes` on the ancestor, so walking
+    from a descendant finds the ancestor's blob as the seed and
+    reconstructs the correct state.
+    """
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "basic-sync"}}
+
+    # Pre-migration: accumulate items across 3 invokes.
+    binop = _binop_graph(checkpointer)
+    _drive(binop, config, "u", 3)
+
+    pre_boundaries = _settled_boundaries(list(binop.get_state_history(config)))
+    assert len(pre_boundaries) >= 2, "expected multiple settled boundaries"
+
+    # Migrate: swap the annotation on the same checkpointer.
+    delta = _delta_graph(checkpointer)
+
+    for cfg, items in pre_boundaries:
+        snap = delta.get_state(cfg)
+        assert list(snap.values.get("items", [])) == items, (
+            f"snapshot mismatch at {cfg['configurable']['checkpoint_id']}: "
+            f"expected {items}, got {snap.values.get('items', [])}"
+        )
+
+
+async def test_basic_migration_preserves_pre_migration_state_async() -> None:
+    """Async variant of the basic migration scenario."""
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "basic-async"}}
+
+    binop = _binop_graph(checkpointer)
+    await _adrive(binop, config, "u", 3)
+
+    pre_history = [s async for s in binop.aget_state_history(config)]
+    pre_boundaries = _settled_boundaries(pre_history)
+    assert len(pre_boundaries) >= 2
+
+    delta = _delta_graph(checkpointer)
+
+    for cfg, items in pre_boundaries:
+        snap = await delta.aget_state(cfg)
+        assert list(snap.values.get("items", [])) == items, (
+            f"async snapshot mismatch at {cfg['configurable']['checkpoint_id']}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# 2. Time travel into a pre-migration checkpoint after migration
+# ---------------------------------------------------------------------------
+
+
+def test_time_travel_into_pre_migration_checkpoint() -> None:
+    """After migration, `graph.get_state(pre_migration_config)` at a
+    settled ancestor returns the state as stored at that point."""
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "time-travel"}}
+
+    binop = _binop_graph(checkpointer)
+    _drive(binop, config, "u", 3)
+
+    pre_boundaries = _settled_boundaries(list(binop.get_state_history(config)))
+    assert pre_boundaries, "no settled ancestors to time-travel to"
+
+    delta = _delta_graph(checkpointer)
+
+    # Pick the oldest non-empty boundary — a long distance to walk back.
+    non_empty = [(cfg, items) for cfg, items in pre_boundaries if items]
+    assert non_empty, "expected at least one non-empty boundary"
+    target_cfg, expected_items = non_empty[-1]
+
+    snap = delta.get_state(target_cfg)
+    assert list(snap.values.get("items", [])) == expected_items
+
+
+# ---------------------------------------------------------------------------
+# 3. Continuing a migrated thread: deltas fold onto pre-migration seed
+# ---------------------------------------------------------------------------
+
+
+def test_continuing_migrated_thread_folds_deltas_on_seed() -> None:
+    """Resume a pre-migration settled ancestor via `invoke(None, cfg)`
+    under the delta-channel graph. Since the pre-migration checkpoint
+    has an existing `pending_writes` entry (the input for the NEXT
+    super-step), re-running from that ancestor reproduces the same
+    post-ancestor state as the original binop run.
+
+    This proves the seed-terminator + write-replay pipeline works
+    end-to-end across the migration boundary.
+    """
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "continue"}}
+
+    binop = _binop_graph(checkpointer)
+    _drive(binop, config, "u", 2)
+
+    # Pick the oldest settled boundary with non-empty state.
+    pre_boundaries = _settled_boundaries(list(binop.get_state_history(config)))
+    target_cfg, seed_items = next(
+        (cfg, items) for cfg, items in reversed(pre_boundaries) if items
+    )
+    assert seed_items, "need a non-empty seed boundary"
+
+    # Migrate and resume from the pre-migration ancestor. `invoke(None,
+    # cfg)` replays the pending writes staged at `cfg` under the new
+    # channel; the reducer folds those deltas onto the seed.
+    delta = _delta_graph(checkpointer)
+    result = delta.invoke(None, target_cfg)
+
+    # The resumed state must include the pre-migration seed items in order.
+    result_items = list(result.get("items", []))
+    for idx, prefix_item in enumerate(seed_items):
+        assert result_items[idx] == prefix_item, (
+            f"pre-migration seed item at {idx} not preserved: "
+            f"got {result_items[: idx + 1]}, expected {seed_items}"
+        )
+
+
+# ---------------------------------------------------------------------------
+# 4. Base-saver fallback path
+# ---------------------------------------------------------------------------
+
+
+class _ThirdPartyStyleSaver(InMemorySaver):
+    """Simulates a third-party saver that inherits the reference
+    `_get_channel_writes_history` implementation from
+    `BaseCheckpointSaver` rather than overriding it.
+
+    We rebind the two methods to the base-class versions (via MRO) so
+    the fallback path is exercised even though the storage layer is
+    still the in-memory one.
+    """
+
+    # MRO: [_ThirdPartyStyleSaver, InMemorySaver, BaseCheckpointSaver, ...]
+    _get_channel_writes_history = (  # type: ignore[assignment]
+        InMemorySaver.__mro__[1]._get_channel_writes_history  # type: ignore[attr-defined]
+    )
+    _aget_channel_writes_history = (  # type: ignore[assignment]
+        InMemorySaver.__mro__[1]._aget_channel_writes_history  # type: ignore[attr-defined]
+    )
+
+
+def test_base_saver_fallback_matches_optimized_override() -> None:
+    """The reference `BaseCheckpointSaver` implementation must produce
+    the same migration behavior as the optimized `InMemorySaver`
+    override. We drive the same migration scenario through both savers
+    and assert per-snapshot parity in the delta-channel view."""
+
+    # Fast path: optimized InMemorySaver override.
+    fast_saver = InMemorySaver()
+    fast_config = {"configurable": {"thread_id": "fast"}}
+    fast_binop = _binop_graph(fast_saver)
+    _drive(fast_binop, fast_config, "u", 3)
+    fast_delta = _delta_graph(fast_saver)
+    fast_history = [
+        (s.next, list(s.values.get("items", [])))
+        for s in fast_delta.get_state_history(fast_config)
+    ]
+
+    # Slow path: base-class fallback.
+    slow_saver = _ThirdPartyStyleSaver()
+    slow_config = {"configurable": {"thread_id": "slow"}}
+    slow_binop = _binop_graph(slow_saver)
+    _drive(slow_binop, slow_config, "u", 3)
+    slow_delta = _delta_graph(slow_saver)
+    slow_history = [
+        (s.next, list(s.values.get("items", [])))
+        for s in slow_delta.get_state_history(slow_config)
+    ]
+
+    assert slow_history == fast_history, (
+        "base-saver fallback should match optimized-override behavior; "
+        f"fast={fast_history}, slow={slow_history}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# 5. Thread isolation under mixed-generation storage
+# ---------------------------------------------------------------------------
+
+
+def test_delta_and_migrated_threads_do_not_cross_contaminate() -> None:
+    """Two threads sharing a checkpointer — one migrated from
+    pre-migration state, one freshly-started under DeltaChannel — must
+    maintain independent state. The parent-chain walk in
+    `_get_channel_writes_history` must be scoped to the target thread.
+    """
+
+    checkpointer = InMemorySaver()
+    migrated_cfg = {"configurable": {"thread_id": "migrated"}}
+    fresh_cfg = {"configurable": {"thread_id": "fresh"}}
+
+    # Thread A: pre-migration build-up.
+    binop = _binop_graph(checkpointer)
+    _drive(binop, migrated_cfg, "m", 2)
+
+    # Thread B: fresh delta-channel run.
+    delta = _delta_graph(checkpointer)
+    _drive(delta, fresh_cfg, "f", 2)
+
+    # Thread A: migrate and confirm its state is anchored in its own
+    # thread's pre-migration history (tag 'm'), never mixing in tag 'f'.
+    migrated_boundaries = _settled_boundaries(
+        list(delta.get_state_history(migrated_cfg))
+    )
+    assert migrated_boundaries, "migrated thread has no settled boundaries"
+    for _, items in migrated_boundaries:
+        for it in items:
+            assert it.startswith("m"), (
+                f"migrated thread leaked item from other thread: {it}"
+            )
+
+    # Thread B: settled boundaries must only contain 'f' tags.
+    fresh_boundaries = _settled_boundaries(list(delta.get_state_history(fresh_cfg)))
+    assert fresh_boundaries, "fresh thread has no settled boundaries"
+    for _, items in fresh_boundaries:
+        for it in items:
+            assert it.startswith("f"), (
+                f"fresh thread leaked item from migrated thread: {it}"
+            )
+
+
+# ---------------------------------------------------------------------------
+# 6. Tip-of-pre-migration hydration: the latest checkpoint from a binop-run
+# thread has a real accumulated value in its own `channel_values["items"]`.
+# When hydrated under the delta-channel graph via `get_state(config)` with no
+# `checkpoint_id`, the short-circuit must use that value directly instead of
+# walking ancestors (which would skip the tip's own blob).
+# ---------------------------------------------------------------------------
+
+
+def test_tip_of_pre_migration_hydrates_directly() -> None:
+    """`graph.get_state(config)` at the latest (pre-migration) checkpoint
+    returns the full accumulated list stored in that checkpoint's own
+    `channel_values`. The hydration must not walk ancestors past it."""
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "tip-sync"}}
+
+    binop = _binop_graph(checkpointer)
+    _drive(binop, config, "u", 3)
+
+    binop_tip = binop.get_state(config)
+    expected_items = list(binop_tip.values.get("items", []))
+    assert expected_items == ["u0", "u1", "u2"], (
+        f"sanity: pre-migration tip should accumulate all 3 items, got {expected_items}"
+    )
+
+    delta = _delta_graph(checkpointer)
+
+    snap = delta.get_state(config)
+    assert list(snap.values.get("items", [])) == expected_items, (
+        f"tip hydration mismatch: expected {expected_items}, "
+        f"got {snap.values.get('items', [])}"
+    )
+
+
+async def test_tip_of_pre_migration_hydrates_directly_async() -> None:
+    """Async variant of the tip-of-pre-migration hydration scenario."""
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "tip-async"}}
+
+    binop = _binop_graph(checkpointer)
+    await _adrive(binop, config, "u", 3)
+
+    binop_tip = await binop.aget_state(config)
+    expected_items = list(binop_tip.values.get("items", []))
+    assert expected_items == ["u0", "u1", "u2"]
+
+    delta = _delta_graph(checkpointer)
+
+    snap = await delta.aget_state(config)
+    assert list(snap.values.get("items", [])) == expected_items, (
+        f"async tip hydration mismatch: expected {expected_items}, "
+        f"got {snap.values.get('items', [])}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# 7. `update_state` after migration writes a real value to the new
+# checkpoint's `channel_values` (not a sentinel). Hydration must use it
+# directly — the ancestor walk would skip this blob and return stale state.
+# ---------------------------------------------------------------------------
+
+
+def test_update_state_after_migration_uses_written_value() -> None:
+    """After migrating and running at least one post-migration super-step
+    (so the thread's tip has a `DELTA_SENTINEL`), `update_state` writes a
+    concrete value to a new checkpoint's `channel_values`. `get_state`
+    must reflect that concrete value."""
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "update-state"}}
+
+    # Pre-migration: accumulate a little state.
+    binop = _binop_graph(checkpointer)
+    _drive(binop, config, "u", 2)
+
+    # Migrate and run one more super-step so the tip is a post-migration
+    # checkpoint with `DELTA_SENTINEL` in its own `channel_values`.
+    delta = _delta_graph(checkpointer)
+    delta.invoke({"items": ["post"]}, config)
+
+    # `update_state` writes a concrete value into a new checkpoint's blob
+    # via the reducer against the hydrated prior state.
+    delta.update_state(config, {"items": ["x", "y"]})
+
+    snap = delta.get_state(config)
+    updated_items = list(snap.values.get("items", []))
+    # Must include the "x","y" update; without the hydration fix, the
+    # update_state-written blob would be skipped in favor of an ancestor
+    # walk, and the update values would disappear.
+    assert "x" in updated_items and "y" in updated_items, (
+        f"update_state values missing from snapshot: {updated_items}"
+    )
+    # The "x","y" items should be folded onto the prior accumulated state,
+    # not stand alone. This verifies the update-written blob is used
+    # directly by `get_state` (no ancestor walk past it).
+    assert len(updated_items) >= 4, (
+        f"update_state snapshot should preserve pre-update state, got {updated_items}"
+    )
+    assert updated_items[-2:] == ["x", "y"], (
+        f"update_state deltas should be at the tail, got {updated_items}"
+    )
+
+
+# ---------------------------------------------------------------------------
+# 8. Fork from an `update_state` checkpoint: a new run branched off the
+# update_state-produced checkpoint must see that checkpoint's concrete
+# `channel_values` as its base, with new deltas folded on top.
+# ---------------------------------------------------------------------------
+
+
+def test_fork_from_update_state_checkpoint() -> None:
+    """Branching a new run from the checkpoint produced by `update_state`
+    must use that checkpoint's concrete blob as the base. Additional
+    deltas from the forked run fold onto it through the reducer."""
+
+    checkpointer = InMemorySaver()
+    config = {"configurable": {"thread_id": "fork"}}
+
+    # Pre-migration build-up, then migrate and add one post-migration step.
+    binop = _binop_graph(checkpointer)
+    _drive(binop, config, "u", 2)
+    delta = _delta_graph(checkpointer)
+    delta.invoke({"items": ["post"]}, config)
+
+    # Apply `update_state` and capture the returned config (references
+    # the new checkpoint produced by the update).
+    update_cfg = delta.update_state(config, {"items": ["x", "y"]})
+
+    update_snap = delta.get_state(update_cfg)
+    base_items = list(update_snap.values.get("items", []))
+    assert "x" in base_items and "y" in base_items, (
+        f"update_state values missing from snapshot: {base_items}"
+    )
+    assert base_items[-2:] == ["x", "y"], (
+        f"sanity: update_state deltas should be at the tail, got {base_items}"
+    )
+
+    # Fork: invoke from the update_state checkpoint with a new delta.
+    forked = delta.invoke({"items": ["fork0"]}, update_cfg)
+    forked_items = list(forked.get("items", []))
+    # The fork must see the update_state-written blob as its base (not
+    # walk past it), and the new delta must fold on top of it.
+    assert forked_items[: len(base_items)] == base_items, (
+        f"fork lost update_state base: base={base_items}, forked={forked_items}"
+    )
+    assert forked_items[-1] == "fork0", f"fork delta not appended: {forked_items}"

libs/langgraph/tests/test_graph_callbacks.py

@@ -275,3 +275,70 @@ def test_graph_callbacks_accept_base_callback_manager() -> None:
 
     assert "__interrupt__" in first
     assert len(graph_handler.interrupt_events) == 1
+
+
+def test_non_graph_handler_via_add_handler_does_not_crash() -> None:
+    """Non-GraphCallbackHandler added via add_handler should not raise.
+
+    Libraries like opentelemetry-instrumentation-langchain monkey-patch
+    BaseCallbackManager.__init__ and inject handlers via add_handler().
+    These handlers inherit from BaseCallbackHandler, not
+    GraphCallbackHandler. They must be silently accepted — graph lifecycle
+    events will simply not be dispatched to them.
+    """
+    from langgraph.callbacks import _GraphCallbackManager
+
+    manager = _GraphCallbackManager()
+    plain_handler = _LangChainCustomEventHandler()
+
+    manager.add_handler(plain_handler, inherit=True)
+    assert plain_handler in manager.handlers
+
+
+def test_non_graph_handler_does_not_receive_lifecycle_events() -> None:
+    """Non-GraphCallbackHandler added alongside a GraphCallbackHandler
+    should not interfere with lifecycle event dispatch."""
+    graph = _build_interrupt_graph()
+    graph_handler = _GraphEventHandler()
+    plain_handler = _LangChainCustomEventHandler()
+
+    config = {
+        "configurable": {"thread_id": "graph-callback-mixed-handlers"},
+        "callbacks": [plain_handler, graph_handler],
+    }
+
+    first = graph.invoke({"answer": None}, config)
+    assert "__interrupt__" in first
+
+    assert len(graph_handler.interrupt_events) == 1
+    assert plain_handler.events == []
+
+    resumed = graph.invoke(Command(resume="done"), config)
+    assert resumed == {"answer": "done"}
+    assert len(graph_handler.resume_events) == 1
+    assert plain_handler.events == []
+
+
+@pytest.mark.anyio
+@NEEDS_CONTEXTVARS
+async def test_non_graph_handler_does_not_receive_lifecycle_events_async() -> None:
+    """Async variant: non-GraphCallbackHandler should not interfere."""
+    graph = _build_interrupt_graph()
+    graph_handler = _GraphEventHandler()
+    plain_handler = _LangChainCustomEventHandler()
+
+    config = {
+        "configurable": {"thread_id": "graph-callback-mixed-handlers-async"},
+        "callbacks": [plain_handler, graph_handler],
+    }
+
+    first = await graph.ainvoke({"answer": None}, config)
+    assert "__interrupt__" in first
+
+    assert len(graph_handler.interrupt_events) == 1
+    assert plain_handler.events == []
+
+    resumed = await graph.ainvoke(Command(resume="done"), config)
+    assert resumed == {"answer": "done"}
+    assert len(graph_handler.resume_events) == 1
+    assert plain_handler.events == []

libs/langgraph/tests/test_pregel.py

@@ -41,6 +41,7 @@ from typing_extensions import NotRequired, TypedDict
 
 from langgraph._internal._constants import CONFIG_KEY_NODE_FINISHED, ERROR, PULL
 from langgraph.channels.binop import BinaryOperatorAggregate
+from langgraph.channels.delta import DeltaChannel
 from langgraph.channels.ephemeral_value import EphemeralValue
 from langgraph.channels.last_value import LastValue
 from langgraph.channels.topic import Topic
@@ -615,8 +616,11 @@ def test_run_from_checkpoint_id_retains_previous_writes(
         )
     ]
 
-    assert len(new_history) == len(history) + 1
-    for original, new in zip(history, new_history[1:]):
+    # +2: one fork checkpoint from time travel, one from the new execution
+    assert len(new_history) == len(history) + 2
+    # new_history[0] is the new execution result, new_history[1] is the fork
+    assert new_history[1].metadata["source"] == "fork"
+    for original, new in zip(history, new_history[2:]):
         assert original.values == new.values
         assert original.next == new.next
         assert original.metadata["step"] == new.metadata["step"]
@@ -624,7 +628,7 @@ def test_run_from_checkpoint_id_retains_previous_writes(
     def _get_tasks(hist: list, start: int):
         return [h.tasks for h in hist[start:]]
 
-    assert _get_tasks(new_history, 1) == _get_tasks(history, 0)
+    assert _get_tasks(new_history, 2) == _get_tasks(history, 0)
 
 
 def test_batch_two_processes_in_out() -> None:
@@ -9397,3 +9401,273 @@ def test_fork_does_not_apply_pending_writes(
 
     # Should be: 1 (input) + 20 (forked node_a) + 100 (node_b) = 121
     assert result == {"value": 121}
+
+
+async def test_delta_channel_end_to_end_inmemory() -> None:
+    """Full graph run: DeltaChannel accumulates correctly across multiple turns."""
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    def respond(state: State) -> dict:
+        n = len(state["messages"])
+        return {"messages": [AIMessage(content=f"reply-{n}", id=f"ai-{n}")]}
+
+    builder = StateGraph(State)
+    builder.add_node("respond", respond)
+    builder.add_edge(START, "respond")
+    graph = builder.compile(checkpointer=InMemorySaver())
+
+    config = {"configurable": {"thread_id": "diff-test-1"}}
+
+    # Turn 1
+    graph.invoke({"messages": [HumanMessage(content="hello", id="h1")]}, config)
+    # Turn 2
+    graph.invoke({"messages": [HumanMessage(content="world", id="h2")]}, config)
+    # Turn 3
+    graph.invoke({"messages": [HumanMessage(content="bye", id="h3")]}, config)
+
+    state = graph.get_state(config)
+    msgs = state.values["messages"]
+    # 3 human + 3 AI = 6 total
+    assert len(msgs) == 6, f"expected 6 messages, got {len(msgs)}: {msgs}"
+    assert msgs[0].content == "hello"
+    assert msgs[2].content == "world"
+    assert msgs[4].content == "bye"
+    assert msgs[1].content == "reply-1"
+    assert msgs[3].content == "reply-3"
+    assert msgs[5].content == "reply-5"
+
+
+async def test_delta_channel_time_travel() -> None:
+    """Time-travel back to turn-1 checkpoint and resume; continuation must not include turn-2 deltas."""
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    counter = {"n": 0}
+
+    def respond(state: State) -> dict:
+        counter["n"] += 1
+        return {
+            "messages": [
+                AIMessage(content=f"ai-{counter['n']}", id=f"ai-{counter['n']}")
+            ]
+        }
+
+    builder = StateGraph(State)
+    builder.add_node("respond", respond)
+    builder.add_edge(START, "respond")
+    saver = InMemorySaver()
+    graph = builder.compile(checkpointer=saver)
+
+    config = {"configurable": {"thread_id": "diff-time-travel"}}
+
+    # Run 2 turns: h1→ai-1, h2→ai-2
+    graph.invoke({"messages": [HumanMessage(content="h1", id="h1")]}, config)
+    graph.invoke({"messages": [HumanMessage(content="h2", id="h2")]}, config)
+
+    # Find the checkpoint after turn 1 (2 messages: h1 + ai-1)
+    history = list(graph.get_state_history(config))
+    after_turn1 = next(h for h in history if len(h.values.get("messages", [])) == 2)
+
+    assert len(after_turn1.values["messages"]) == 2
+    assert after_turn1.values["messages"][0].content == "h1"
+    assert after_turn1.values["messages"][1].content == "ai-1"
+
+    # Resume from turn-1 checkpoint: inject h3, expect 3 messages total (h1, ai-1, ai-N)
+    # NOT 5 messages (turn-2 deltas must not bleed into the resumed run)
+    result = graph.invoke(
+        {"messages": [HumanMessage(content="h3", id="h3")]},
+        after_turn1.config,
+    )
+    msgs = result["messages"]
+    # Should be: h1, ai-1, h3, ai-N — 4 messages total
+    assert len(msgs) == 4, (
+        f"expected 4 messages after time-travel resume, got {len(msgs)}: {msgs}"
+    )
+    assert msgs[0].content == "h1"
+    assert msgs[1].content == "ai-1"
+    assert msgs[2].content == "h3"
+
+
+async def test_delta_channel_remove_message_end_to_end() -> None:
+    """RemoveMessage inside a DeltaChannel graph must persist and reload correctly."""
+    from langchain_core.messages import AIMessage, HumanMessage, RemoveMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    def respond(state: State) -> dict:
+        return {"messages": [AIMessage(content="reply", id="ai-1")]}
+
+    def delete_first(state: State) -> dict:
+        # removes the first message
+        return {"messages": [RemoveMessage(id=state["messages"][0].id)]}
+
+    builder = StateGraph(State)
+    builder.add_node("respond", respond)
+    builder.add_node("delete_first", delete_first)
+    builder.add_edge(START, "respond")
+    builder.add_edge("respond", "delete_first")
+    graph = builder.compile(checkpointer=InMemorySaver())
+
+    config = {"configurable": {"thread_id": "diff-remove-test"}}
+    graph.invoke({"messages": [HumanMessage(content="hello", id="h1")]}, config)
+
+    state = graph.get_state(config)
+    msgs = state.values["messages"]
+    # h1 was removed, only ai-1 should remain
+    assert len(msgs) == 1, f"expected 1 message, got {len(msgs)}: {msgs}"
+    assert msgs[0].id == "ai-1"
+
+    # A subsequent turn must reconstruct from the checkpoint correctly
+    graph.invoke({"messages": [HumanMessage(content="again", id="h2")]}, config)
+    state = graph.get_state(config)
+    msgs = state.values["messages"]
+    # ai-1 + h2 + ai-1(second reply, same id overwrites) + h2 removed
+    # more simply: after second run we expect ai-1 updated + h2 remaining minus deleted h2
+    # just assert h1 is still gone
+    assert all(m.id != "h1" for m in msgs), (
+        "h1 should still be absent after second turn"
+    )
+
+
+async def test_delta_channel_update_by_id_end_to_end() -> None:
+    """Updating a message by ID via DeltaChannel must persist and reload correctly."""
+    from langchain_core.messages import HumanMessage
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    def update_msg(state: State) -> dict:
+        # re-send h1 with updated content
+        return {"messages": [HumanMessage(content="updated", id="h1")]}
+
+    builder = StateGraph(State)
+    builder.add_node("update_msg", update_msg)
+    builder.add_edge(START, "update_msg")
+    graph = builder.compile(checkpointer=InMemorySaver())
+
+    config = {"configurable": {"thread_id": "diff-update-id-test"}}
+    graph.invoke({"messages": [HumanMessage(content="original", id="h1")]}, config)
+
+    state = graph.get_state(config)
+    msgs = state.values["messages"]
+    assert len(msgs) == 1, f"expected 1 message, got {len(msgs)}: {msgs}"
+    assert msgs[0].content == "updated"
+    assert msgs[0].id == "h1"
+
+    # Second turn: verify the updated state is the base for further accumulation
+    graph.invoke({"messages": [HumanMessage(content="new", id="h2")]}, config)
+    state = graph.get_state(config)
+    msgs = state.values["messages"]
+    ids = [m.id for m in msgs]
+    assert "h1" in ids  # h1 persists (updated, not duplicated)
+    assert "h2" in ids
+    assert ids.count("h1") == 1, "h1 must not be duplicated"
+
+
+async def test_delta_channel_write_flushed_before_put() -> None:
+    """checkpoint_writes are flushed synchronously before put when DELTA_SENTINEL
+    is present, ensuring writes are durable before the sentinel blob is committed.
+
+    We verify this by intercepting put_writes and put calls and confirming
+    put_writes always completes before put is called for sentinel checkpoints.
+    """
+    import threading
+    from typing import Annotated
+
+    from langchain_core.messages import AIMessage, HumanMessage
+    from langgraph.checkpoint.base import DELTA_SENTINEL
+    from langgraph.checkpoint.memory import InMemorySaver
+
+    from langgraph.graph import START, StateGraph
+    from langgraph.graph.message import add_messages
+
+    class State(TypedDict):
+        messages: Annotated[list, DeltaChannel(add_messages)]
+
+    def respond(state: State) -> dict:
+        i = len(state["messages"])
+        return {"messages": [AIMessage(content=f"r{i}", id=f"ai{i}")]}
+
+    order: list[str] = []
+    lock = threading.Lock()
+    original_put_writes = InMemorySaver.put_writes
+    original_put = InMemorySaver.put
+
+    def tracked_put_writes(self, config, writes, task_id, task_path=""):
+        result = original_put_writes(self, config, writes, task_id, task_path)
+        with lock:
+            order.append("put_writes")
+        return result
+
+    def tracked_put(self, config, checkpoint, metadata, new_versions):
+        # Check if this checkpoint has any DELTA_SENTINEL blobs
+        has_sentinel = any(
+            v is DELTA_SENTINEL for v in checkpoint.get("channel_values", {}).values()
+        )
+        if has_sentinel:
+            with lock:
+                order.append("put_sentinel")
+        else:
+            with lock:
+                order.append("put_snapshot")
+        return original_put(self, config, checkpoint, metadata, new_versions)
+
+    InMemorySaver.put_writes = tracked_put_writes
+    InMemorySaver.put = tracked_put
+    try:
+        builder = StateGraph(State)
+        builder.add_node("respond", respond)
+        builder.add_edge(START, "respond")
+        saver = InMemorySaver()
+        graph = builder.compile(checkpointer=saver)
+        config = {"configurable": {"thread_id": "flush-test"}}
+
+        for i in range(3):
+            graph.invoke(
+                {"messages": [HumanMessage(content=f"h{i}", id=f"h{i}")]}, config
+            )
+
+        # For every sentinel put, all preceding put_writes must already be in order
+        for i, event in enumerate(order):
+            if event == "put_sentinel":
+                # All put_writes before this index must appear before this sentinel
+                preceding = order[:i]
+                assert "put_writes" in preceding, (
+                    f"put_sentinel at index {i} had no preceding put_writes: {order}"
+                )
+                # And the most recent put_writes must come before this sentinel
+                last_write_idx = max(
+                    j for j, e in enumerate(order[:i]) if e == "put_writes"
+                )
+                assert last_write_idx < i, (
+                    f"put_writes at {last_write_idx} not before put_sentinel at {i}"
+                )
+    finally:
+        InMemorySaver.put_writes = original_put_writes
+        InMemorySaver.put = original_put
+
+    # Final state must still be correct
+    state = graph.get_state(config)
+    assert len(state.values["messages"]) == 6  # 3 human + 3 AI

libs/langgraph/tests/test_pregel_async.py

@@ -2086,8 +2086,11 @@ async def test_run_from_checkpoint_id_retains_previous_writes(
         )
     ]
 
-    assert len(new_history) == len(history) + 1
-    for original, new in zip(history, new_history[1:]):
+    # +2: one fork checkpoint from time travel, one from the new execution
+    assert len(new_history) == len(history) + 2
+    # new_history[0] is the new execution result, new_history[1] is the fork
+    assert new_history[1].metadata["source"] == "fork"
+    for original, new in zip(history, new_history[2:]):
         assert original.values == new.values
         assert original.next == new.next
         assert original.metadata["step"] == new.metadata["step"]
@@ -2095,7 +2098,7 @@ async def test_run_from_checkpoint_id_retains_previous_writes(
     def _get_tasks(hist: list, start: int):
         return [h.tasks for h in hist[start:]]
 
-    assert _get_tasks(new_history, 1) == _get_tasks(history, 0)
+    assert _get_tasks(new_history, 2) == _get_tasks(history, 0)
 
 
 async def test_cond_edge_after_send() -> None:

libs/langgraph/tests/test_stream_subgraph_transformer.py

@@ -1,628 +0,0 @@
-"""Tests for subgraph lifecycle events and the SubgraphTransformer."""
-
-from __future__ import annotations
-
-import operator
-import time
-from typing import Annotated, Any
-
-import pytest
-from langgraph.checkpoint.memory import InMemorySaver
-from typing_extensions import TypedDict
-
-from langgraph.constants import END, START
-from langgraph.errors import GraphInterrupt
-from langgraph.graph import StateGraph
-from langgraph.stream._event_log import EventLog
-from langgraph.stream._mux import StreamMux
-from langgraph.stream._types import ProtocolEvent
-from langgraph.stream.transformers import (
-    MessagesTransformer,
-    SubgraphRunStream,
-    SubgraphTransformer,
-    ToolLifecycleTransformer,
-    ValuesTransformer,
-)
-from langgraph.types import interrupt
-
-TS = int(time.time() * 1000)
-
-
-def _lifecycle(
-    event: str,
-    *,
-    namespace: list[str] | None = None,
-    graph_name: str | None = None,
-    cause: dict[str, Any] | None = None,
-    error: str | None = None,
-) -> ProtocolEvent:
-    data: dict[str, Any] = {"event": event}
-    if graph_name is not None:
-        data["graph_name"] = graph_name
-    if cause is not None:
-        data["cause"] = cause
-    if error is not None:
-        data["error"] = error
-    return {
-        "type": "event",
-        "method": "lifecycle",
-        "params": {
-            "namespace": namespace or [],
-            "timestamp": TS,
-            "data": data,
-        },
-    }
-
-
-def _values(payload: dict[str, Any], *, namespace: list[str]) -> ProtocolEvent:
-    return {
-        "type": "event",
-        "method": "values",
-        "params": {
-            "namespace": namespace,
-            "timestamp": TS,
-            "data": payload,
-        },
-    }
-
-
-def _subscribe(log: EventLog) -> None:
-    """Flip `_subscribed = True` so pushes retain items for test inspection."""
-    log._subscribed = True
-
-
-# ---------------------------------------------------------------------------
-# Unit tests: feed events directly into the transformer
-# ---------------------------------------------------------------------------
-
-
-_FACTORIES = [
-    ValuesTransformer,
-    ToolLifecycleTransformer,
-    MessagesTransformer,
-    SubgraphTransformer,
-]
-
-
-def _handle_values_items(handle: SubgraphRunStream) -> list:
-    return list(handle._mux.extensions["values"]._items)  # type: ignore[attr-defined]
-
-
-def _handle_subgraphs_items(handle: SubgraphRunStream) -> list:
-    return list(handle._mux.extensions["subgraphs"]._items)  # type: ignore[attr-defined]
-
-
-def _pre_subscribe_handle(handle: SubgraphRunStream) -> None:
-    """Flip `_subscribed` on every EventLog inside the handle's mini-mux.
-
-    The mini-mux is built via `make_child` with the full factory list,
-    so values / messages / subgraphs logs all exist as projections.
-    Tests that feed events directly need them subscribed so pushes
-    retain items in the deque for `_items` inspection.
-    """
-    for value in handle._mux.extensions.values():
-        if isinstance(value, EventLog):
-            _subscribe(value)
-
-
-class TestSubgraphTransformerUnit:
-    def _mux(self) -> tuple[StreamMux, SubgraphTransformer]:
-        mux = StreamMux(factories=_FACTORIES, is_async=False)
-        transformer = mux.transformer_by_key("subgraphs")
-        assert isinstance(transformer, SubgraphTransformer)
-        _subscribe(transformer._root_log)
-        return mux, transformer
-
-    def _handle(self, transformer: SubgraphTransformer) -> SubgraphRunStream:
-        """Return the single root handle after pushing one lifecycle started."""
-        (handle,) = list(transformer._root_log._items)
-        return handle
-
-    def test_root_started_is_ignored(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", graph_name="root"))
-        assert list(transformer._root_log._items) == []
-        assert transformer._by_ns == {}
-
-    def test_child_started_yields_handle(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(
-            _lifecycle(
-                "started",
-                namespace=["task_a:child"],
-                graph_name="child",
-                cause={"type": "toolCall", "tool_call_id": "call_abc"},
-            )
-        )
-
-        handle = self._handle(transformer)
-        assert handle.path == ("task_a:child",)
-        assert handle.graph_name == "child"
-        assert handle.cause == {"type": "toolCall", "tool_call_id": "call_abc"}
-        assert handle.status == "started"
-
-    def test_tool_started_is_synthesized_before_tool_caused_lifecycle(self) -> None:
-        mux, transformer = self._mux()
-        events = iter(mux._events)
-        mux.push(
-            _values(
-                {
-                    "messages": [
-                        {
-                            "tool_calls": [
-                                {
-                                    "id": "call_abc",
-                                    "name": "task",
-                                    "args": {"subagent_type": "researcher"},
-                                }
-                            ]
-                        }
-                    ]
-                },
-                namespace=[],
-            )
-        )
-        mux.push(
-            _lifecycle(
-                "started",
-                namespace=["task:child"],
-                graph_name="child",
-                cause={"type": "toolCall", "tool_call_id": "call_abc"},
-            )
-        )
-
-        mux.close()
-        tool_started, lifecycle_started = list(events)[1:3]
-        assert tool_started["method"] == "tools"
-        assert tool_started["params"]["namespace"] == []
-        assert tool_started["params"]["data"] == {
-            "event": "tool-started",
-            "tool_call_id": "call_abc",
-            "tool_name": "task",
-            "input": {"subagent_type": "researcher"},
-        }
-        assert lifecycle_started["method"] == "lifecycle"
-        assert tool_started["seq"] < lifecycle_started["seq"]
-        assert self._handle(transformer).path == ("task:child",)
-
-    def test_core_golden_trace_uses_js_wire_shape_and_ordering(self) -> None:
-        mux, _transformer = self._mux()
-        events = iter(mux._events)
-        mux.push(
-            _values(
-                {
-                    "messages": [
-                        {
-                            "tool_calls": [
-                                {
-                                    "id": "call_abc",
-                                    "name": "task",
-                                    "args": {"subagent_type": "researcher"},
-                                }
-                            ]
-                        }
-                    ]
-                },
-                namespace=[],
-            )
-        )
-        for data in (
-            {"event": "message-start", "id": "msg-1", "role": "ai"},
-            {
-                "event": "content-block-delta",
-                "index": 0,
-                "content": {"type": "text", "text": "hi"},
-            },
-        ):
-            mux.push(
-                {
-                    "type": "event",
-                    "method": "messages",
-                    "params": {
-                        "namespace": ["call_model:task-1"],
-                        "timestamp": TS,
-                        "data": data,
-                        "run_id": "run-1",
-                    },
-                }
-            )
-        mux.push(
-            _lifecycle(
-                "started",
-                namespace=["task:child"],
-                graph_name="child",
-                cause={"type": "toolCall", "tool_call_id": "call_abc"},
-            )
-        )
-        mux.close()
-
-        trace = [
-            (event["method"], event["params"]["namespace"], event["params"]["data"])
-            for event in events
-        ]
-        assert trace == [
-            (
-                "values",
-                [],
-                {
-                    "messages": [
-                        {
-                            "tool_calls": [
-                                {
-                                    "id": "call_abc",
-                                    "name": "task",
-                                    "args": {"subagent_type": "researcher"},
-                                }
-                            ]
-                        }
-                    ]
-                },
-            ),
-            (
-                "messages",
-                ["call_model:task-1"],
-                {"event": "message-start", "id": "msg-1", "role": "ai"},
-            ),
-            (
-                "messages",
-                ["call_model:task-1"],
-                {
-                    "event": "content-block-start",
-                    "index": 0,
-                    "content": {"type": "text", "text": ""},
-                },
-            ),
-            (
-                "messages",
-                ["call_model:task-1"],
-                {
-                    "event": "content-block-delta",
-                    "index": 0,
-                    "content": {"type": "text", "text": "hi"},
-                },
-            ),
-            (
-                "tools",
-                [],
-                {
-                    "event": "tool-started",
-                    "tool_call_id": "call_abc",
-                    "tool_name": "task",
-                    "input": {"subagent_type": "researcher"},
-                },
-            ),
-            (
-                "lifecycle",
-                ["task:child"],
-                {
-                    "event": "started",
-                    "graph_name": "child",
-                    "cause": {"type": "toolCall", "tool_call_id": "call_abc"},
-                },
-            ),
-        ]
-
-    def test_status_transitions(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        mux.push(_lifecycle("running", namespace=["t:c"]))
-        mux.push(_lifecycle("completed", namespace=["t:c"]))
-
-        handle = self._handle(transformer)
-        assert handle.status == "completed"
-
-    def test_grandchild_surfaces_under_child(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:child"], graph_name="child"))
-
-        child = self._handle(transformer)
-        _pre_subscribe_handle(child)
-
-        mux.push(
-            _lifecycle(
-                "started",
-                namespace=["t:child", "u:grand"],
-                graph_name="grand",
-            )
-        )
-
-        (grand,) = _handle_subgraphs_items(child)
-        assert grand.path == ("t:child", "u:grand")
-        assert grand.graph_name == "grand"
-
-    def test_failed_stores_error(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        mux.push(_lifecycle("failed", namespace=["t:c"], error="boom"))
-
-        handle = self._handle(transformer)
-        assert handle.status == "failed"
-        assert handle.error == "boom"
-
-    def test_values_routed_into_handle(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-
-        handle = self._handle(transformer)
-        _pre_subscribe_handle(handle)
-
-        mux.push(_values({"value": 1}, namespace=["t:c"]))
-        mux.push(_values({"value": 2}, namespace=["t:c"]))
-
-        assert _handle_values_items(handle) == [{"value": 1}, {"value": 2}]
-        assert handle.output == {"value": 2}
-
-    def test_root_values_not_routed(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        handle = self._handle(transformer)
-        _pre_subscribe_handle(handle)
-
-        # Values event at root namespace — must not leak into child handle.
-        mux.push(_values({"value": "root"}, namespace=[]))
-        assert _handle_values_items(handle) == []
-
-    def test_finalize_closes_dangling(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        handle = self._handle(transformer)
-
-        mux.close()
-        assert handle.status == "completed"
-        assert handle._mux.extensions["values"]._closed
-        assert handle._mux.extensions["subgraphs"]._closed
-
-    def test_fail_with_graph_interrupt_marks_interrupted(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        handle = self._handle(transformer)
-
-        mux.fail(GraphInterrupt())
-        assert handle.status == "interrupted"
-
-    def test_fail_with_generic_error_marks_failed(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        handle = self._handle(transformer)
-
-        mux.fail(RuntimeError("explode"))
-        assert handle.status == "failed"
-        assert handle.error == "explode"
-
-    def test_duplicate_started_ignored(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="c"))
-        mux.push(_lifecycle("started", namespace=["t:c"], graph_name="other"))
-
-        handles = list(transformer._root_log._items)
-        assert len(handles) == 1
-        assert handles[0].graph_name == "c"
-
-    def test_non_lifecycle_non_values_passthrough(self) -> None:
-        mux, transformer = self._mux()
-        mux.push(
-            {
-                "type": "event",
-                "method": "messages",
-                "params": {
-                    "namespace": ["t:c"],
-                    "timestamp": TS,
-                    "data": (
-                        {"event": "message-start", "message_id": "m1"},
-                        {"run_id": "m1"},
-                    ),
-                },
-            }
-        )
-        assert list(transformer._root_log._items) == []
-
-
-# ---------------------------------------------------------------------------
-# End-to-end tests via stream_v2 on real graphs
-# ---------------------------------------------------------------------------
-
-
-class SimpleState(TypedDict):
-    value: str
-    items: Annotated[list[str], operator.add]
-
-
-def _build_nested_graph():
-    """Parent graph with a compiled subgraph node."""
-
-    def inner_node(state: SimpleState) -> dict:
-        return {"value": state["value"] + "X", "items": ["x"]}
-
-    inner_builder = StateGraph(SimpleState)
-    inner_builder.add_node("inner_node", inner_node)
-    inner_builder.add_edge(START, "inner_node")
-    inner_builder.add_edge("inner_node", END)
-    inner = inner_builder.compile()
-
-    def outer_node(state: SimpleState) -> dict:
-        return {"value": state["value"] + "Y", "items": ["y"]}
-
-    outer_builder = StateGraph(SimpleState)
-    outer_builder.add_node("outer_node", outer_node)
-    outer_builder.add_node("sub", inner)
-    outer_builder.add_edge(START, "outer_node")
-    outer_builder.add_edge("outer_node", "sub")
-    outer_builder.add_edge("sub", END)
-    return outer_builder.compile()
-
-
-class TestSubgraphTransformerEndToEnd:
-    def test_flat_graph_yields_no_subgraphs(self) -> None:
-        builder = StateGraph(SimpleState)
-        builder.add_node("n", lambda s: {"value": s["value"] + "!", "items": ["!"]})
-        builder.add_edge(START, "n")
-        builder.add_edge("n", END)
-        graph = builder.compile()
-
-        run = graph.stream_v2({"value": "", "items": []})
-
-        collected: list[SubgraphRunStream] = []
-        for sub in run.subgraphs:
-            collected.append(sub)
-        assert collected == []
-        # Output still resolves.
-        assert run.output is not None
-
-    def test_nested_graph_yields_one_child(self) -> None:
-        graph = _build_nested_graph()
-        run = graph.stream_v2({"value": "", "items": []})
-
-        collected: list[SubgraphRunStream] = []
-        for sub in run.subgraphs:
-            collected.append(sub)
-
-        assert len(collected) == 1
-        child = collected[0]
-        assert len(child.path) == 1
-        assert child.path[0].startswith("sub:")
-        assert child.status == "completed"
-
-    def test_error_in_subgraph_fails_child(self) -> None:
-        def boom(state: SimpleState) -> dict:
-            raise RuntimeError("subgraph_failed")
-
-        inner_builder = StateGraph(SimpleState)
-        inner_builder.add_node("inner", boom)
-        inner_builder.add_edge(START, "inner")
-        inner_builder.add_edge("inner", END)
-        inner = inner_builder.compile()
-
-        outer_builder = StateGraph(SimpleState)
-        outer_builder.add_node("sub", inner)
-        outer_builder.add_edge(START, "sub")
-        outer_builder.add_edge("sub", END)
-        graph = outer_builder.compile()
-
-        run = graph.stream_v2({"value": "", "items": []})
-
-        collected: list[SubgraphRunStream] = []
-        with pytest.raises(RuntimeError):
-            for sub in run.subgraphs:
-                collected.append(sub)
-
-        assert len(collected) == 1
-        assert collected[0].status == "failed"
-
-
-class TestSubgraphTransformerAsyncEndToEnd:
-    @pytest.mark.anyio
-    async def test_nested_graph_yields_one_child(self) -> None:
-        async def inner(state: SimpleState) -> dict:
-            return {"value": state["value"] + "X", "items": ["x"]}
-
-        inner_builder = StateGraph(SimpleState)
-        inner_builder.add_node("inner", inner)
-        inner_builder.add_edge(START, "inner")
-        inner_builder.add_edge("inner", END)
-        inner_graph = inner_builder.compile()
-
-        outer_builder = StateGraph(SimpleState)
-        outer_builder.add_node("sub", inner_graph)
-        outer_builder.add_edge(START, "sub")
-        outer_builder.add_edge("sub", END)
-        graph = outer_builder.compile()
-
-        run = await graph.astream_v2({"value": "", "items": []})
-
-        collected: list[SubgraphRunStream] = []
-        async for sub in run.subgraphs:
-            collected.append(sub)
-
-        assert len(collected) == 1
-        child = collected[0]
-        assert child.status == "completed"
-
-
-class TestSubgraphCause:
-    """Pregel core emits no `cause`; product transformers populate it."""
-
-    def test_cause_not_populated_by_pregel(self) -> None:
-        graph = _build_nested_graph()
-        run = graph.stream_v2({"value": "", "items": []})
-
-        collected: list[SubgraphRunStream] = list(run.subgraphs)
-        assert len(collected) == 1
-        child = collected[0]
-
-        # The child's single-segment path still encodes `node_name:task_id`
-        # (that's pregel's internal namespace format), but `cause` is now
-        # product-agnostic and must be populated by a stream transformer,
-        # not by pregel itself.
-        assert ":" in child.path[0]
-        node_name, _, task_id = child.path[0].partition(":")
-        assert node_name == "sub"
-        assert task_id  # non-empty
-        assert child.cause is None
-
-
-class TestSubgraphInterrupt:
-    """Interrupts raised inside a subgraph surface as status=interrupted."""
-
-    def _build_interrupt_subgraph(self):
-        def inner_node(state: SimpleState) -> dict:
-            interrupt("need approval")
-            return {"value": state["value"] + "X", "items": ["x"]}
-
-        inner_builder = StateGraph(SimpleState)
-        inner_builder.add_node("inner_node", inner_node)
-        inner_builder.add_edge(START, "inner_node")
-        inner_builder.add_edge("inner_node", END)
-        inner = inner_builder.compile()
-
-        outer_builder = StateGraph(SimpleState)
-        outer_builder.add_node("sub", inner)
-        outer_builder.add_edge(START, "sub")
-        outer_builder.add_edge("sub", END)
-        return outer_builder.compile(checkpointer=InMemorySaver())
-
-    def test_interrupt_in_subgraph_marks_handle_interrupted(self) -> None:
-        graph = self._build_interrupt_subgraph()
-        run = graph.stream_v2(
-            {"value": "", "items": []},
-            config={"configurable": {"thread_id": "t1"}},
-        )
-
-        collected: list[SubgraphRunStream] = list(run.subgraphs)
-
-        assert run.interrupted is True
-        assert len(collected) == 1
-        assert collected[0].status == "interrupted"
-
-
-class TestSubgraphNameCollision:
-    """The subgraph's compiled `name` equaling its node name is detected.
-
-    Primary detector `name != langgraph_node` fails here; the
-    parent_run_id fallback in `_is_nested_pregel_start` is what keeps
-    the subgraph visible.
-    """
-
-    def test_name_equals_node_name_still_detected(self) -> None:
-        def inner_node(state: SimpleState) -> dict:
-            return {"value": state["value"] + "X", "items": ["x"]}
-
-        inner_builder = StateGraph(SimpleState)
-        inner_builder.add_node("inner_node", inner_node)
-        inner_builder.add_edge(START, "inner_node")
-        inner_builder.add_edge("inner_node", END)
-        # Compile with the same name as the node it will be registered as.
-        inner = inner_builder.compile(name="sub")
-
-        outer_builder = StateGraph(SimpleState)
-        outer_builder.add_node("sub", inner)
-        outer_builder.add_edge(START, "sub")
-        outer_builder.add_edge("sub", END)
-        graph = outer_builder.compile()
-
-        run = graph.stream_v2({"value": "", "items": []})
-
-        collected: list[SubgraphRunStream] = list(run.subgraphs)
-        assert len(collected) == 1
-        child = collected[0]
-        assert child.graph_name == "sub"
-        assert child.status == "completed"

libs/langgraph/tests/test_time_travel.py

@@ -37,6 +37,7 @@ def _checkpoint_summary(history: list) -> list[dict]:
     Returns a list of dicts (newest-first, matching get_state_history order) with:
       - id: short checkpoint id suffix (last 6 chars)
       - parent_id: short parent checkpoint id suffix or None
+      - source: checkpoint metadata source (input, loop, fork, update)
       - next: tuple of next node names
       - values: channel values snapshot
     """
@@ -52,6 +53,7 @@ def _checkpoint_summary(history: list) -> list[dict]:
             {
                 "id": cid[-6:],
                 "parent_id": pid[-6:] if pid else None,
+                "source": s.metadata.get("source"),
                 "next": s.next,
                 "values": s.values,
             }
@@ -280,6 +282,116 @@ def test_replay_from_before_interrupt_refires(
     assert call_count["node_b"] == 1  # NOT re-executed (after interrupt)
 
 
+def test_replay_from_before_interrupt_then_resume(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Replay from checkpoint before interrupt node, then resume with a new
+    answer and verify the graph completes with the new value.
+
+    Graph: START --> node_a --> ask_human (interrupt) --> node_b --> END
+
+    Original run:
+      source=input  next=(__start__,)  values=[]
+      source=loop   next=(node_a,)     values=[]
+      source=loop   next=(ask_human,)  values=[a]            <-- replay from here
+      source=loop   next=(node_b,)     values=[a, human:old_answer]
+      source=loop   next=()            values=[a, human:old_answer, b]
+
+    After replay (fork created) + resume with "new_answer":
+      source=input  next=(__start__,)  values=[]
+      source=loop   next=(node_a,)     values=[]
+      source=loop   next=(ask_human,)  values=[a]            <-- branch point
+      source=loop   next=(node_b,)     values=[a, human:old_answer]
+      source=loop   next=()            values=[a, human:old_answer, b]  (old branch)
+      source=fork   next=(ask_human,)  values=[a]            <-- fork from branch point
+      source=loop   next=(node_b,)     values=[a, human:new_answer]
+      source=loop   next=()            values=[a, human:new_answer, b]  (new branch)
+    """
+
+    called: list[str] = []
+
+    def node_a(state: State) -> State:
+        called.append("node_a")
+        return {"value": ["a"]}
+
+    def ask_human(state: State) -> State:
+        called.append("ask_human")
+        answer = interrupt("What is your input?")
+        return {"value": [f"human:{answer}"]}
+
+    def node_b(state: State) -> State:
+        called.append("node_b")
+        return {"value": ["b"]}
+
+    graph = (
+        StateGraph(State)
+        .add_node("node_a", node_a)
+        .add_node("ask_human", ask_human)
+        .add_node("node_b", node_b)
+        .add_edge(START, "node_a")
+        .add_edge("node_a", "ask_human")
+        .add_edge("ask_human", "node_b")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # --- Original run: invoke until interrupt, then resume to complete ---
+    graph.invoke({"value": []}, config)
+    graph.invoke(Command(resume="old_answer"), config)
+
+    original_history = list(graph.get_state_history(config))
+    original = _checkpoint_summary(original_history)
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["a", "human:old_answer", "b"]}),
+        ("loop", ("node_b",), {"value": ["a", "human:old_answer"]}),
+        ("loop", ("ask_human",), {"value": ["a"]}),
+        ("loop", ("node_a",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # --- Replay from checkpoint before ask_human ---
+    before_ask = next(s for s in original_history if s.next == ("ask_human",))
+
+    called.clear()
+    replay_result = graph.invoke(None, before_ask.config)
+    assert replay_result["__interrupt__"][0].value == "What is your input?"
+    assert "ask_human" in called
+    assert "node_a" not in called  # before the replay point, not re-executed
+
+    # A fork checkpoint is now the latest — it branches from the replay point
+    post_replay = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"]) for s in post_replay] == [
+        ("fork", ("ask_human",)),  # <-- new fork (latest)
+        ("loop", ()),  # original done
+        ("loop", ("node_b",)),
+        ("loop", ("ask_human",)),  # branch point
+        ("loop", ("node_a",)),
+        ("input", ("__start__",)),
+    ]
+
+    # --- Resume with a new answer ---
+    called.clear()
+    final_result = graph.invoke(Command(resume="new_answer"), config)
+    assert final_result["value"] == ["a", "human:new_answer", "b"]
+    assert "ask_human" in called
+    assert "node_b" in called
+
+    final = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch (from fork)
+        ("loop", (), {"value": ["a", "human:new_answer", "b"]}),
+        ("loop", ("node_b",), {"value": ["a", "human:new_answer"]}),
+        ("fork", ("ask_human",), {"value": ["a"]}),
+        # Original branch (preserved)
+        ("loop", (), {"value": ["a", "human:old_answer", "b"]}),
+        ("loop", ("node_b",), {"value": ["a", "human:old_answer"]}),
+        ("loop", ("ask_human",), {"value": ["a"]}),
+        ("loop", ("node_a",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
 def test_replay_interrupt_stable_across_replays(
     sync_checkpointer: BaseCheckpointSaver,
 ) -> None:
@@ -320,8 +432,14 @@ def test_replay_interrupt_stable_across_replays(
         r = graph.invoke(None, before_ask.config)
         results.append(r)
 
-    assert all(r == results[0] for r in results)
-    assert "__interrupt__" in results[0]
+    # Each replay creates a fork with a unique interrupt ID, so we compare
+    # interrupt values and state values rather than full equality.
+    assert all("__interrupt__" in r for r in results)
+    assert all(
+        r["__interrupt__"][0].value == results[0]["__interrupt__"][0].value
+        for r in results
+    )
+    assert all(r["value"] == results[0]["value"] for r in results)
 
 
 def test_fork_from_before_interrupt_refires(
@@ -854,6 +972,354 @@ def test_subgraph_interrupt_replay_from_interrupt_checkpoint(
     assert "step_b" not in called
 
 
+def test_subgraph_interrupt_replay_from_parent_then_resume(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Replay from the parent checkpoint where a subgraph interrupt fired,
+    then resume with a new answer. Verifies that a fork is created and the
+    full graph completes. Checks full checkpoint history at each stage."""
+
+    called: list[str] = []
+
+    def router(state: State) -> State:
+        called.append("router")
+        return {"value": ["routed"]}
+
+    def step_a(state: State) -> State:
+        called.append("step_a")
+        return {"value": ["sub_a"]}
+
+    def ask_human(state: State) -> State:
+        called.append("ask_human")
+        answer = interrupt("Provide input:")
+        return {"value": [f"human:{answer}"]}
+
+    def step_b(state: State) -> State:
+        called.append("step_b")
+        return {"value": ["sub_b"]}
+
+    subgraph = (
+        StateGraph(State)
+        .add_node("step_a", step_a)
+        .add_node("ask_human", ask_human)
+        .add_node("step_b", step_b)
+        .add_edge(START, "step_a")
+        .add_edge("step_a", "ask_human")
+        .add_edge("ask_human", "step_b")
+        .compile(checkpointer=True)
+    )
+
+    def post_process(state: State) -> State:
+        called.append("post_process")
+        return {"value": ["post"]}
+
+    graph = (
+        StateGraph(State)
+        .add_node("router", router)
+        .add_node("subgraph_node", subgraph)
+        .add_node("post_process", post_process)
+        .add_edge(START, "router")
+        .add_edge("router", "subgraph_node")
+        .add_edge("subgraph_node", "post_process")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # Run until interrupt, then resume to complete
+    graph.invoke({"value": []}, config)
+    graph.invoke(Command(resume="old_answer"), config)
+
+    # Original parent history (newest first)
+    original_history = list(graph.get_state_history(config))
+    assert [s.next for s in original_history] == [
+        (),  # done
+        ("post_process",),
+        ("subgraph_node",),  # subgraph ran, interrupt fired here
+        ("router",),
+        ("__start__",),
+    ]
+
+    # Find the parent checkpoint where the interrupt fired
+    interrupt_checkpoint = next(
+        s for s in original_history if s.next == ("subgraph_node",)
+    )
+
+    # Replay from parent checkpoint — subgraph re-executes, interrupt re-fires
+    called.clear()
+    replay_result = graph.invoke(None, interrupt_checkpoint.config)
+    assert "__interrupt__" in replay_result
+    assert replay_result["__interrupt__"][0].value == "Provide input:"
+    assert "step_a" in called
+    assert "ask_human" in called
+    assert "step_b" not in called
+
+    # Verify fork checkpoint was created
+    post_replay_history = list(graph.get_state_history(config))
+    assert [s.next for s in post_replay_history] == [
+        ("subgraph_node",),  # fork (interrupt pending)
+        (),  # original done
+        ("post_process",),
+        ("subgraph_node",),
+        ("router",),
+        ("__start__",),
+    ]
+    assert [s.metadata["source"] for s in post_replay_history] == [
+        "fork",
+        "loop",
+        "loop",
+        "loop",
+        "loop",
+        "input",
+    ]
+    fork = post_replay_history[0]
+    assert (
+        fork.parent_config["configurable"]["checkpoint_id"]
+        == interrupt_checkpoint.config["configurable"]["checkpoint_id"]
+    )
+
+    # Resume with a new answer — full graph should complete
+    called.clear()
+    final_result = graph.invoke(Command(resume="new_answer"), config)
+    assert "__interrupt__" not in final_result
+    assert "human:new_answer" in final_result["value"]
+    assert "sub_b" in final_result["value"]
+    assert "post" in final_result["value"]
+    assert "ask_human" in called
+    assert "step_b" in called
+    assert "post_process" in called
+
+    # Final checkpoint history
+    final_history = list(graph.get_state_history(config))
+    assert [s.next for s in final_history] == [
+        (),  # new branch done
+        ("post_process",),  # new branch post_process
+        ("subgraph_node",),  # fork
+        (),  # original done
+        ("post_process",),
+        ("subgraph_node",),
+        ("router",),
+        ("__start__",),
+    ]
+    assert [s.metadata["source"] for s in final_history] == [
+        "loop",
+        "loop",
+        "fork",
+        "loop",
+        "loop",
+        "loop",
+        "loop",
+        "input",
+    ]
+
+
+def test_subgraph_interrupt_resume_with_explicit_head_checkpoint_id(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Resume with Command(resume=...) plus the current head checkpoint_id
+    in config. The subgraph must continue from the interrupted node, not
+    restart from scratch. Explicit checkpoint_id triggers is_replaying but
+    this is a resume, not a time-travel, so ReplayState should not apply."""
+
+    called: list[str] = []
+
+    def step_a(state: State) -> State:
+        called.append("step_a")
+        return {"value": ["sub_a"]}
+
+    def ask_human(state: State) -> State:
+        called.append("ask_human")
+        answer = interrupt("Provide input:")
+        return {"value": [f"human:{answer}"]}
+
+    def step_b(state: State) -> State:
+        called.append("step_b")
+        return {"value": ["sub_b"]}
+
+    subgraph = (
+        StateGraph(State)
+        .add_node("step_a", step_a)
+        .add_node("ask_human", ask_human)
+        .add_node("step_b", step_b)
+        .add_edge(START, "step_a")
+        .add_edge("step_a", "ask_human")
+        .add_edge("ask_human", "step_b")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("subgraph_node", subgraph)
+        .add_edge(START, "subgraph_node")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # Run until interrupt fires in subgraph
+    graph.invoke({"value": []}, config)
+    assert called == ["step_a", "ask_human"]
+
+    # Resume with explicit head checkpoint_id in config
+    head_checkpoint_id = graph.get_state(config).config["configurable"]["checkpoint_id"]
+    called.clear()
+    resume_config = {
+        "configurable": {
+            "thread_id": "1",
+            "checkpoint_id": head_checkpoint_id,
+            "checkpoint_ns": "",
+        }
+    }
+    result = graph.invoke(Command(resume="answer"), resume_config)
+
+    assert called == ["ask_human", "step_b"]
+    assert "__interrupt__" not in result
+    assert result["value"] == ["sub_a", "human:answer", "sub_b"]
+
+
+def test_subgraph_replay_loads_accumulated_state_then_resume(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Two parent invocations, then replay from before the subgraph in the
+    2nd invocation. The subgraph (checkpointer=True) should load its
+    accumulated state from the 1st invocation via ReplayState, re-fire
+    the interrupt, and then resume + complete.
+
+    This tests the ReplayState path: the parent is replaying and the
+    subgraph uses list(before=parent_checkpoint_id) to find its
+    corresponding checkpoint from the original execution.
+    """
+
+    class SubState(TypedDict):
+        value: Annotated[list[str], operator.add]
+
+    class ParentState(TypedDict):
+        results: Annotated[list[str], operator.add]
+
+    started_state: list[dict] = []
+
+    def step_a(state: SubState) -> SubState:
+        started_state.append(dict(state))
+        answer = interrupt("question_a")
+        return {"value": [f"a:{answer}"]}
+
+    subgraph = (
+        StateGraph(SubState)
+        .add_node("step_a", step_a)
+        .add_edge(START, "step_a")
+        .compile(checkpointer=True)
+    )
+
+    def parent_node(state: ParentState) -> ParentState:
+        return {"results": ["p"]}
+
+    graph = (
+        StateGraph(ParentState)
+        .add_node("parent_node", parent_node)
+        .add_node("sub_node", subgraph)
+        .add_edge(START, "parent_node")
+        .add_edge("parent_node", "sub_node")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # === 1st invocation: complete with answer "a1" ===
+    graph.invoke({"results": []}, config)
+    graph.invoke(Command(resume="a1"), config)
+
+    # step_a saw empty state (fresh subgraph)
+    assert started_state[0] == {"value": []}
+
+    # === 2nd invocation: complete with answer "a2" ===
+    started_state.clear()
+    graph.invoke({"results": []}, config)
+    graph.invoke(Command(resume="a2"), config)
+
+    # Stateful subgraph retained state from 1st invocation
+    assert started_state[0] == {"value": ["a:a1"]}
+
+    # Original history (newest first)
+    original_history = list(graph.get_state_history(config))
+    assert [s.next for s in original_history] == [
+        (),  # 2nd done
+        ("sub_node",),  # 2nd sub_node
+        ("parent_node",),  # 2nd parent_node
+        ("__start__",),  # 2nd input
+        (),  # 1st done
+        ("sub_node",),  # 1st sub_node
+        ("parent_node",),  # 1st parent_node
+        ("__start__",),  # 1st input
+    ]
+
+    # Replay from before sub_node in 2nd invocation (newest match)
+    before_sub_2nd = [s for s in original_history if s.next == ("sub_node",)][0]
+    started_state.clear()
+    replay = graph.invoke(None, before_sub_2nd.config)
+    assert "__interrupt__" in replay
+
+    # Subgraph should see accumulated state from END of 1st invocation
+    assert started_state[0] == {"value": ["a:a1"]}
+
+    # Verify fork was created
+    post_replay_history = list(graph.get_state_history(config))
+    assert [s.next for s in post_replay_history] == [
+        ("sub_node",),  # fork (interrupt pending)
+        (),  # 2nd done
+        ("sub_node",),  # 2nd sub_node
+        ("parent_node",),  # 2nd parent_node
+        ("__start__",),  # 2nd input
+        (),  # 1st done
+        ("sub_node",),  # 1st sub_node
+        ("parent_node",),  # 1st parent_node
+        ("__start__",),  # 1st input
+    ]
+    assert [s.metadata["source"] for s in post_replay_history] == [
+        "fork",
+        "loop",
+        "loop",
+        "loop",
+        "input",
+        "loop",
+        "loop",
+        "loop",
+        "input",
+    ]
+
+    # Resume with a new answer
+    started_state.clear()
+    final = graph.invoke(Command(resume="a3"), config)
+    assert "__interrupt__" not in final
+    assert final["results"] == ["p", "p"]
+
+    # Final history
+    final_history = list(graph.get_state_history(config))
+    assert [s.next for s in final_history] == [
+        (),  # new branch done
+        ("sub_node",),  # fork
+        (),  # 2nd done
+        ("sub_node",),  # 2nd sub_node
+        ("parent_node",),  # 2nd parent_node
+        ("__start__",),  # 2nd input
+        (),  # 1st done
+        ("sub_node",),  # 1st sub_node
+        ("parent_node",),  # 1st parent_node
+        ("__start__",),  # 1st input
+    ]
+    assert [s.metadata["source"] for s in final_history] == [
+        "loop",
+        "fork",
+        "loop",
+        "loop",
+        "loop",
+        "input",
+        "loop",
+        "loop",
+        "loop",
+        "input",
+    ]
+
+
 def test_subgraph_interrupt_full_flow(
     sync_checkpointer: BaseCheckpointSaver,
 ) -> None:
@@ -1290,6 +1756,321 @@ def test_subgraph_time_travel_to_second_interrupt(
     assert "ask_1" not in called
 
 
+def test_subgraph_time_travel_resume_from_first_interrupt(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Time travel to a subgraph checkpoint at the first interrupt, then
+    resume through both interrupts with new answers.
+
+    This verifies the key bug fix: after time-traveling to a subgraph
+    checkpoint with an interrupt, a fork checkpoint is created so that
+    subsequent resumes find the correct state (not the old branch tip).
+
+    Parent:    START --> executor (subgraph, checkpointer=True) --> END
+    Executor:  START --> step_a --> ask_1 (interrupt) --> ask_2 (interrupt) --> END
+
+    Parent history after original run completes:
+      source=input  next=(__start__,)   values=[]
+      source=loop   next=(executor,)    values=[]
+      source=loop   next=()             values=[step_a_done, ask_1:answer_1, ask_2:answer_2]
+
+    After time-traveling to 1st interrupt + resuming with new answers:
+      source=input  next=(__start__,)   values=[]
+      source=loop   next=(executor,)    values=[]          <-- branch point
+      source=loop   next=()             values=[..., ask_2:answer_2]  (old branch)
+      source=fork   next=(executor,)    values=[]          <-- fork from time travel
+      source=loop   next=()             values=[..., ask_2:new_answer_2]  (new branch)
+    """
+
+    called: list[str] = []
+
+    def step_a(state: State) -> State:
+        called.append("step_a")
+        return {"value": ["step_a_done"]}
+
+    def ask_1(state: State) -> State:
+        called.append("ask_1")
+        answer = interrupt("Question 1?")
+        return {"value": [f"ask_1:{answer}"]}
+
+    def ask_2(state: State) -> State:
+        called.append("ask_2")
+        answer = interrupt("Question 2?")
+        return {"value": [f"ask_2:{answer}"]}
+
+    executor = (
+        StateGraph(State)
+        .add_node("step_a", step_a)
+        .add_node("ask_1", ask_1)
+        .add_node("ask_2", ask_2)
+        .add_edge(START, "step_a")
+        .add_edge("step_a", "ask_1")
+        .add_edge("ask_1", "ask_2")
+        .add_edge("ask_2", "__end__")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("executor", executor)
+        .add_edge(START, "executor")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # --- Original run: hit both interrupts and resume ---
+    graph.invoke({"value": []}, config)
+    sub_config_at_first = graph.get_state(config, subgraphs=True).tasks[0].state.config
+    graph.invoke(Command(resume="answer_1"), config)
+    graph.invoke(Command(resume="answer_2"), config)
+
+    original = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # --- Time travel to first interrupt's subgraph checkpoint ---
+    called.clear()
+    replay_result = graph.invoke(None, sub_config_at_first)
+    assert replay_result["__interrupt__"][0].value == "Question 1?"
+    assert "step_a" not in called  # before interrupt, not re-executed
+
+    # Fork is now the latest parent checkpoint
+    post_tt = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"]) for s in post_tt] == [
+        ("fork", ("executor",)),  # <-- new fork (latest)
+        ("loop", ()),  # original done
+        ("loop", ("executor",)),
+        ("input", ("__start__",)),
+    ]
+
+    # --- Resume both interrupts with new answers ---
+    called.clear()
+    resume_1 = graph.invoke(Command(resume="new_answer_1"), config)
+    assert resume_1["__interrupt__"][0].value == "Question 2?"
+    assert "ask_1" in called
+
+    called.clear()
+    resume_2 = graph.invoke(Command(resume="new_answer_2"), config)
+    assert resume_2["value"] == [
+        "step_a_done",
+        "ask_1:new_answer_1",
+        "ask_2:new_answer_2",
+    ]
+
+    # Verify final history: original branch preserved, new branch appended
+    final = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch (from time travel fork)
+        (
+            "loop",
+            (),
+            {"value": ["step_a_done", "ask_1:new_answer_1", "ask_2:new_answer_2"]},
+        ),
+        ("fork", ("executor",), {"value": []}),
+        # Original branch (preserved)
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
+def test_subgraph_time_travel_resume_from_second_interrupt(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Time travel to a subgraph checkpoint at the second interrupt, then
+    resume with a new answer. The first interrupt's answer should be preserved.
+
+    Parent:    START --> executor (subgraph, checkpointer=True) --> END
+    Executor:  START --> step_a --> ask_1 (interrupt) --> ask_2 (interrupt) --> END
+
+    Key assertion: after resuming from a time-travel to the 2nd interrupt,
+    the final state keeps ask_1's original answer but uses the new ask_2 answer.
+    """
+
+    called: list[str] = []
+
+    def step_a(state: State) -> State:
+        called.append("step_a")
+        return {"value": ["step_a_done"]}
+
+    def ask_1(state: State) -> State:
+        called.append("ask_1")
+        answer = interrupt("Question 1?")
+        return {"value": [f"ask_1:{answer}"]}
+
+    def ask_2(state: State) -> State:
+        called.append("ask_2")
+        answer = interrupt("Question 2?")
+        return {"value": [f"ask_2:{answer}"]}
+
+    executor = (
+        StateGraph(State)
+        .add_node("step_a", step_a)
+        .add_node("ask_1", ask_1)
+        .add_node("ask_2", ask_2)
+        .add_edge(START, "step_a")
+        .add_edge("step_a", "ask_1")
+        .add_edge("ask_1", "ask_2")
+        .add_edge("ask_2", "__end__")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("executor", executor)
+        .add_edge(START, "executor")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # --- Original run: hit both interrupts and resume ---
+    graph.invoke({"value": []}, config)
+    graph.invoke(Command(resume="answer_1"), config)
+    sub_config_at_second = graph.get_state(config, subgraphs=True).tasks[0].state.config
+    graph.invoke(Command(resume="answer_2"), config)
+
+    original = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # --- Time travel to second interrupt ---
+    called.clear()
+    replay_result = graph.invoke(None, sub_config_at_second)
+    assert replay_result["__interrupt__"][0].value == "Question 2?"
+    assert "step_a" not in called
+    assert "ask_1" not in called  # already resolved, not re-executed
+
+    # Fork is now the latest parent checkpoint
+    post_tt = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"]) for s in post_tt] == [
+        ("fork", ("executor",)),  # <-- new fork (latest)
+        ("loop", ()),  # original done
+        ("loop", ("executor",)),
+        ("input", ("__start__",)),
+    ]
+
+    # --- Resume with a new answer for ask_2 only ---
+    called.clear()
+    resume_result = graph.invoke(Command(resume="new_answer_2"), config)
+    # ask_1's original answer preserved, ask_2 uses the new answer
+    assert resume_result["value"] == [
+        "step_a_done",
+        "ask_1:answer_1",
+        "ask_2:new_answer_2",
+    ]
+
+    # Verify final history: original branch preserved, new branch appended
+    final = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch (from time travel fork)
+        (
+            "loop",
+            (),
+            {"value": ["step_a_done", "ask_1:answer_1", "ask_2:new_answer_2"]},
+        ),
+        ("fork", ("executor",), {"value": []}),
+        # Original branch (preserved)
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
+def test_subgraph_time_travel_checkpoint_pattern(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Verify the checkpoint pattern created by time travel to a subgraph
+    interrupt. A fork checkpoint should branch from the replay point and
+    become the latest parent checkpoint.
+
+    Parent:    START --> executor (subgraph, checkpointer=True) --> END
+    Executor:  START --> ask (interrupt) --> END
+
+    Original run (after completing):
+      source=input  next=(__start__,)  values=[]
+      source=loop   next=(executor,)   values=[]          <-- replay point
+      source=loop   next=()            values=[a:first]
+
+    After time travel to interrupt + resume with "second":
+      source=input  next=(__start__,)  values=[]
+      source=loop   next=(executor,)   values=[]          <-- branch point
+      source=loop   next=()            values=[a:first]   (old branch)
+      source=fork   next=(executor,)   values=[]          <-- fork
+      source=loop   next=()            values=[a:second]  (new branch)
+    """
+
+    def ask(state: State) -> State:
+        answer = interrupt("Q?")
+        return {"value": [f"a:{answer}"]}
+
+    executor = (
+        StateGraph(State)
+        .add_node("ask", ask)
+        .add_edge(START, "ask")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("executor", executor)
+        .add_edge(START, "executor")
+        .compile(checkpointer=sync_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # Run until interrupt, then complete
+    graph.invoke({"value": []}, config)
+    sub_config = graph.get_state(config, subgraphs=True).tasks[0].state.config
+    graph.invoke(Command(resume="first"), config)
+
+    original = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["a:first"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # Time travel to the interrupt
+    graph.invoke(None, sub_config)
+
+    # Fork is now the latest, branching from the original replay point
+    post_tt = list(graph.get_state_history(config))
+    post_tt_summary = _checkpoint_summary(post_tt)
+    assert [(s["source"], s["next"]) for s in post_tt_summary] == [
+        ("fork", ("executor",)),  # <-- new fork (latest)
+        ("loop", ()),
+        ("loop", ("executor",)),  # <-- replay point / fork parent
+        ("input", ("__start__",)),
+    ]
+    # Verify the fork's parent is the original replay point
+    replay_point_id = sub_config["configurable"]["checkpoint_map"][""]
+    assert post_tt[0].parent_config["configurable"]["checkpoint_id"] == replay_point_id
+
+    # Resume from the fork — graph completes with new answer
+    result = graph.invoke(Command(resume="second"), config)
+    assert result["value"] == ["a:second"]
+
+    final = _checkpoint_summary(list(graph.get_state_history(config)))
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch
+        ("loop", (), {"value": ["a:second"]}),
+        ("fork", ("executor",), {"value": []}),
+        # Original branch
+        ("loop", (), {"value": ["a:first"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
 def test_subgraph_time_travel_after_completion(
     sync_checkpointer: BaseCheckpointSaver,
 ) -> None:
@@ -2283,14 +3064,16 @@ def test_replay_creates_branch_preserving_old_checkpoints(
     # -- Post-replay checkpoint history (newest first) --
     post_replay_history = list(graph.get_state_history(config))
     post_summary = _checkpoint_summary(post_replay_history)
-    assert len(post_summary) == 7  # 5 original + 2 new branch checkpoints
+    # 5 original + 1 fork + 2 new branch checkpoints = 8
+    assert len(post_summary) == 8
 
     # Verify the full shape after replay
     assert [s["next"] for s in post_summary] == [
-        (),  # new branch tip (C6)
-        ("node_c",),  # new branch (C5)
-        (),  # old branch tip (C4)
-        ("node_c",),  # old (C3)
+        (),  # new branch tip
+        ("node_c",),  # new branch
+        ("node_b",),  # fork from replay point
+        (),  # old branch tip
+        ("node_c",),  # old
         ("node_b",),  # branch point (C2)
         ("node_a",),  # old (C1)
         ("__start__",),  # old (C0)
@@ -2298,6 +3081,7 @@ def test_replay_creates_branch_preserving_old_checkpoints(
     assert [s["values"] for s in post_summary] == [
         {"value": ["a", "b2", "c"]},  # new branch tip
         {"value": ["a", "b2"]},  # new: node_b re-ran with call_count=2
+        {"value": ["a"]},  # fork from replay point
         {"value": ["a", "b1", "c"]},  # old branch tip preserved
         {"value": ["a", "b1"]},  # old
         {"value": ["a"]},  # branch point

libs/langgraph/tests/test_time_travel_async.py

@@ -46,6 +46,7 @@ def _checkpoint_summary(history: list) -> list[dict]:
     Returns a list of dicts (newest-first, matching get_state_history order) with:
       - id: short checkpoint id suffix (last 6 chars)
       - parent_id: short parent checkpoint id suffix or None
+      - source: checkpoint metadata source (input, loop, fork, update)
       - next: tuple of next node names
       - values: channel values snapshot
     """
@@ -61,6 +62,7 @@ def _checkpoint_summary(history: list) -> list[dict]:
             {
                 "id": cid[-6:],
                 "parent_id": pid[-6:] if pid else None,
+                "source": s.metadata.get("source"),
                 "next": s.next,
                 "values": s.values,
             }
@@ -335,8 +337,14 @@ async def test_replay_interrupt_stable_across_replays(
         r = await graph.ainvoke(None, before_ask.config)
         results.append(r)
 
-    assert all(r == results[0] for r in results)
-    assert "__interrupt__" in results[0]
+    # Each replay creates a fork with a unique interrupt ID, so we compare
+    # interrupt values and state values rather than full equality.
+    assert all("__interrupt__" in r for r in results)
+    assert all(
+        r["__interrupt__"][0].value == results[0]["__interrupt__"][0].value
+        for r in results
+    )
+    assert all(r["value"] == results[0]["value"] for r in results)
 
 
 @NEEDS_CONTEXTVARS
@@ -1261,6 +1269,391 @@ async def test_subgraph_time_travel_after_completion_async(
     assert "ask_2:answer_2" in replay_result["value"]
 
 
+@NEEDS_CONTEXTVARS
+async def test_replay_from_before_interrupt_then_resume_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Replay from checkpoint before interrupt node, then resume with a new
+    answer and verify the graph completes with the new value.
+
+    Graph: START --> node_a --> ask_human (interrupt) --> node_b --> END
+    """
+
+    called: list[str] = []
+
+    async def node_a(state: State) -> State:
+        called.append("node_a")
+        return {"value": ["a"]}
+
+    async def ask_human(state: State) -> State:
+        called.append("ask_human")
+        answer = interrupt("What is your input?")
+        return {"value": [f"human:{answer}"]}
+
+    async def node_b(state: State) -> State:
+        called.append("node_b")
+        return {"value": ["b"]}
+
+    graph = (
+        StateGraph(State)
+        .add_node("node_a", node_a)
+        .add_node("ask_human", ask_human)
+        .add_node("node_b", node_b)
+        .add_edge(START, "node_a")
+        .add_edge("node_a", "ask_human")
+        .add_edge("ask_human", "node_b")
+        .compile(checkpointer=async_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # --- Original run: invoke until interrupt, then resume to complete ---
+    await graph.ainvoke({"value": []}, config)
+    await graph.ainvoke(Command(resume="old_answer"), config)
+
+    original_history = [s async for s in graph.aget_state_history(config)]
+    original = _checkpoint_summary(original_history)
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["a", "human:old_answer", "b"]}),
+        ("loop", ("node_b",), {"value": ["a", "human:old_answer"]}),
+        ("loop", ("ask_human",), {"value": ["a"]}),
+        ("loop", ("node_a",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # --- Replay from checkpoint before ask_human ---
+    before_ask = next(s for s in original_history if s.next == ("ask_human",))
+
+    called.clear()
+    replay_result = await graph.ainvoke(None, before_ask.config)
+    assert replay_result["__interrupt__"][0].value == "What is your input?"
+    assert "ask_human" in called
+    assert "node_a" not in called
+
+    # A fork checkpoint is now the latest
+    post_replay = _checkpoint_summary(
+        [s async for s in graph.aget_state_history(config)]
+    )
+    assert [(s["source"], s["next"]) for s in post_replay] == [
+        ("fork", ("ask_human",)),
+        ("loop", ()),
+        ("loop", ("node_b",)),
+        ("loop", ("ask_human",)),
+        ("loop", ("node_a",)),
+        ("input", ("__start__",)),
+    ]
+
+    # --- Resume with a new answer ---
+    called.clear()
+    final_result = await graph.ainvoke(Command(resume="new_answer"), config)
+    assert final_result["value"] == ["a", "human:new_answer", "b"]
+    assert "ask_human" in called
+    assert "node_b" in called
+
+    final = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch (from fork)
+        ("loop", (), {"value": ["a", "human:new_answer", "b"]}),
+        ("loop", ("node_b",), {"value": ["a", "human:new_answer"]}),
+        ("fork", ("ask_human",), {"value": ["a"]}),
+        # Original branch (preserved)
+        ("loop", (), {"value": ["a", "human:old_answer", "b"]}),
+        ("loop", ("node_b",), {"value": ["a", "human:old_answer"]}),
+        ("loop", ("ask_human",), {"value": ["a"]}),
+        ("loop", ("node_a",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
+@NEEDS_CONTEXTVARS
+async def test_subgraph_time_travel_resume_from_first_interrupt_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Time travel to a subgraph checkpoint at the first interrupt, then
+    resume through both interrupts with new answers.
+
+    Parent:    START --> executor (subgraph, checkpointer=True) --> END
+    Executor:  START --> step_a --> ask_1 (interrupt) --> ask_2 (interrupt) --> END
+    """
+
+    called: list[str] = []
+
+    async def step_a(state: State) -> State:
+        called.append("step_a")
+        return {"value": ["step_a_done"]}
+
+    async def ask_1(state: State) -> State:
+        called.append("ask_1")
+        answer = interrupt("Question 1?")
+        return {"value": [f"ask_1:{answer}"]}
+
+    async def ask_2(state: State) -> State:
+        called.append("ask_2")
+        answer = interrupt("Question 2?")
+        return {"value": [f"ask_2:{answer}"]}
+
+    executor = (
+        StateGraph(State)
+        .add_node("step_a", step_a)
+        .add_node("ask_1", ask_1)
+        .add_node("ask_2", ask_2)
+        .add_edge(START, "step_a")
+        .add_edge("step_a", "ask_1")
+        .add_edge("ask_1", "ask_2")
+        .add_edge("ask_2", "__end__")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("executor", executor)
+        .add_edge(START, "executor")
+        .compile(checkpointer=async_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # --- Original run: hit both interrupts and resume ---
+    await graph.ainvoke({"value": []}, config)
+    sub_config_at_first = (
+        (await graph.aget_state(config, subgraphs=True)).tasks[0].state.config
+    )
+    await graph.ainvoke(Command(resume="answer_1"), config)
+    await graph.ainvoke(Command(resume="answer_2"), config)
+
+    original = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # --- Time travel to first interrupt's subgraph checkpoint ---
+    called.clear()
+    replay_result = await graph.ainvoke(None, sub_config_at_first)
+    assert replay_result["__interrupt__"][0].value == "Question 1?"
+    assert "step_a" not in called
+
+    # Fork is now the latest parent checkpoint
+    post_tt = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"]) for s in post_tt] == [
+        ("fork", ("executor",)),  # <-- new fork (latest)
+        ("loop", ()),  # original done
+        ("loop", ("executor",)),
+        ("input", ("__start__",)),
+    ]
+
+    # --- Resume both interrupts with new answers ---
+    called.clear()
+    resume_1 = await graph.ainvoke(Command(resume="new_answer_1"), config)
+    assert resume_1["__interrupt__"][0].value == "Question 2?"
+    assert "ask_1" in called
+
+    called.clear()
+    resume_2 = await graph.ainvoke(Command(resume="new_answer_2"), config)
+    assert resume_2["value"] == [
+        "step_a_done",
+        "ask_1:new_answer_1",
+        "ask_2:new_answer_2",
+    ]
+
+    # Verify final history: original branch preserved, new branch appended
+    final = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch (from time travel fork)
+        (
+            "loop",
+            (),
+            {"value": ["step_a_done", "ask_1:new_answer_1", "ask_2:new_answer_2"]},
+        ),
+        ("fork", ("executor",), {"value": []}),
+        # Original branch (preserved)
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
+@NEEDS_CONTEXTVARS
+async def test_subgraph_time_travel_resume_from_second_interrupt_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Time travel to a subgraph checkpoint at the second interrupt, then
+    resume with a new answer. The first interrupt's answer should be preserved.
+
+    Parent:    START --> executor (subgraph, checkpointer=True) --> END
+    Executor:  START --> step_a --> ask_1 (interrupt) --> ask_2 (interrupt) --> END
+    """
+
+    called: list[str] = []
+
+    async def step_a(state: State) -> State:
+        called.append("step_a")
+        return {"value": ["step_a_done"]}
+
+    async def ask_1(state: State) -> State:
+        called.append("ask_1")
+        answer = interrupt("Question 1?")
+        return {"value": [f"ask_1:{answer}"]}
+
+    async def ask_2(state: State) -> State:
+        called.append("ask_2")
+        answer = interrupt("Question 2?")
+        return {"value": [f"ask_2:{answer}"]}
+
+    executor = (
+        StateGraph(State)
+        .add_node("step_a", step_a)
+        .add_node("ask_1", ask_1)
+        .add_node("ask_2", ask_2)
+        .add_edge(START, "step_a")
+        .add_edge("step_a", "ask_1")
+        .add_edge("ask_1", "ask_2")
+        .add_edge("ask_2", "__end__")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("executor", executor)
+        .add_edge(START, "executor")
+        .compile(checkpointer=async_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # --- Original run: hit both interrupts and resume ---
+    await graph.ainvoke({"value": []}, config)
+    await graph.ainvoke(Command(resume="answer_1"), config)
+    sub_config_at_second = (
+        (await graph.aget_state(config, subgraphs=True)).tasks[0].state.config
+    )
+    await graph.ainvoke(Command(resume="answer_2"), config)
+
+    original = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # --- Time travel to second interrupt ---
+    called.clear()
+    replay_result = await graph.ainvoke(None, sub_config_at_second)
+    assert replay_result["__interrupt__"][0].value == "Question 2?"
+    assert "step_a" not in called
+    assert "ask_1" not in called
+
+    # Fork is now the latest parent checkpoint
+    post_tt = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"]) for s in post_tt] == [
+        ("fork", ("executor",)),  # <-- new fork (latest)
+        ("loop", ()),  # original done
+        ("loop", ("executor",)),
+        ("input", ("__start__",)),
+    ]
+
+    # --- Resume with a new answer for ask_2 only ---
+    called.clear()
+    resume_result = await graph.ainvoke(Command(resume="new_answer_2"), config)
+    assert resume_result["value"] == [
+        "step_a_done",
+        "ask_1:answer_1",
+        "ask_2:new_answer_2",
+    ]
+
+    # Verify final history
+    final = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch (from time travel fork)
+        (
+            "loop",
+            (),
+            {"value": ["step_a_done", "ask_1:answer_1", "ask_2:new_answer_2"]},
+        ),
+        ("fork", ("executor",), {"value": []}),
+        # Original branch (preserved)
+        ("loop", (), {"value": ["step_a_done", "ask_1:answer_1", "ask_2:answer_2"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
+@NEEDS_CONTEXTVARS
+async def test_subgraph_time_travel_checkpoint_pattern_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Verify the checkpoint pattern created by time travel to a subgraph
+    interrupt. A fork checkpoint should branch from the replay point.
+
+    Parent:    START --> executor (subgraph, checkpointer=True) --> END
+    Executor:  START --> ask (interrupt) --> END
+    """
+
+    async def ask(state: State) -> State:
+        answer = interrupt("Q?")
+        return {"value": [f"a:{answer}"]}
+
+    executor = (
+        StateGraph(State)
+        .add_node("ask", ask)
+        .add_edge(START, "ask")
+        .compile(checkpointer=True)
+    )
+
+    graph = (
+        StateGraph(State)
+        .add_node("executor", executor)
+        .add_edge(START, "executor")
+        .compile(checkpointer=async_checkpointer)
+    )
+
+    config = {"configurable": {"thread_id": "1"}}
+
+    # Run until interrupt, then complete
+    await graph.ainvoke({"value": []}, config)
+    sub_config = (await graph.aget_state(config, subgraphs=True)).tasks[0].state.config
+    await graph.ainvoke(Command(resume="first"), config)
+
+    original = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in original] == [
+        ("loop", (), {"value": ["a:first"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+    # Time travel to the interrupt
+    await graph.ainvoke(None, sub_config)
+
+    # Fork is now the latest, branching from the original replay point
+    post_tt = [s async for s in graph.aget_state_history(config)]
+    post_tt_summary = _checkpoint_summary(post_tt)
+    assert [(s["source"], s["next"]) for s in post_tt_summary] == [
+        ("fork", ("executor",)),  # <-- new fork (latest)
+        ("loop", ()),
+        ("loop", ("executor",)),  # <-- replay point / fork parent
+        ("input", ("__start__",)),
+    ]
+    # Verify the fork's parent is the original replay point
+    replay_point_id = sub_config["configurable"]["checkpoint_map"][""]
+    assert post_tt[0].parent_config["configurable"]["checkpoint_id"] == replay_point_id
+
+    # Resume from the fork
+    result = await graph.ainvoke(Command(resume="second"), config)
+    assert result["value"] == ["a:second"]
+
+    final = _checkpoint_summary([s async for s in graph.aget_state_history(config)])
+    assert [(s["source"], s["next"], s["values"]) for s in final] == [
+        # New branch
+        ("loop", (), {"value": ["a:second"]}),
+        ("fork", ("executor",), {"value": []}),
+        # Original branch
+        ("loop", (), {"value": ["a:first"]}),
+        ("loop", ("executor",), {"value": []}),
+        ("input", ("__start__",), {"value": []}),
+    ]
+
+
 @NEEDS_CONTEXTVARS
 async def test_3_levels_deep_time_travel_to_first_interrupt_async(
     async_checkpointer: BaseCheckpointSaver,
@@ -2088,13 +2481,15 @@ async def test_replay_creates_branch_preserving_old_checkpoints(
     # -- Post-replay checkpoint history (newest first) --
     post_replay_history = [s async for s in graph.aget_state_history(config)]
     post_summary = _checkpoint_summary(post_replay_history)
-    assert len(post_summary) == 7  # 5 original + 2 new branch checkpoints
+    # 5 original + 1 fork + 2 new branch checkpoints = 8
+    assert len(post_summary) == 8
 
     assert [s["next"] for s in post_summary] == [
-        (),  # new branch tip (C6)
-        ("node_c",),  # new branch (C5)
-        (),  # old branch tip (C4)
-        ("node_c",),  # old (C3)
+        (),  # new branch tip
+        ("node_c",),  # new branch
+        ("node_b",),  # fork from replay point
+        (),  # old branch tip
+        ("node_c",),  # old
         ("node_b",),  # branch point (C2)
         ("node_a",),  # old (C1)
         ("__start__",),  # old (C0)
@@ -2102,6 +2497,7 @@ async def test_replay_creates_branch_preserving_old_checkpoints(
     assert [s["values"] for s in post_summary] == [
         {"value": ["a", "b2", "c"]},  # new branch tip
         {"value": ["a", "b2"]},  # new: node_b re-ran with call_count=2
+        {"value": ["a"]},  # fork from replay point
         {"value": ["a", "b1", "c"]},  # old branch tip preserved
         {"value": ["a", "b1"]},  # old
         {"value": ["a"]},  # branch point

libs/langgraph/tests/test_tool_stream_handler.py

@@ -1,290 +0,0 @@
-"""Tests for StreamToolCallHandler and emit_tool_output_delta.
-
-These tests exercise the langgraph-core piece in isolation — the prebuilt
-`ToolCallTransformer` has its own test file. Here we feed real graphs
-through `Pregel.stream(stream_mode=["tools", ...])` and inspect the raw
-`(ns, mode, payload)` tuples on the `tools` channel.
-"""
-
-from __future__ import annotations
-
-from typing import Annotated, Any
-
-import pytest
-from langchain_core.messages import AIMessage
-from langchain_core.tools import tool
-from langgraph.prebuilt import ToolNode
-from typing_extensions import TypedDict
-
-from langgraph.config import emit_tool_output_delta
-from langgraph.constants import END, START
-from langgraph.graph import StateGraph
-from langgraph.graph.message import add_messages
-
-
-class _State(TypedDict):
-    messages: Annotated[list, add_messages]
-
-
-def _caller_sync(tool_name: str, tool_args: dict[str, Any], tc_id: str = "tc1"):
-    def caller(state: _State) -> dict:
-        return {
-            "messages": [
-                AIMessage(
-                    content="",
-                    tool_calls=[{"name": tool_name, "args": tool_args, "id": tc_id}],
-                )
-            ]
-        }
-
-    return caller
-
-
-def _caller_async(tool_name: str, tool_args: dict[str, Any], tc_id: str = "tc1"):
-    async def caller(state: _State) -> dict:
-        return {
-            "messages": [
-                AIMessage(
-                    content="",
-                    tool_calls=[{"name": tool_name, "args": tool_args, "id": tc_id}],
-                )
-            ]
-        }
-
-    return caller
-
-
-def _build_graph(caller, tools) -> Any:
-    sg = StateGraph(_State)
-    sg.add_node("caller", caller)
-    sg.add_node("tools", ToolNode(tools))
-    sg.add_edge(START, "caller")
-    sg.add_edge("caller", "tools")
-    sg.add_edge("tools", END)
-    return sg.compile()
-
-
-def _tool_events(stream) -> list[tuple[tuple[str, ...], dict]]:
-    """Collect `(ns, payload)` for every `tools`-mode chunk."""
-    out: list[tuple[tuple[str, ...], dict]] = []
-    for ns, mode, payload in stream:
-        if mode == "tools":
-            out.append((tuple(ns), payload))
-    return out
-
-
-class TestSyncGraphSyncTool:
-    def test_started_finished_cycle(self) -> None:
-        @tool
-        def echo(text: str) -> str:
-            """echo."""
-            return f"echoed:{text}"
-
-        graph = _build_graph(_caller_sync("echo", {"text": "hi"}), [echo])
-        events = _tool_events(
-            graph.stream(
-                {"messages": []},
-                stream_mode=["tools"],
-                subgraphs=True,
-            )
-        )
-
-        assert [p["event"] for _, p in events] == [
-            "tool-started",
-            "tool-finished",
-        ]
-        assert events[0][1]["tool_call_id"] == "tc1"
-        assert events[0][1]["tool_name"] == "echo"
-        assert events[0][1]["input"] == {"text": "hi"}
-        # ToolNode wraps the return in a ToolMessage.
-        assert events[1][1]["tool_call_id"] == "tc1"
-
-    def test_emit_tool_output_delta_produces_delta_events(self) -> None:
-        @tool
-        def streaming_echo(text: str) -> str:
-            """stream chunks."""
-            for chunk in ("a", "b", "c"):
-                emit_tool_output_delta(chunk)
-            return text
-
-        graph = _build_graph(
-            _caller_sync("streaming_echo", {"text": "x"}), [streaming_echo]
-        )
-        events = _tool_events(
-            graph.stream(
-                {"messages": []},
-                stream_mode=["tools"],
-                subgraphs=True,
-            )
-        )
-
-        deltas = [p["delta"] for _, p in events if p["event"] == "tool-output-delta"]
-        assert deltas == ["a", "b", "c"]
-        # The deltas must be bracketed by started and finished.
-        ordered = [p["event"] for _, p in events]
-        assert ordered[0] == "tool-started"
-        assert ordered[-1] == "tool-finished"
-
-    def test_tool_error_event(self) -> None:
-        @tool
-        def boom() -> str:
-            """raises."""
-            raise ValueError("nope")
-
-        graph = _build_graph(_caller_sync("boom", {}), [boom])
-        events: list[tuple[tuple[str, ...], dict]] = []
-        with pytest.raises(ValueError, match="nope"):
-            for ns, mode, payload in graph.stream(
-                {"messages": []},
-                stream_mode=["tools"],
-                subgraphs=True,
-            ):
-                if mode == "tools":
-                    events.append((tuple(ns), payload))
-
-        kinds = [p["event"] for _, p in events]
-        assert kinds == ["tool-started", "tool-error"]
-        assert events[1][1]["message"] == "nope"
-
-    def test_emit_outside_tool_is_noop(self) -> None:
-        # Called at import time (outside any tool body) — must not raise.
-        emit_tool_output_delta("ignored")
-        emit_tool_output_delta({"any": "payload"})
-
-    def test_no_events_without_tools_mode(self) -> None:
-        @tool
-        def echo(text: str) -> str:
-            """echo."""
-            return text
-
-        graph = _build_graph(_caller_sync("echo", {"text": "hi"}), [echo])
-        # No "tools" in stream_mode — handler is not attached and zero
-        # `tools`-method events fire.
-        chunks = list(
-            graph.stream(
-                {"messages": []},
-                stream_mode=["values"],
-                subgraphs=True,
-            )
-        )
-        assert all(
-            not (isinstance(c, tuple) and len(c) == 3 and c[1] == "tools")
-            for c in chunks
-        )
-
-
-class TestAsyncGraphAsyncTool:
-    @pytest.mark.anyio
-    async def test_async_tool_produces_events(self) -> None:
-        @tool
-        async def aecho(text: str) -> str:
-            """async echo."""
-            emit_tool_output_delta(text)
-            return f"got:{text}"
-
-        graph = _build_graph(_caller_async("aecho", {"text": "hi"}), [aecho])
-        events: list[tuple[tuple[str, ...], dict]] = []
-        async for ns, mode, payload in graph.astream(
-            {"messages": []},
-            stream_mode=["tools"],
-            subgraphs=True,
-        ):
-            if mode == "tools":
-                events.append((tuple(ns), payload))
-
-        kinds = [p["event"] for _, p in events]
-        assert kinds == ["tool-started", "tool-output-delta", "tool-finished"]
-        assert events[1][1]["delta"] == "hi"
-
-
-class TestConcurrentToolCalls:
-    def test_parallel_tool_calls_do_not_bleed(self) -> None:
-        @tool
-        def streamer(marker: str) -> str:
-            """emits marker twice."""
-            emit_tool_output_delta(f"{marker}-1")
-            emit_tool_output_delta(f"{marker}-2")
-            return marker
-
-        def caller(state: _State) -> dict:
-            return {
-                "messages": [
-                    AIMessage(
-                        content="",
-                        tool_calls=[
-                            {"name": "streamer", "args": {"marker": "A"}, "id": "a"},
-                            {"name": "streamer", "args": {"marker": "B"}, "id": "b"},
-                        ],
-                    )
-                ]
-            }
-
-        graph = _build_graph(caller, [streamer])
-        events = _tool_events(
-            graph.stream(
-                {"messages": []},
-                stream_mode=["tools"],
-                subgraphs=True,
-            )
-        )
-
-        # Group deltas by tool_call_id.
-        by_id: dict[str, list[str]] = {}
-        for _, p in events:
-            if p["event"] == "tool-output-delta":
-                by_id.setdefault(p["tool_call_id"], []).append(p["delta"])
-        assert by_id["a"] == ["A-1", "A-2"]
-        assert by_id["b"] == ["B-1", "B-2"]
-
-
-class TestSubgraphNamespacePropagation:
-    def test_tool_inside_subgraph_emits_with_subgraph_ns(self) -> None:
-        @tool
-        def inner_tool(text: str) -> str:
-            """inner tool."""
-            return text
-
-        def sub_caller(state: _State) -> dict:
-            return {
-                "messages": [
-                    AIMessage(
-                        content="",
-                        tool_calls=[
-                            {
-                                "name": "inner_tool",
-                                "args": {"text": "x"},
-                                "id": "tc1",
-                            }
-                        ],
-                    )
-                ]
-            }
-
-        inner = StateGraph(_State)
-        inner.add_node("sub_caller", sub_caller)
-        inner.add_node("sub_tools", ToolNode([inner_tool]))
-        inner.add_edge(START, "sub_caller")
-        inner.add_edge("sub_caller", "sub_tools")
-        inner.add_edge("sub_tools", END)
-        inner_graph = inner.compile()
-
-        outer = StateGraph(_State)
-        outer.add_node("sub", inner_graph)
-        outer.add_edge(START, "sub")
-        outer.add_edge("sub", END)
-        graph = outer.compile()
-
-        events = _tool_events(
-            graph.stream(
-                {"messages": []},
-                stream_mode=["tools"],
-                subgraphs=True,
-            )
-        )
-
-        # All `tools` events should carry a non-empty namespace rooted
-        # at the `sub` node.
-        assert events, "expected at least one tools event"
-        for ns, _ in events:
-            assert ns  # non-empty
-            assert ns[0].startswith("sub:")

libs/langgraph/uv.lock

@@ -1348,11 +1348,10 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.3.2"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
-    { name = "langchain-protocol" },
     { name = "langsmith" },
     { name = "packaging" },
     { name = "pydantic" },
@@ -1361,26 +1360,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a8/03/7219502e8ca728d65eb44d7a3eb60239230742a70dbfc9241b9bfd61c4ab/langchain_core-1.3.2.tar.gz", hash = "sha256:fd7a50b2f28ba561fd9d7f5d2760bc9e06cf00cdf820a3ccafe88a94ffa8d5b7", size = 911813, upload-time = "2026-04-24T15:49:23.699Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/fe/20190232d9b513242899dbb0c2bb77e31b4d61e343743adbe90ebc2603d2/langchain_core-1.3.0.tar.gz", hash = "sha256:14a39f528bf459aa3aa40d0a7f7f1bae7520d435ef991ae14a4ceb74d8c49046", size = 860755, upload-time = "2026-04-17T14:51:38.298Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7d/d5/8fa4431007cbb7cfed7590f4d6a5dea3ad724f4174d248f6642ef5ce7d05/langchain_core-1.3.2-py3-none-any.whl", hash = "sha256:d44a66127f9f8db735bdfd0ab9661bccb47a97113cfd3f2d89c74864422b7274", size = 542390, upload-time = "2026-04-24T15:49:21.991Z" },
-]
-
-[[package]]
-name = "langchain-protocol"
-version = "0.0.12"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "typing-extensions" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/51/1157009b6f94e6e58be58fa8b620187d657909a8b36a6bf5b0c52a2711f6/langchain_protocol-0.0.12.tar.gz", hash = "sha256:5e14c434290a705c9510fdb1a83ecf7561a5e6e0dfd053930ade80dba069269f", size = 6408, upload-time = "2026-04-25T01:05:01.489Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/95/82/3431e3061c917439589fa88a6b23c9bc0e154cba0f05d2e895a68c76ff74/langchain_protocol-0.0.12-py3-none-any.whl", hash = "sha256:402b61f42d4139692528cf37226c367bb6efc8ff8165b29380accb0abfece7b2", size = 6639, upload-time = "2026-04-25T01:05:00.487Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e2/dbfa347aa072a6dc4cd38d6f9ebfc730b4c14c258c47f480f4c5c546f177/langchain_core-1.3.0-py3-none-any.whl", hash = "sha256:baf16ee028475df177b9ab8869a751c79406d64a6f12125b93802991b566cced", size = 515140, upload-time = "2026-04-17T14:51:36.274Z" },
 ]
 
 [[package]]
 name = "langgraph"
-version = "1.1.7a2"
+version = "1.1.9"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
@@ -1452,7 +1439,7 @@ test = [
 
 [package.metadata]
 requires-dist = [
-    { name = "langchain-core", specifier = ">=1.3.2" },
+    { name = "langchain-core", specifier = ">=1.3.0,<2" },
     { name = "langgraph-checkpoint", editable = "../checkpoint" },
     { name = "langgraph-prebuilt", editable = "../prebuilt" },
     { name = "langgraph-sdk", editable = "../sdk-py" },
@@ -1561,7 +1548,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 source = { editable = "../checkpoint" }
 dependencies = [
     { name = "langchain-core" },
@@ -1719,7 +1706,7 @@ inmem = [
 requires-dist = [
     { name = "click", specifier = ">=8.1.7" },
     { name = "httpx", specifier = ">=0.24.0" },
-    { name = "langgraph-api", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.5.35,<0.8.0" },
+    { name = "langgraph-api", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.5.35,<0.9.0" },
     { name = "langgraph-runtime-inmem", marker = "python_full_version >= '3.11' and extra == 'inmem'", specifier = ">=0.7" },
     { name = "langgraph-sdk", marker = "python_full_version >= '3.11'", specifier = ">=0.1.0" },
     { name = "pathspec", specifier = ">=0.11.0" },
@@ -1755,7 +1742,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "1.0.9"
+version = "1.0.10"
 source = { editable = "../prebuilt" }
 dependencies = [
     { name = "langchain-core" },
@@ -1865,7 +1852,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.6.4"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -1875,11 +1862,12 @@ dependencies = [
     { name = "requests" },
     { name = "requests-toolbelt" },
     { name = "uuid-utils" },
+    { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/85/9c7933052a997da1b85bc5c774f3865e9b1da1c8d71541ea133178b13229/langsmith-0.6.4.tar.gz", hash = "sha256:36f7223a01c218079fbb17da5e536ebbaf5c1468c028abe070aa3ae59bc99ec8", size = 919964, upload-time = "2026-01-15T20:02:28.873Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/0f/09a6637a7ba777eb307b7c80852d9ee26438e2bdafbad6fcc849ff9d9192/langsmith-0.6.4-py3-none-any.whl", hash = "sha256:ac4835860160be371042c7adbba3cb267bcf8d96a5ea976c33a8a4acad6c5486", size = 283503, upload-time = "2026-01-15T20:02:26.662Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [package.optional-dependencies]

libs/prebuilt/langgraph/prebuilt/__init__.py

@@ -1,7 +1,5 @@
 """langgraph.prebuilt exposes a higher-level API for creating and executing agents and tools."""
 
-from langgraph.prebuilt._tool_call_stream import ToolCallStream
-from langgraph.prebuilt._tool_call_transformer import ToolCallTransformer
 from langgraph.prebuilt.chat_agent_executor import create_react_agent
 from langgraph.prebuilt.tool_node import (
     InjectedState,
@@ -15,8 +13,6 @@ from langgraph.prebuilt.tool_validator import ValidationNode
 __all__ = [
     "create_react_agent",
     "ToolNode",
-    "ToolCallStream",
-    "ToolCallTransformer",
     "tools_condition",
     "ValidationNode",
     "InjectedState",

libs/prebuilt/langgraph/prebuilt/_tool_call_stream.py

@@ -1,117 +0,0 @@
-"""In-process handle for a single tool call's streaming execution.
-
-Mirrors the shape of `ChatModelStream` from langchain-core but simpler —
-a tool has one output channel, no content-block multiplexing. Populated
-by `ToolCallTransformer` as `tool-started` / `tool-output-delta` /
-`tool-finished` / `tool-error` events flow in on the `tools` channel.
-"""
-
-from __future__ import annotations
-
-from collections.abc import AsyncIterator, Iterator
-from typing import Any
-
-from langgraph.stream._event_log import EventLog
-
-
-class ToolCallStream:
-    """Scoped view of a single tool call's lifecycle.
-
-    Yielded on `run.tool_calls` once per `tool-started` event. Fields
-    are populated as events arrive:
-
-    - `tool_call_id`, `tool_name`, `input`: stable from the start event.
-    - `output_deltas`: an `EventLog` of delta chunks. Iterate (sync or
-      async) to consume partial output in arrival order.
-    - `output`: terminal payload from `tool-finished`, or `None` if the
-      call failed or is still in flight.
-    - `error`: terminal error string from `tool-error`, or `None` if the
-      call succeeded or is still in flight.
-    - `completed`: True once a terminal event (`tool-finished` or
-      `tool-error`) has been observed.
-
-    `ToolCallStream` is not meant to be constructed by end users — it's
-    produced by `ToolCallTransformer` as events flow through the mux.
-    """
-
-    def __init__(
-        self,
-        tool_call_id: str,
-        tool_name: str,
-        input: dict[str, Any] | None = None,
-    ) -> None:
-        """Initialize a fresh handle for a tool call.
-
-        Args:
-            tool_call_id: The `tool_call_id` from the AIMessage.
-            tool_name: The tool's name.
-            input: The tool's input arguments (as reported by
-                `on_tool_start`), or `None` if none were captured.
-        """
-        self.tool_call_id = tool_call_id
-        self.tool_name = tool_name
-        self.input = input
-        self._output_deltas: EventLog[Any] = EventLog()
-        self.output: Any = None
-        self.error: str | None = None
-        self.completed = False
-
-    @property
-    def output_deltas(self) -> EventLog[Any]:
-        """The EventLog of streamed `tool-output-delta` payloads.
-
-        Iterate (sync or async depending on how the run was started)
-        to consume partial output in arrival order. The log closes when
-        the tool finishes or errors.
-        """
-        return self._output_deltas
-
-    def _bind(self, *, is_async: bool) -> None:
-        """Bind the deltas log to sync or async iteration.
-
-        Called by `ToolCallTransformer` when constructing this handle so
-        the log matches the enclosing mux's mode.
-        """
-        self._output_deltas._bind(is_async=is_async)
-
-    def _push_delta(self, delta: Any) -> None:
-        self._output_deltas.push(delta)
-
-    def _finish(self, output: Any) -> None:
-        self.output = output
-        self.completed = True
-        self._output_deltas.close()
-
-    def _fail(self, message: str) -> None:
-        self.error = message
-        self.completed = True
-        self._output_deltas.close()
-
-    def __iter__(self) -> Iterator[Any]:
-        """Iterate delta chunks synchronously.
-
-        Equivalent to `iter(self.output_deltas)`. Raises `TypeError` if
-        the underlying log is bound to async mode.
-        """
-        return iter(self._output_deltas)
-
-    def __aiter__(self) -> AsyncIterator[Any]:
-        """Iterate delta chunks asynchronously.
-
-        Equivalent to `aiter(self.output_deltas)`. Raises `TypeError`
-        if the underlying log is bound to sync mode.
-        """
-        return self._output_deltas.__aiter__()
-
-    def __repr__(self) -> str:
-        status = (
-            "completed"
-            if self.completed and self.error is None
-            else "failed"
-            if self.completed
-            else "running"
-        )
-        return (
-            f"ToolCallStream(tool_call_id={self.tool_call_id!r}, "
-            f"tool_name={self.tool_name!r}, status={status})"
-        )

libs/prebuilt/langgraph/prebuilt/_tool_call_transformer.py

@@ -1,128 +0,0 @@
-"""Transformer that projects `tools` channel events into `ToolCallStream`s."""
-
-from __future__ import annotations
-
-from collections.abc import Awaitable, Callable
-from typing import Any
-
-from langgraph.stream._event_log import EventLog
-from langgraph.stream._types import ProtocolEvent, StreamTransformer
-
-from langgraph.prebuilt._tool_call_stream import ToolCallStream
-
-
-class ToolCallTransformer(StreamTransformer):
-    """Project `tools` channel events into `ToolCallStream` handles.
-
-    Each `tool-started` event spawns a `ToolCallStream`, pushed onto
-    `run.tool_calls`. Subsequent `tool-output-delta` events append to
-    that stream's deltas log; `tool-finished` and `tool-error` close it.
-
-    Native transformer — the `tool_calls` projection is exposed as a
-    direct attribute on the run stream.
-
-    `EventLog[ToolCallStream]` is used (not `StreamChannel`) because the
-    live handles are not serializable and should not be auto-forwarded
-    onto the main event log. Wire consumers subscribe to the `tools`
-    channel instead, where the raw protocol events flow through
-    untouched by this transformer (`process` returns `True`).
-
-    Registered explicitly by users at compile time via
-    `builder.compile(transformers=[ToolCallTransformer])` — not a
-    default built-in, so the `tools` channel is user-opt-in.
-    """
-
-    _native = True
-    required_stream_modes = ("tools",)
-
-    def __init__(self, scope: tuple[str, ...] = ()) -> None:
-        super().__init__(scope)
-        self._log: EventLog[ToolCallStream] = EventLog()
-        self._active: dict[str, ToolCallStream] = {}
-        self._is_async = False
-        self._pump_fn: Callable[[], bool] | None = None
-        self._apump_fn: Callable[[], Awaitable[bool]] | None = None
-
-    def init(self) -> dict[str, Any]:
-        return {"tool_calls": self._log}
-
-    def _bind_pump(self, fn: Callable[[], bool]) -> None:
-        """Wire the sync pull callback onto this transformer.
-
-        Called by `StreamMux.bind_pump`. Stored so each new
-        `ToolCallStream` created by `process` can wire its deltas log
-        for pump-driven iteration.
-        """
-        self._pump_fn = fn
-        self._is_async = False
-
-    def _bind_apump(self, fn: Callable[[], Awaitable[bool]]) -> None:
-        """Async counterpart to `_bind_pump`."""
-        self._apump_fn = fn
-        self._is_async = True
-
-    def _new_stream(
-        self,
-        tool_call_id: str,
-        tool_name: str,
-        tool_input: dict[str, Any] | None,
-    ) -> ToolCallStream:
-        stream = ToolCallStream(tool_call_id, tool_name, tool_input)
-        stream._bind(is_async=self._is_async)
-        if self._apump_fn is not None:
-            stream._output_deltas._arequest_more = self._apump_fn
-        if self._pump_fn is not None:
-            stream._output_deltas._request_more = self._pump_fn
-        return stream
-
-    def process(self, event: ProtocolEvent) -> bool:
-        # Namespace filtering is handled by the mux via `scope_exact`.
-        if event["method"] != "tools":
-            return True
-
-        data = event["params"]["data"]
-        tool_call_id = data.get("tool_call_id")
-        if tool_call_id is None:
-            return True
-        event_type = data.get("event")
-
-        stream: ToolCallStream | None
-        if event_type == "tool-started":
-            stream = self._new_stream(
-                tool_call_id,
-                data.get("tool_name", ""),
-                data.get("input"),
-            )
-            self._active[tool_call_id] = stream
-            self._log.push(stream)
-        elif event_type == "tool-output-delta":
-            stream = self._active.get(tool_call_id)
-            if stream is not None:
-                stream._push_delta(data.get("delta"))
-        elif event_type == "tool-finished":
-            stream = self._active.pop(tool_call_id, None)
-            if stream is not None:
-                stream._finish(data.get("output"))
-        elif event_type == "tool-error":
-            stream = self._active.pop(tool_call_id, None)
-            if stream is not None:
-                stream._fail(data.get("message", ""))
-
-        # Pass-through — wire consumers subscribe to the `tools` channel
-        # directly and reconstruct handles client-side.
-        return True
-
-    def finalize(self) -> None:
-        """Close any still-active tool streams left open at run end."""
-        for stream in self._active.values():
-            if not stream.completed:
-                stream._finish(None)
-        self._active.clear()
-
-    def fail(self, err: BaseException) -> None:
-        """Fail any still-active tool streams when the run errors."""
-        message = str(err)
-        for stream in self._active.values():
-            if not stream.completed:
-                stream._fail(message)
-        self._active.clear()

libs/prebuilt/langgraph/prebuilt/tool_node.py

@@ -614,6 +614,7 @@ class _InjectedArgs:
     store: str | None
     runtime: str | None
     all_injected_keys: set[str]
+    _optional_state_args: set[str]
 
 
 class ToolNode(RunnableCallable):
@@ -807,6 +808,7 @@ class ToolNode(RunnableCallable):
                 context=runtime.context,
                 store=runtime.store,
                 stream_writer=runtime.stream_writer,
+                tools=list(self.tools_by_name.values()),
                 execution_info=runtime.execution_info,
                 server_info=runtime.server_info,
             )
@@ -841,6 +843,7 @@ class ToolNode(RunnableCallable):
                 context=runtime.context,
                 store=runtime.store,
                 stream_writer=runtime.stream_writer,
+                tools=list(self.tools_by_name.values()),
                 execution_info=runtime.execution_info,
                 server_info=runtime.server_info,
             )
@@ -1333,7 +1336,7 @@ class ToolNode(RunnableCallable):
             return tool_call
 
         tool_call_copy: ToolCall = copy(tool_call)
-        injected_args = {}
+        injected_args: dict[str, Any] = {}
 
         # Inject state
         if injected.state:
@@ -1361,14 +1364,20 @@ class ToolNode(RunnableCallable):
             # Extract state values
             if isinstance(state, dict):
                 for tool_arg, state_field in injected.state.items():
-                    injected_args[tool_arg] = (
-                        state[state_field] if state_field else state
-                    )
+                    if not state_field:
+                        injected_args[tool_arg] = state
+                    elif state_field in state:
+                        injected_args[tool_arg] = state[state_field]
+                    elif tool_arg not in injected._optional_state_args:
+                        raise KeyError(state_field)
             else:
                 for tool_arg, state_field in injected.state.items():
-                    injected_args[tool_arg] = (
-                        getattr(state, state_field) if state_field else state
-                    )
+                    if not state_field:
+                        injected_args[tool_arg] = state
+                    elif hasattr(state, state_field):
+                        injected_args[tool_arg] = getattr(state, state_field)
+                    elif tool_arg not in injected._optional_state_args:
+                        raise AttributeError(state_field)
 
         # Inject store
         if injected.store:
@@ -1569,6 +1578,7 @@ class ToolRuntime(_DirectlyInjectedToolArg, Generic[ContextT, StateT]):
     - `context`: Runtime context (shared with `Runtime`)
     - `store`: `BaseStore` instance for persistent storage (shared with `Runtime`)
     - `stream_writer`: `StreamWriter` for streaming output (shared with `Runtime`)
+    - `tools`: List of all available `BaseTool` instances
 
     No `Annotated` wrapper is needed - just use `runtime: ToolRuntime`
     as a parameter.
@@ -1611,6 +1621,7 @@ class ToolRuntime(_DirectlyInjectedToolArg, Generic[ContextT, StateT]):
     context: ContextT
     config: RunnableConfig
     stream_writer: StreamWriter
+    tools: list[BaseTool]
     tool_call_id: str | None
     store: BaseStore | None
     execution_info: ExecutionInfo | None = None
@@ -1859,6 +1870,7 @@ def _get_all_injected_args(tool: BaseTool) -> _InjectedArgs:
     store_arg: str | None = None
     runtime_arg: str | None = None
     all_injected_keys: set[str] = set()
+    _optional_state_args: set[str] = set()
 
     for name, type_ in all_annotations.items():
         # Track all InjectedToolArg-annotated params (including custom subclasses)
@@ -1873,6 +1885,9 @@ def _get_all_injected_args(tool: BaseTool) -> _InjectedArgs:
         if state_inj := _get_injection_from_type(type_, InjectedState):
             if isinstance(state_inj, InjectedState) and state_inj.field:
                 state_args[name] = state_inj.field
+                field_info = full_schema.model_fields.get(name)
+                if field_info and not field_info.is_required():
+                    _optional_state_args.add(name)
             else:
                 state_args[name] = None
 
@@ -1889,4 +1904,5 @@ def _get_all_injected_args(tool: BaseTool) -> _InjectedArgs:
         store=store_arg,
         runtime=runtime_arg,
         all_injected_keys=all_injected_keys,
+        _optional_state_args=_optional_state_args,
     )

libs/prebuilt/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph-prebuilt"
-version = "1.0.9"
+version = "1.0.10"
 description = "Library with high-level APIs for creating and executing LangGraph agents and tools."
 authors = []
 requires-python = ">=3.10"

libs/prebuilt/tests/test_injected_state_not_required.py

@@ -0,0 +1,285 @@
+"""Test InjectedState with NotRequired state fields.
+
+This tests the fix for https://github.com/langchain-ai/langchain/issues/35585
+
+When using InjectedState(<field>) on a tool parameter, and the referenced field is
+declared as NotRequired in the custom state schema, the ToolNode should gracefully
+handle missing fields by injecting None instead of raising KeyError.
+"""
+
+import sys
+from typing import Annotated
+
+import pytest
+from langchain_core.messages import AIMessage, AnyMessage, HumanMessage, ToolMessage
+from langchain_core.tools import tool
+from langgraph.graph.message import add_messages
+from pydantic import BaseModel, Field
+from typing_extensions import NotRequired
+
+from langgraph.prebuilt import InjectedState, ToolNode, create_react_agent
+from langgraph.prebuilt.chat_agent_executor import AgentState
+
+from .model import FakeToolCallingModel
+
+
+class CustomAgentStateWithNotRequired(AgentState):
+    """Custom state with a NotRequired field (TypedDict style)."""
+
+    city: NotRequired[str]
+
+
+class CustomAgentStatePydanticWithDefault(BaseModel):
+    """Custom state with Optional field and default (Pydantic style)."""
+
+    messages: Annotated[list[AnyMessage], add_messages]
+    remaining_steps: int = Field(default=10)
+    city: str | None = Field(default=None)
+
+
+@tool
+def get_weather(city: Annotated[str | None, InjectedState("city")] = None) -> str:
+    """Get weather for a given city."""
+    if city is None:
+        return "No city provided"
+    return f"It's always sunny in {city}!"
+
+
+def _create_mock_runtime(
+    state: dict | None = None,
+    store=None,
+):
+    """Create a mock Runtime for testing ToolNode directly."""
+    from unittest.mock import Mock
+
+    from langgraph.runtime import Runtime
+
+    mock_runtime = Mock(spec=Runtime)
+    mock_runtime.context = {}
+    return mock_runtime
+
+
+def _create_config_with_runtime(store=None, state=None):
+    """Create a RunnableConfig with mocked runtime for direct ToolNode testing."""
+    from langgraph.prebuilt.tool_node import ToolRuntime
+
+    tool_runtime = ToolRuntime(
+        state=state or {},
+        config={},
+        context={},
+        store=store,
+        stream_writer=None,
+        tools=[],
+        tool_call_id="test_id",
+    )
+    return {
+        "configurable": {
+            "__pregel_runtime": _create_mock_runtime(),
+            "__tool_runtime__": tool_runtime,
+        }
+    }
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="InjectedState field extraction from Optional[Annotated[...]] not supported on Python <3.11",
+)
+def test_injected_state_not_required_field_missing_injects_none():
+    """Test that InjectedState with NotRequired field injects None when field is missing.
+
+    This verifies the fix for https://github.com/langchain-ai/langchain/issues/35585
+    """
+    tool_node = ToolNode([get_weather])
+
+    tool_call = {
+        "name": "get_weather",
+        "args": {},
+        "id": "call_1",
+        "type": "tool_call",
+    }
+    ai_msg = AIMessage("Let me check the weather", tool_calls=[tool_call])
+
+    # State WITHOUT the "city" field - should inject None instead of raising KeyError
+    state_without_city: CustomAgentStateWithNotRequired = {
+        "messages": [HumanMessage("What's the weather?"), ai_msg],
+    }
+
+    result = tool_node.invoke(
+        state_without_city,
+        config=_create_config_with_runtime(state=state_without_city),
+    )
+
+    assert len(result["messages"]) == 1
+    tool_msg = result["messages"][0]
+    assert isinstance(tool_msg, ToolMessage)
+    assert "No city provided" in tool_msg.content
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="InjectedState field extraction from Optional[Annotated[...]] not supported on Python <3.11",
+)
+def test_injected_state_not_required_field_present_works():
+    """Test that InjectedState with NotRequired field works when field IS present."""
+    tool_node = ToolNode([get_weather])
+
+    tool_call = {
+        "name": "get_weather",
+        "args": {},
+        "id": "call_1",
+        "type": "tool_call",
+    }
+    ai_msg = AIMessage("Let me check the weather", tool_calls=[tool_call])
+
+    # State WITH the "city" field - this should work
+    state_with_city: CustomAgentStateWithNotRequired = {
+        "messages": [HumanMessage("What's the weather?"), ai_msg],
+        "city": "San Francisco",
+    }
+
+    result = tool_node.invoke(
+        state_with_city,
+        config=_create_config_with_runtime(state=state_with_city),
+    )
+
+    assert len(result["messages"]) == 1
+    tool_msg = result["messages"][0]
+    assert isinstance(tool_msg, ToolMessage)
+    assert "San Francisco" in tool_msg.content
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="InjectedState field extraction from Optional[Annotated[...]] not supported on Python <3.11",
+)
+def test_create_react_agent_injected_state_not_required_field_missing():
+    """Test create_react_agent with InjectedState using NotRequired field that is missing.
+
+    This verifies the fix for https://github.com/langchain-ai/langchain/issues/35585
+    """
+    model = FakeToolCallingModel(
+        tool_calls=[
+            [{"name": "get_weather", "args": {}, "id": "call_1"}],
+            [],  # No more tool calls, agent should stop
+        ]
+    )
+
+    agent = create_react_agent(
+        model,
+        tools=[get_weather],
+        state_schema=CustomAgentStateWithNotRequired,
+    )
+
+    # Invoke WITHOUT the city field - should work, injecting None
+    result = agent.invoke(
+        {"messages": [HumanMessage("What's the weather?")]},
+    )
+
+    # Check that the tool was called successfully with None injected
+    messages = result["messages"]
+    tool_messages = [m for m in messages if isinstance(m, ToolMessage)]
+    assert len(tool_messages) == 1
+    assert "No city provided" in tool_messages[0].content
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="InjectedState field extraction from Optional[Annotated[...]] not supported on Python <3.11",
+)
+def test_create_react_agent_injected_state_not_required_field_present():
+    """Test create_react_agent with InjectedState using NotRequired field that IS present."""
+    model = FakeToolCallingModel(
+        tool_calls=[
+            [{"name": "get_weather", "args": {}, "id": "call_1"}],
+            [],  # No more tool calls, agent should stop
+        ]
+    )
+
+    agent = create_react_agent(
+        model,
+        tools=[get_weather],
+        state_schema=CustomAgentStateWithNotRequired,
+    )
+
+    # Invoke WITH the city field
+    result = agent.invoke(
+        {
+            "messages": [HumanMessage("What's the weather?")],
+            "city": "San Francisco",
+        },
+    )
+
+    # Check that the tool was called successfully
+    messages = result["messages"]
+    tool_messages = [m for m in messages if isinstance(m, ToolMessage)]
+    assert len(tool_messages) == 1
+    assert "San Francisco" in tool_messages[0].content
+
+
+@tool
+def get_weather_optional(city: Annotated[str | None, InjectedState("city")]) -> str:
+    """Get weather for a given city (accepts None)."""
+    if city is None:
+        return "Please provide a city!"
+    return f"It's always sunny in {city}!"
+
+
+def test_pydantic_state_with_default_field_missing_works():
+    """Test that Pydantic state with Optional field and default=None works when field is missing.
+
+    This is the workaround suggested in the issue comments - using Pydantic BaseModel
+    with `city: Optional[str] = Field(default=None)` instead of TypedDict with NotRequired.
+    """
+    model = FakeToolCallingModel(
+        tool_calls=[
+            [{"name": "get_weather_optional", "args": {}, "id": "call_1"}],
+            [],  # No more tool calls, agent should stop
+        ]
+    )
+
+    agent = create_react_agent(
+        model,
+        tools=[get_weather_optional],
+        state_schema=CustomAgentStatePydanticWithDefault,
+    )
+
+    # Invoke WITHOUT the city field - should work because Pydantic provides default
+    result = agent.invoke(
+        {"messages": [HumanMessage("What's the weather?")]},
+    )
+
+    # Check that the tool was called successfully with None
+    messages = result["messages"]
+    tool_messages = [m for m in messages if isinstance(m, ToolMessage)]
+    assert len(tool_messages) == 1
+    assert "Please provide a city!" in tool_messages[0].content
+
+
+def test_pydantic_state_with_default_field_present_works():
+    """Test that Pydantic state with Optional field works when field IS present."""
+    model = FakeToolCallingModel(
+        tool_calls=[
+            [{"name": "get_weather_optional", "args": {}, "id": "call_1"}],
+            [],  # No more tool calls, agent should stop
+        ]
+    )
+
+    agent = create_react_agent(
+        model,
+        tools=[get_weather_optional],
+        state_schema=CustomAgentStatePydanticWithDefault,
+    )
+
+    # Invoke WITH the city field
+    result = agent.invoke(
+        {
+            "messages": [HumanMessage("What's the weather?")],
+            "city": "San Francisco",
+        },
+    )
+
+    # Check that the tool was called successfully
+    messages = result["messages"]
+    tool_messages = [m for m in messages if isinstance(m, ToolMessage)]
+    assert len(tool_messages) == 1
+    assert "San Francisco" in tool_messages[0].content

libs/prebuilt/tests/test_tool_call_transformer.py

@@ -1,306 +0,0 @@
-"""Tests for ToolCallTransformer and the ToolCallStream projection."""
-
-from __future__ import annotations
-
-import time
-from typing import Annotated, Any
-
-import pytest
-from langchain_core.messages import AIMessage
-from langchain_core.tools import tool
-from langgraph.config import emit_tool_output_delta
-from langgraph.constants import END, START
-from langgraph.graph import StateGraph
-from langgraph.graph.message import add_messages
-from langgraph.stream._event_log import EventLog
-from langgraph.stream._mux import StreamMux
-from langgraph.stream._types import ProtocolEvent
-from langgraph.stream.transformers import (
-    MessagesTransformer,
-    SubgraphTransformer,
-    ValuesTransformer,
-)
-from typing_extensions import TypedDict
-
-from langgraph.prebuilt import ToolCallStream, ToolCallTransformer, ToolNode
-
-TS = int(time.time() * 1000)
-
-
-def _tool_event(
-    event: str,
-    tool_call_id: str,
-    *,
-    tool_name: str = "",
-    input: dict[str, Any] | None = None,
-    delta: Any = None,
-    output: Any = None,
-    message: str = "",
-    namespace: list[str] | None = None,
-) -> ProtocolEvent:
-    data: dict[str, Any] = {"event": event, "tool_call_id": tool_call_id}
-    if event == "tool-started":
-        data["tool_name"] = tool_name
-        if input is not None:
-            data["input"] = input
-    elif event == "tool-output-delta":
-        data["delta"] = delta
-    elif event == "tool-finished":
-        data["output"] = output
-    elif event == "tool-error":
-        data["message"] = message
-    return {
-        "type": "event",
-        "method": "tools",
-        "params": {
-            "namespace": namespace or [],
-            "timestamp": TS,
-            "data": data,
-        },
-    }
-
-
-def _subscribe(log: EventLog) -> None:
-    log._subscribed = True
-
-
-def _mux() -> tuple[StreamMux, ToolCallTransformer]:
-    mux = StreamMux(
-        factories=[
-            ValuesTransformer,
-            MessagesTransformer,
-            SubgraphTransformer,
-            ToolCallTransformer,
-        ],
-        is_async=False,
-    )
-    transformer = mux.transformer_by_key("tool_calls")
-    assert isinstance(transformer, ToolCallTransformer)
-    _subscribe(transformer._log)
-    return mux, transformer
-
-
-class TestToolCallTransformerUnit:
-    def test_required_stream_modes_declares_tools(self) -> None:
-        assert ToolCallTransformer.required_stream_modes == ("tools",)
-
-    def test_tool_started_yields_handle(self) -> None:
-        mux, transformer = _mux()
-        mux.push(
-            _tool_event(
-                "tool-started",
-                "tc1",
-                tool_name="echo",
-                input={"text": "hi"},
-            )
-        )
-        handles = list(transformer._log._items)
-        assert len(handles) == 1
-        h = handles[0]
-        assert isinstance(h, ToolCallStream)
-        assert h.tool_call_id == "tc1"
-        assert h.tool_name == "echo"
-        assert h.input == {"text": "hi"}
-        assert h.completed is False
-
-    def test_delta_accumulates_on_active_stream(self) -> None:
-        mux, transformer = _mux()
-        mux.push(_tool_event("tool-started", "tc1", tool_name="echo"))
-        _subscribe(transformer._active["tc1"]._output_deltas)
-        mux.push(_tool_event("tool-output-delta", "tc1", delta="a"))
-        mux.push(_tool_event("tool-output-delta", "tc1", delta="b"))
-        stream = transformer._active["tc1"]
-        assert list(stream._output_deltas._items) == ["a", "b"]
-
-    def test_finish_closes_stream(self) -> None:
-        mux, transformer = _mux()
-        mux.push(_tool_event("tool-started", "tc1", tool_name="echo"))
-        stream = transformer._active["tc1"]
-        mux.push(_tool_event("tool-finished", "tc1", output="done"))
-        assert stream.completed is True
-        assert stream.output == "done"
-        assert stream.error is None
-        assert "tc1" not in transformer._active
-
-    def test_error_closes_stream(self) -> None:
-        mux, transformer = _mux()
-        mux.push(_tool_event("tool-started", "tc1", tool_name="boom"))
-        stream = transformer._active["tc1"]
-        mux.push(_tool_event("tool-error", "tc1", message="nope"))
-        assert stream.completed is True
-        assert stream.output is None
-        assert stream.error == "nope"
-        assert "tc1" not in transformer._active
-
-    def test_concurrent_tool_calls_do_not_bleed(self) -> None:
-        mux, transformer = _mux()
-        mux.push(_tool_event("tool-started", "a", tool_name="t"))
-        mux.push(_tool_event("tool-started", "b", tool_name="t"))
-        for tc in ("a", "b"):
-            _subscribe(transformer._active[tc]._output_deltas)
-        mux.push(_tool_event("tool-output-delta", "a", delta="A1"))
-        mux.push(_tool_event("tool-output-delta", "b", delta="B1"))
-        mux.push(_tool_event("tool-output-delta", "a", delta="A2"))
-        assert list(transformer._active["a"]._output_deltas._items) == ["A1", "A2"]
-        assert list(transformer._active["b"]._output_deltas._items) == ["B1"]
-
-    def test_tools_event_passes_through_main_log(self) -> None:
-        mux, transformer = _mux()
-        _subscribe(mux._events)
-        mux.push(_tool_event("tool-started", "tc1", tool_name="echo"))
-        kept = [e for e in mux._events._items if e["method"] == "tools"]
-        assert len(kept) == 1
-
-
-# ---------------------------------------------------------------------------
-# End-to-end tests with a real graph
-# ---------------------------------------------------------------------------
-
-
-class _State(TypedDict):
-    messages: Annotated[list, add_messages]
-
-
-def _build_graph(caller, tools):
-    sg = StateGraph(_State)
-    sg.add_node("caller", caller)
-    sg.add_node("tools", ToolNode(tools))
-    sg.add_edge(START, "caller")
-    sg.add_edge("caller", "tools")
-    sg.add_edge("tools", END)
-    return sg.compile()
-
-
-class TestToolCallTransformerEndToEnd:
-    def test_sync_streaming_tool_populates_tool_calls(self) -> None:
-        @tool
-        def streamer(text: str) -> str:
-            """streams chunks."""
-            for chunk in ("one", "two"):
-                emit_tool_output_delta(chunk)
-            return text
-
-        def caller(state: _State) -> dict:
-            return {
-                "messages": [
-                    AIMessage(
-                        content="",
-                        tool_calls=[
-                            {"name": "streamer", "args": {"text": "x"}, "id": "tc1"}
-                        ],
-                    )
-                ]
-            }
-
-        graph = _build_graph(caller, [streamer])
-        run = graph.stream_v2({"messages": []}, transformers=[ToolCallTransformer])
-
-        tool_calls: list[ToolCallStream] = []
-        for tc in run.tool_calls:
-            tool_calls.append(tc)
-            deltas = list(tc.output_deltas)
-            assert deltas == ["one", "two"]
-        assert len(tool_calls) == 1
-        tc = tool_calls[0]
-        assert tc.tool_call_id == "tc1"
-        assert tc.tool_name == "streamer"
-        assert tc.completed is True
-        assert tc.error is None
-
-    def test_stream_modes_union_includes_tools(self) -> None:
-        @tool
-        def echo(text: str) -> str:
-            """echo."""
-            return text
-
-        def caller(state: _State) -> dict:
-            return {
-                "messages": [
-                    AIMessage(
-                        content="",
-                        tool_calls=[
-                            {"name": "echo", "args": {"text": "x"}, "id": "tc1"}
-                        ],
-                    )
-                ]
-            }
-
-        graph = _build_graph(caller, [echo])
-        # Without ToolCallTransformer, no tool_calls projection is
-        # exposed and no `tools` events flow through (required_stream_modes
-        # omits it).
-        run_no_tc = graph.stream_v2({"messages": []})
-        assert "tool_calls" not in run_no_tc._mux.extensions  # type: ignore[attr-defined]
-
-        # With ToolCallTransformer, the projection is present.
-        run = graph.stream_v2({"messages": []}, transformers=[ToolCallTransformer])
-        assert "tool_calls" in run._mux.extensions  # type: ignore[attr-defined]
-        # Drain so the run closes cleanly.
-        list(run.tool_calls)
-
-    @pytest.mark.anyio
-    async def test_async_streaming_tool_populates_tool_calls(self) -> None:
-        @tool
-        async def astreamer(text: str) -> str:
-            """async streams."""
-            emit_tool_output_delta(text)
-            emit_tool_output_delta(text + "!")
-            return text
-
-        async def caller(state: _State) -> dict:
-            return {
-                "messages": [
-                    AIMessage(
-                        content="",
-                        tool_calls=[
-                            {"name": "astreamer", "args": {"text": "hi"}, "id": "tc1"}
-                        ],
-                    )
-                ]
-            }
-
-        graph = _build_graph(caller, [astreamer])
-        run = await graph.astream_v2(
-            {"messages": []}, transformers=[ToolCallTransformer]
-        )
-
-        collected: list[ToolCallStream] = []
-        async for tc in run.tool_calls:
-            collected.append(tc)
-            deltas = [d async for d in tc.output_deltas]
-            assert deltas == ["hi", "hi!"]
-        assert len(collected) == 1
-        assert collected[0].completed is True
-        assert collected[0].error is None
-
-    def test_tool_error_populates_error_field(self) -> None:
-        @tool
-        def boom() -> str:
-            """raises."""
-            raise ValueError("nope")
-
-        def caller(state: _State) -> dict:
-            return {
-                "messages": [
-                    AIMessage(
-                        content="",
-                        tool_calls=[{"name": "boom", "args": {}, "id": "tc1"}],
-                    )
-                ]
-            }
-
-        graph = _build_graph(caller, [boom])
-        run = graph.stream_v2({"messages": []}, transformers=[ToolCallTransformer])
-
-        collected: list[ToolCallStream] = []
-        with pytest.raises(ValueError, match="nope"):
-            for tc in run.tool_calls:
-                collected.append(tc)
-                # Drain deltas so the error field is populated before we
-                # inspect it below.
-                list(tc.output_deltas)
-
-        assert len(collected) == 1
-        assert collected[0].error == "nope"
-        assert collected[0].output is None
-        assert collected[0].completed is True

libs/prebuilt/tests/test_tool_node.py

@@ -2016,8 +2016,8 @@ async def test_tool_node_inject_runtime_dynamic_tool_via_wrap_tool_call_async()
     assert tool_message.tool_call_id == "call_dynamic_2"
 
 
-def test_tool_runtime_forwards_execution_info_and_server_info() -> None:
-    """Test that execution_info and server_info are forwarded from Runtime to ToolRuntime."""
+def test_tool_runtime_forwards_execution_info_server_info_and_tools() -> None:
+    """Test that execution_info, server_info, and tools are forwarded from Runtime to ToolRuntime."""
     from langgraph.runtime import ExecutionInfo, ServerInfo
 
     exec_info = ExecutionInfo(
@@ -2043,9 +2043,15 @@ def test_tool_runtime_forwards_execution_info_and_server_info() -> None:
         """Tool that captures runtime info."""
         captured["execution_info"] = runtime.execution_info
         captured["server_info"] = runtime.server_info
+        captured["tools"] = runtime.tools
         return "ok"
 
-    node = ToolNode([info_tool])
+    @dec_tool
+    def other_tool(y: int) -> str:
+        """Another tool available to the runtime."""
+        return str(y)
+
+    node = ToolNode([info_tool, other_tool])
     tool_call = {
         "name": "info_tool",
         "args": {"x": 1},
@@ -2054,17 +2060,21 @@ def test_tool_runtime_forwards_execution_info_and_server_info() -> None:
     }
     msg = AIMessage("", tool_calls=[tool_call])
     config: RunnableConfig = {"configurable": {"__pregel_runtime": mock_runtime}}
-    node.invoke({"messages": [msg]}, config=config)
+    result = node.invoke({"messages": [msg]}, config=config)
 
+    assert result["messages"][-1].content == "ok"
     assert captured["execution_info"] is exec_info
     assert captured["execution_info"].thread_id == "t-1"
     assert captured["execution_info"].task_id == "tk-1"
     assert captured["server_info"] is server_info
     assert captured["server_info"].assistant_id == "asst-1"
+    assert [tool.name for tool in captured["tools"]] == ["info_tool", "other_tool"]
 
 
-async def test_tool_runtime_forwards_execution_info_and_server_info_async() -> None:
-    """Test that execution_info and server_info are forwarded in async path."""
+async def test_tool_runtime_forwards_execution_info_server_info_and_tools_async() -> (
+    None
+):
+    """Test that execution_info, server_info, and tools are forwarded in async path."""
     from langgraph.runtime import ExecutionInfo, ServerInfo
 
     exec_info = ExecutionInfo(
@@ -2090,9 +2100,15 @@ async def test_tool_runtime_forwards_execution_info_and_server_info_async() -> N
         """Async tool that captures runtime info."""
         captured["execution_info"] = runtime.execution_info
         captured["server_info"] = runtime.server_info
+        captured["tools"] = runtime.tools
         return "ok"
 
-    node = ToolNode([info_tool_async])
+    @dec_tool
+    async def other_tool_async(y: int) -> str:
+        """Another async tool available to the runtime."""
+        return str(y)
+
+    node = ToolNode([info_tool_async, other_tool_async])
     tool_call = {
         "name": "info_tool_async",
         "args": {"x": 1},
@@ -2101,12 +2117,17 @@ async def test_tool_runtime_forwards_execution_info_and_server_info_async() -> N
     }
     msg = AIMessage("", tool_calls=[tool_call])
     config: RunnableConfig = {"configurable": {"__pregel_runtime": mock_runtime}}
-    await node.ainvoke({"messages": [msg]}, config=config)
+    result = await node.ainvoke({"messages": [msg]}, config=config)
 
+    assert result["messages"][-1].content == "ok"
     assert captured["execution_info"] is exec_info
     assert captured["execution_info"].thread_id == "t-2"
     assert captured["server_info"] is server_info
     assert captured["server_info"].graph_id == "graph-2"
+    assert [tool.name for tool in captured["tools"]] == [
+        "info_tool_async",
+        "other_tool_async",
+    ]
 
 
 # --- InjectedToolArg security tests ---

libs/prebuilt/uv.lock

@@ -249,7 +249,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.3.0a2"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -261,14 +261,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/af/bc/0bff31fcaff174d86031cc713471a3e85ed4ec8e5cd95ad0217f2aced20e/langchain_core-1.3.0a2.tar.gz", hash = "sha256:52d978c84552b74b9a3f16c1fced84f9e27cc96d7a67c601925ce6cbc4ea3cf9", size = 854580, upload-time = "2026-04-13T14:37:55.745Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/fe/20190232d9b513242899dbb0c2bb77e31b4d61e343743adbe90ebc2603d2/langchain_core-1.3.0.tar.gz", hash = "sha256:14a39f528bf459aa3aa40d0a7f7f1bae7520d435ef991ae14a4ceb74d8c49046", size = 860755, upload-time = "2026-04-17T14:51:38.298Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/14/03c09686602567059f26af29de0c44546a83af2f2aa29925e61040e43ea2/langchain_core-1.3.0a2-py3-none-any.whl", hash = "sha256:9e929a34f0b0c6c1255e395a1de34f8626893ceb4cdae550a22a0bd18c87be54", size = 510233, upload-time = "2026-04-13T14:37:54.277Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e2/dbfa347aa072a6dc4cd38d6f9ebfc730b4c14c258c47f480f4c5c546f177/langchain_core-1.3.0-py3-none-any.whl", hash = "sha256:baf16ee028475df177b9ab8869a751c79406d64a6f12125b93802991b566cced", size = 515140, upload-time = "2026-04-17T14:51:36.274Z" },
 ]
 
 [[package]]
 name = "langgraph"
-version = "1.1.7a2"
+version = "1.1.9"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -281,7 +281,7 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "langchain-core", specifier = "==1.3.0a2" },
+    { name = "langchain-core", specifier = ">=1.3.0,<2" },
     { name = "langgraph-checkpoint", editable = "../checkpoint" },
     { name = "langgraph-prebuilt", editable = "." },
     { name = "langgraph-sdk", editable = "../sdk-py" },
@@ -352,7 +352,7 @@ test = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 source = { editable = "../checkpoint" }
 dependencies = [
     { name = "langchain-core" },
@@ -490,7 +490,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "1.0.9"
+version = "1.0.10"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
@@ -619,7 +619,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.6.4"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -629,11 +629,12 @@ dependencies = [
     { name = "requests" },
     { name = "requests-toolbelt" },
     { name = "uuid-utils" },
+    { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e7/85/9c7933052a997da1b85bc5c774f3865e9b1da1c8d71541ea133178b13229/langsmith-0.6.4.tar.gz", hash = "sha256:36f7223a01c218079fbb17da5e536ebbaf5c1468c028abe070aa3ae59bc99ec8", size = 919964, upload-time = "2026-01-15T20:02:28.873Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/66/0f/09a6637a7ba777eb307b7c80852d9ee26438e2bdafbad6fcc849ff9d9192/langsmith-0.6.4-py3-none-any.whl", hash = "sha256:ac4835860160be371042c7adbba3cb267bcf8d96a5ea976c33a8a4acad6c5486", size = 283503, upload-time = "2026-01-15T20:02:26.662Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]

libs/sdk-py/uv.lock

@@ -262,7 +262,7 @@ wheels = [
 
 [[package]]
 name = "langchain-core"
-version = "1.3.0a2"
+version = "1.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -274,14 +274,14 @@ dependencies = [
     { name = "typing-extensions" },
     { name = "uuid-utils" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/af/bc/0bff31fcaff174d86031cc713471a3e85ed4ec8e5cd95ad0217f2aced20e/langchain_core-1.3.0a2.tar.gz", hash = "sha256:52d978c84552b74b9a3f16c1fced84f9e27cc96d7a67c601925ce6cbc4ea3cf9", size = 854580, upload-time = "2026-04-13T14:37:55.745Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/92/fe/20190232d9b513242899dbb0c2bb77e31b4d61e343743adbe90ebc2603d2/langchain_core-1.3.0.tar.gz", hash = "sha256:14a39f528bf459aa3aa40d0a7f7f1bae7520d435ef991ae14a4ceb74d8c49046", size = 860755, upload-time = "2026-04-17T14:51:38.298Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/14/03c09686602567059f26af29de0c44546a83af2f2aa29925e61040e43ea2/langchain_core-1.3.0a2-py3-none-any.whl", hash = "sha256:9e929a34f0b0c6c1255e395a1de34f8626893ceb4cdae550a22a0bd18c87be54", size = 510233, upload-time = "2026-04-13T14:37:54.277Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/e2/dbfa347aa072a6dc4cd38d6f9ebfc730b4c14c258c47f480f4c5c546f177/langchain_core-1.3.0-py3-none-any.whl", hash = "sha256:baf16ee028475df177b9ab8869a751c79406d64a6f12125b93802991b566cced", size = 515140, upload-time = "2026-04-17T14:51:36.274Z" },
 ]
 
 [[package]]
 name = "langgraph"
-version = "1.1.7a2"
+version = "1.1.9"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },
@@ -294,7 +294,7 @@ dependencies = [
 
 [package.metadata]
 requires-dist = [
-    { name = "langchain-core", specifier = "==1.3.0a2" },
+    { name = "langchain-core", specifier = ">=1.3.0,<2" },
     { name = "langgraph-checkpoint", editable = "../checkpoint" },
     { name = "langgraph-prebuilt", editable = "../prebuilt" },
     { name = "langgraph-sdk", editable = "." },
@@ -365,7 +365,7 @@ test = [
 
 [[package]]
 name = "langgraph-checkpoint"
-version = "4.0.1"
+version = "4.0.2"
 source = { editable = "../checkpoint" }
 dependencies = [
     { name = "langchain-core" },
@@ -413,7 +413,7 @@ test = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "1.0.9"
+version = "1.0.10"
 source = { editable = "../prebuilt" }
 dependencies = [
     { name = "langchain-core" },
@@ -534,7 +534,7 @@ test = [
 
 [[package]]
 name = "langsmith"
-version = "0.7.20"
+version = "0.7.31"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "httpx" },
@@ -547,9 +547,9 @@ dependencies = [
     { name = "xxhash" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/80/c6/cbdc6638207f68a3c61ec0b64fa593f6b11de3170d03c852238c31b54960/langsmith-0.7.20.tar.gz", hash = "sha256:fa983a74f75648ee0e80d3f9751162b6f9a438896d5f9bdb6cba9abda451e234", size = 1134732, upload-time = "2026-03-18T00:03:39.129Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/11/696019490992db5c87774dc20515529ef42a01e1d770fb754ed6d9b12fb0/langsmith-0.7.31.tar.gz", hash = "sha256:331ee4f7c26bb5be4022b9859b7d7b122cbf8c9d01d9f530114c1914b0349ffb", size = 1178480, upload-time = "2026-04-14T17:55:41.242Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e8/46/9294d4f49de6a8f08e8b83907713ca545459d87d474c6add15d31a36f5dc/langsmith-0.7.20-py3-none-any.whl", hash = "sha256:0162faf791ea48d69009a12a3da917468556b99cf5d5fcacbb8cda064262e118", size = 359314, upload-time = "2026-03-18T00:03:37.59Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/a1/a013cf458c301cda86a213dd153ce0a01c93f1ab5833f951e6a44c9763ce/langsmith-0.7.31-py3-none-any.whl", hash = "sha256:0291d49203f6e80dda011af1afda61eb0595a4d697adb684590a8805e1d61fb6", size = 373276, upload-time = "2026-04-14T17:55:39.677Z" },
 ]
 
 [[package]]

notes/delta_channel_query_bench.md

@@ -0,0 +1,137 @@
+# Delta-channel reconstruction: query strategy benchmark
+
+**Branch:** `delta-channel-writes-based`
+**Question (Nuno):** Is the recursive CTE the right query shape for reconstructing a delta channel inside `get_tuple`, or would a plain `SELECT WHERE` be cheaper even though it returns more rows?
+**Answer:** Plain `SELECT WHERE` wins at every realistic depth. The recursion isn't the problem — the JSON-expression join inside the CTE is.
+
+## Setup
+
+- Postgres 16 on `localhost:5441` (the `compose-postgres.yml` instance, run directly without docker for this round)
+- Single delta channel `messages`, one write per checkpoint, `DELTA_SENTINEL` blob per checkpoint
+- Linear chain (`branch=1`) and 5-way branching at every step (`branch=5`) — branching is the case where plain over-fetches sibling rows
+- Median of 20 timed runs after 3 warmups, fresh psycopg cursor per strategy
+- Bench script: `bench_get_tuple_strategies.py` at repo root
+
+Three strategies compared:
+
+| name | roundtrips | shape |
+|------|-----------|-------|
+| `cte` | 1 | Current prod: recursive CTE walks ancestors, LEFT JOINs writes + blobs |
+| `plain` | 3 | Nuno's suggestion: thread-wide `SELECT WHERE` per table, Python walks parent chain and filters |
+| `cte+narrow` | 2 | CTE returns ancestor IDs only, then one `UNION ALL` of writes + blobs filtered by `ANY(ids)` |
+
+## Results (ms per get_tuple, median of 20)
+
+```
+ depth  branch       cte       plain    cte+narrow   rows_cte   rows_plain   plain/cte
+    10       1     0.14ms      0.26ms       0.24ms          9           30      1.89x
+    10       5     0.21ms      0.23ms       0.17ms          9          110      1.11x
+    50       1     0.89ms      0.27ms       0.33ms         49          150      0.31x
+    50       5     2.35ms      0.66ms       0.51ms         49          550      0.28x
+   200       1    11.61ms      0.78ms       1.30ms        199          600      0.07x
+   200       5    34.79ms      2.33ms       3.07ms        199         2200      0.07x
+  1000       1   274.60ms      2.59ms      13.29ms        999         3000      0.01x
+  1000       5   856.01ms     10.14ms      15.31ms        999        11000      0.01x
+```
+
+Lower is better. `plain/cte < 1` means plain is faster.
+
+### Headline numbers
+
+- depth 50: plain is **3x** faster
+- depth 200: plain is **15x** faster
+- depth 1000: plain is **~100x** faster
+- Branching makes plain over-fetch (3000 rows → 11000 rows at d=1000), but it remains ~85x faster than the CTE
+
+## Why the CTE collapses
+
+`EXPLAIN (ANALYZE, BUFFERS)` of the CTE at depth 1000 (linear). Excerpt with the load-bearing nodes:
+
+```
+Sort  ... actual time=137.798..137.827 rows=999
+  CTE ancestors
+    ->  Recursive Union  ... actual time=0.005..2.443 rows=999
+                                                 ^^^^^^
+                                                 recursion is 2.4 ms — fine
+  ->  Nested Loop Left Join  ... actual time=2.676..137.529 rows=999
+        Join Filter: (cw.checkpoint_id = a.cid)
+        Rows Removed by Join Filter: 998001
+                                     ^^^^^^^
+                                     999 ancestors x ~1000 writes
+        ->  Nested Loop Left Join  ... actual time=2.669..85.061 rows=999
+              Join Filter: (bl.version = ((c.checkpoint -> 'channel_versions'::text) ->> bl.channel))
+              Rows Removed by Join Filter: 998001
+                                           ^^^^^^^
+                                           same quadratic blow-up on the blob join
+```
+
+Two pathological things are happening:
+
+1. **The blob join filter is on a JSON expression**: `bl.version = (c.checkpoint -> 'channel_versions' ->> bl.channel)`. The planner cannot push this into an index lookup, so it materializes `checkpoint_blobs` for the thread and does a nested-loop comparison against every ancestor — a Cartesian product that grows as `O(ancestors × blobs_in_thread)`.
+2. **The writes join is similar**: writes for the thread are materialized once, then nested-loop joined against ancestors with a `Join Filter` rather than a hash/merge join over the indexed `checkpoint_id`.
+
+At depth 1000 that's **~2 million rows evaluated, 99.9% of them discarded**. The recursion itself is a rounding error.
+
+For comparison, the plain Q1 (`SELECT … FROM checkpoints WHERE thread_id=? AND checkpoint_ns=?`) at depth 1000:
+
+```
+Seq Scan on checkpoints  ... actual time=0.012..0.121 rows=1000
+Execution Time: 0.140 ms
+```
+
+A simple seq scan over 57 buffers. Q2 and Q3 follow the same shape and complete in well under 1 ms each.
+
+## Crossover and remote-DB reasoning
+
+- Pure local Postgres: plain wins from depth ~30 onward; CTE wins by fractions of a ms below that
+- Remote Postgres at ~5 ms RTT adds ~10 ms to plain (3 roundtrips vs 1). Crossover shifts to ~depth 30. Above that, the CTE's quadratic SQL cost still dominates the RTT savings.
+
+There is no realistic conversation depth where the CTE wins on a remote DB. At depth 200+ (anything resembling a real multi-turn agent run) plain is faster regardless of network.
+
+## Recommendation
+
+**Switch to plain SELECT WHERE, one delta channel at a time.**
+
+Three indexed queries per delta channel:
+
+```sql
+-- Q1: parent chain + per-checkpoint version of this channel
+SELECT checkpoint_id,
+       parent_checkpoint_id,
+       checkpoint -> 'channel_versions' ->> 'channel_name' AS ver
+FROM checkpoints
+WHERE thread_id = ? AND checkpoint_ns = ?;
+
+-- Q2: writes for this channel, anywhere in the thread
+SELECT checkpoint_id, type, blob, task_id, idx
+FROM checkpoint_writes
+WHERE thread_id = ? AND checkpoint_ns = ? AND channel = ?;
+
+-- Q3: blobs for this channel, anywhere in the thread
+SELECT version, type, blob
+FROM checkpoint_blobs
+WHERE thread_id = ? AND checkpoint_ns = ? AND channel = ?;
+```
+
+Python then:
+- Builds `parent_of: dict[cid, parent_cid]` from Q1
+- Walks from target's parent newest → oldest
+- Filters Q2 rows by `ancestor_set`, processes oldest → newest, applies overwrite-terminator
+- Picks seed blob via the per-ancestor `ver` map, terminates at first non-sentinel blob
+
+All O(n) on n = thread checkpoints, with tight constants (dict lookups). No recursion, no JSON-expression joins, no quadratic plans.
+
+If the 3-roundtrip cost ever shows up on remote-DB benchmarks, fold Q2 + Q3 into one `UNION ALL` to get back to 2 roundtrips. Bench says it isn't worth the SQL complexity right now.
+
+## Bonus: code simplification from single-channel scope
+
+Multi-channel reconstruction in the current `_reconstruct_delta_channels_cur` carries:
+
+- `rows_by_cid` nested dicts, keyed by cid then channel
+- `seen_blob: set[(cid, channel)]` and `seen_write: set[(cid, channel, task_id, idx)]` dedup
+- `collected: dict[channel, list]`, `done: set[channel]`, `seeds: dict[channel, value]`
+- Inner `for ch in channels_list` loops and an early-exit `if len(done) == len(channels_list)`
+
+Single-channel collapses these to a single list, a single bool, and one `Optional[Any]`. Roughly half the Python in that function, plus an obvious shape for splitting pure post-processing into `base.py` so sync and async stop duplicating it.
+
+If multi-channel coalescing turns out to matter later, it can come back as a SQL-level optimization without re-introducing the bookkeeping in Python.