feat(langgraph): run the cancel handler only for RunCancelled cancels

Plain cancels, like asyncio timeouts, task groups stopping siblings or a
process shutting down, skip the handler so the run can be resumed as is.

.github/workflows/_integration_test.yml

@@ -115,21 +115,16 @@ jobs:
           echo "LANGSMITH_API_KEY=${{ secrets.LANGSMITH_API_KEY }}" >> .env
           timeout --kill-after=30 300 python ../../../../.github/scripts/run_langgraph_cli_test.py -t langgraph-test-h
           echo "Finished starting up langgraph-test-h"
-          LANGGRAPH_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langgraph'); print(v);")
-          if [ "$LANGGRAPH_VERSION" != "1.2.6" ]; then
-            echo "LANGGRAPH_VERSION != 1.2.6; $LANGGRAPH_VERSION"
-            exit 1
-          fi
-          LANGCHAIN_OPENAI_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langchain-openai'); print(v);")
-          if [ "$LANGCHAIN_OPENAI_VERSION" != "1.1.14" ]; then
-            echo "LANGCHAIN_OPENAI_VERSION != 1.1.14; $LANGCHAIN_OPENAI_VERSION"
-            exit 1
-          fi
-          LANGCHAIN_ANTHROPIC_VERSION=$(docker run --rm --entrypoint "" langgraph-test-h python -c "import sys; from importlib.metadata import version; v = version('langchain-anthropic'); print(v);")
-          if [ "$LANGCHAIN_ANTHROPIC_VERSION" != "1.4.6" ]; then
-            echo "LANGCHAIN_ANTHROPIC_VERSION != 1.4.6; $LANGCHAIN_ANTHROPIC_VERSION"
-            exit 1
-          fi
+          pins=$(grep -oE '"[a-z0-9-]+==[^"]+"' pyproject.toml | tr -d '"')
+          [ -n "$pins" ] || { echo "no == pins found in pyproject.toml"; exit 1; }
+          for pin in $pins; do
+            pkg=${pin%%==*}
+            installed=$(docker run --rm --entrypoint "" langgraph-test-h python -c "from importlib.metadata import version; print(version('$pkg'))")
+            if [ "$installed" != "${pin#*==}" ]; then
+              echo "$pkg $installed != pinned ${pin#*==}"
+              exit 1
+            fi
+          done
 
       - name: Build and test prerelease reqs fail service
         if: ${{ (steps.changed-files.outputs.all || github.event_name == 'workflow_dispatch') &&matrix.example.name == 'A' }}

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

@@ -1,7 +1,6 @@
 from __future__ import annotations
 
 import copy
-import json
 import logging
 from collections.abc import AsyncIterator, Collection, Iterator, Mapping, Sequence
 from typing import (
@@ -27,8 +26,6 @@ from langgraph.checkpoint.serde.types import (
     RESUME,
     SCHEDULED,
     ChannelProtocol,
-    LogAppend,
-    LogStep,
 )
 
 V = TypeVar("V", int, float, str)
@@ -185,93 +182,6 @@ class DeltaChannelHistory(TypedDict):
     seed: NotRequired[Any]
 
 
-class LogPage(NamedTuple):
-    """A page of a log channel, as returned by `BaseCheckpointSaver.read_log`.
-
-    !!! warning "Prototype"
-
-        Part of the transcript log prototype. Shape and semantics may change.
-    """
-
-    entries: list[tuple[int, Any]]
-    """`(position, entry)` pairs in path order. Entries are JSON values."""
-    length: int
-    """Number of committed entries on the path to the checkpoint's leaf."""
-    pending: list[Any]
-    """Entries written by finished tasks of the step in progress at the head,
-    not committed yet. Empty unless the checkpoint read is the thread's latest."""
-
-
-def log_range(
-    length: int, after: int | None, before: int | None, limit: int | None
-) -> tuple[int, int]:
-    """The position range `[lo, hi)` a `read_log` call asks for.
-
-    `after=p` starts after position `p`; `before=p` stops before it. With a
-    `limit`, a read with only `after` takes the first `limit` entries of the
-    range; any other read takes the last `limit` (chat UIs page from the end).
-    """
-    lo = 0 if after is None else max(after + 1, 0)
-    hi = length if before is None else min(before, length)
-    if limit is not None:
-        if after is not None and before is None:
-            hi = min(hi, lo + limit)
-        else:
-            lo = max(lo, hi - limit)
-    return lo, max(lo, hi)
-
-
-def _without_checkpoint_id(config: RunnableConfig) -> RunnableConfig:
-    conf = {k: v for k, v in config["configurable"].items() if k != "checkpoint_id"}
-    return {**config, "configurable": conf}
-
-
-def _pending_log_entries(tup: CheckpointTuple, channel: str) -> list[Any]:
-    return [
-        json.loads(text)
-        for _, ch, value in tup.pending_writes or ()
-        if ch == channel and isinstance(value, LogAppend)
-        for text in value.entries
-    ]
-
-
-def _step_entries(
-    step: LogStep, parent: CheckpointTuple | None, channel: str
-) -> list[str]:
-    """The JSON texts of one step: inline, or the `LogAppend` writes stored on
-    the checkpoint the step started from."""
-    if step.entries is not None:
-        texts = list(step.entries)
-    else:
-        texts = [
-            text
-            for _, ch, value in (parent.pending_writes or () if parent else ())
-            if ch == channel
-            and isinstance(value, LogAppend)
-            and value.start == step.start
-            for text in value.entries
-        ]
-    if len(texts) != step.count:
-        raise ValueError(
-            f"log channel {channel!r}: the step at position {step.start} "
-            f"committed {step.count} entries, found {len(texts)}"
-        )
-    return texts
-
-
-def _page_entries(
-    steps: Sequence[tuple[int, Sequence[str]]], lo: int, hi: int
-) -> list[tuple[int, Any]]:
-    """Positions `[lo, hi)` from steps given as `(start, texts)`, any order."""
-    out: list[tuple[int, Any]] = []
-    for start, texts in sorted(steps, key=lambda s: s[0]):
-        for i, text in enumerate(texts):
-            pos = start + i
-            if lo <= pos < hi:
-                out.append((pos, json.loads(text)))
-    return out
-
-
 def writes_sort_key(
     task_path: str, task_id: str = "", idx: int = 0
 ) -> tuple[str, str, int]:
@@ -321,14 +231,6 @@ class BaseCheckpointSaver(Generic[V]):
 
     serde: SerializerProtocol = JsonPlusSerializer()
 
-    supports_log: bool = False
-    """Whether this saver stores log channels natively (prototype).
-
-    A saver without native support still works: it stores `LogAppend` writes
-    and `LogStep` values like any other, and the default `read_log` walks the
-    parent chain to read them back.
-    """
-
     def __init__(
         self,
         *,
@@ -702,109 +604,6 @@ class BaseCheckpointSaver(Generic[V]):
         """
         raise NotImplementedError
 
-    def read_log(
-        self,
-        config: RunnableConfig,
-        channel: str,
-        *,
-        after: int | None = None,
-        before: int | None = None,
-        limit: int | None = None,
-    ) -> LogPage:
-        """Read a log channel as of the checkpoint `config` names (or the latest).
-
-        !!! warning "Prototype"
-
-            Part of the transcript log prototype. Shape and semantics may change.
-
-        The log as of a checkpoint is the path from the root to the leaf its
-        channel version points at. See `log_range` for `after`, `before` and
-        `limit`.
-
-        The default implementation walks the parent chain through `get_tuple`:
-        a step's entries are inline in its `LogStep`, or are the `LogAppend`
-        writes stored on the checkpoint the step started from. It is correct
-        and costs one `get_tuple` per checkpoint walked. Savers with direct
-        storage access override it with range reads.
-        """
-        tup = self.get_tuple(config)
-        if tup is None:
-            return LogPage([], 0, [])
-        latest = self.get_tuple(_without_checkpoint_id(tup.config))
-        is_head = latest is not None and latest.checkpoint["id"] == tup.checkpoint["id"]
-        pending = _pending_log_entries(tup, channel) if is_head else []
-        marker = tup.checkpoint["channel_values"].get(channel)
-        if not isinstance(marker, LogStep):
-            return LogPage([], 0, pending)
-        lo, hi = log_range(marker.end, after, before, limit)
-        steps: list[tuple[int, list[str]]] = []
-        cur: CheckpointTuple | None = tup
-        while cur is not None:
-            version = cur.checkpoint["channel_versions"].get(channel)
-            step = cur.checkpoint["channel_values"].get(channel)
-            if version is None or not isinstance(step, LogStep) or step.end <= lo:
-                break
-            # climb to the checkpoint that committed this version: later ones
-            # carry its marker without inline entries
-            parent = self.get_tuple(cur.parent_config) if cur.parent_config else None
-            while (
-                parent is not None
-                and parent.checkpoint["channel_versions"].get(channel) == version
-            ):
-                step = parent.checkpoint["channel_values"].get(channel, step)
-                parent = (
-                    self.get_tuple(parent.parent_config)
-                    if parent.parent_config
-                    else None
-                )
-            steps.append((step.start, _step_entries(step, parent, channel)))
-            cur = parent
-        return LogPage(_page_entries(steps, lo, hi), marker.end, pending)
-
-    async def aread_log(
-        self,
-        config: RunnableConfig,
-        channel: str,
-        *,
-        after: int | None = None,
-        before: int | None = None,
-        limit: int | None = None,
-    ) -> LogPage:
-        """Async version of `read_log`."""
-        tup = await self.aget_tuple(config)
-        if tup is None:
-            return LogPage([], 0, [])
-        latest = await self.aget_tuple(_without_checkpoint_id(tup.config))
-        is_head = latest is not None and latest.checkpoint["id"] == tup.checkpoint["id"]
-        pending = _pending_log_entries(tup, channel) if is_head else []
-        marker = tup.checkpoint["channel_values"].get(channel)
-        if not isinstance(marker, LogStep):
-            return LogPage([], 0, pending)
-        lo, hi = log_range(marker.end, after, before, limit)
-        steps: list[tuple[int, list[str]]] = []
-        cur: CheckpointTuple | None = tup
-        while cur is not None:
-            version = cur.checkpoint["channel_versions"].get(channel)
-            step = cur.checkpoint["channel_values"].get(channel)
-            if version is None or not isinstance(step, LogStep) or step.end <= lo:
-                break
-            parent = (
-                await self.aget_tuple(cur.parent_config) if cur.parent_config else None
-            )
-            while (
-                parent is not None
-                and parent.checkpoint["channel_versions"].get(channel) == version
-            ):
-                step = parent.checkpoint["channel_values"].get(channel, step)
-                parent = (
-                    await self.aget_tuple(parent.parent_config)
-                    if parent.parent_config
-                    else None
-                )
-            steps.append((step.start, _step_entries(step, parent, channel)))
-            cur = parent
-        return LogPage(_page_entries(steps, lo, hi), marker.end, pending)
-
     def get_delta_channel_history(
         self, *, config: RunnableConfig, channels: Sequence[str]
     ) -> Mapping[str, DeltaChannelHistory]:

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

@@ -21,15 +21,12 @@ from langgraph.checkpoint.base import (
     CheckpointMetadata,
     CheckpointTuple,
     DeltaChannelHistory,
-    LogPage,
     PendingWrite,
     SerializerProtocol,
     get_checkpoint_id,
     get_checkpoint_metadata,
     writes_sort_key,
 )
-from langgraph.checkpoint.memory._log import InMemoryLog
-from langgraph.checkpoint.serde.types import LogAppend, LogStep
 
 logger = logging.getLogger(__name__)
 
@@ -69,8 +66,6 @@ class InMemorySaver(
         ```
     """
 
-    supports_log = True
-
     # thread ID ->  checkpoint NS -> checkpoint ID -> checkpoint mapping
     storage: defaultdict[
         str,
@@ -98,7 +93,6 @@ class InMemorySaver(
         self.storage = factory(lambda: defaultdict(dict))
         self.writes = factory(dict)
         self.blobs = factory()
-        self.log = InMemoryLog()
         self.stack = ExitStack()
         if factory is not defaultdict:
             self.stack.enter_context(self.storage)  # type: ignore[arg-type]
@@ -137,11 +131,6 @@ class InMemorySaver(
     ) -> dict[str, Any]:
         result: dict[str, Any] = {}
         for k, ver in versions.items():
-            if (
-                marker := self.log.marker(thread_id, checkpoint_ns, k, ver)
-            ) is not None:
-                result[k] = marker
-                continue
             kk = (thread_id, checkpoint_ns, k, ver)
             if kk not in self.blobs:
                 continue
@@ -160,87 +149,6 @@ class InMemorySaver(
             for k in sorted(stored, key=lambda k: writes_sort_key(stored[k][3], *k))
         ]
 
-    def _pending_writes(
-        self, thread_id: str, checkpoint_ns: str, checkpoint_id: str
-    ) -> list[PendingWrite]:
-        """A checkpoint's writes, including its uncommitted log writes, in
-        `writes_sort_key` order."""
-        stored = self.writes.get((thread_id, checkpoint_ns, checkpoint_id), {})
-        rows: list[tuple[tuple[str, str, int], PendingWrite]] = [
-            (
-                writes_sort_key(v[3], *k),
-                (v[0], v[1], self.serde.loads_typed(v[2])),
-            )
-            for k, v in stored.items()
-        ]
-        for task_path, task_id, channel, idx, value in self.log.pending_writes(
-            thread_id, checkpoint_ns, checkpoint_id
-        ):
-            rows.append(
-                (writes_sort_key(task_path, task_id, idx), (task_id, channel, value))
-            )
-        rows.sort(key=lambda r: r[0])
-        return [w for _, w in rows]
-
-    def _version(
-        self,
-        thread_id: str,
-        checkpoint_ns: str,
-        checkpoint_id: str | None,
-        channel: str,
-    ) -> Any:
-        if checkpoint_id is None:
-            return None
-        saved = (
-            self.storage.get(thread_id, {}).get(checkpoint_ns, {}).get(checkpoint_id)
-        )
-        if saved is None:
-            return None
-        version = self.serde.loads_typed(saved[0])["channel_versions"].get(channel)
-        if (thread_id, checkpoint_ns, channel, version) in self.blobs:
-            # stored before the field became a log channel: its log is empty
-            return None
-        return version
-
-    def read_log(
-        self,
-        config: RunnableConfig,
-        channel: str,
-        *,
-        after: int | None = None,
-        before: int | None = None,
-        limit: int | None = None,
-    ) -> LogPage:
-        """Read a log channel with range reads over its segment chain."""
-        thread_id = config["configurable"]["thread_id"]
-        checkpoint_ns = config["configurable"].get("checkpoint_ns", "")
-        ns_storage = self.storage.get(thread_id, {}).get(checkpoint_ns, {})
-        latest = max(ns_storage, default=None)
-        checkpoint_id = get_checkpoint_id(config) or latest
-        if checkpoint_id is None or checkpoint_id not in ns_storage:
-            return LogPage([], 0, [])
-        return self.log.read(
-            thread_id,
-            checkpoint_ns,
-            channel,
-            self._version(thread_id, checkpoint_ns, checkpoint_id, channel),
-            checkpoint_id if checkpoint_id == latest else None,
-            after=after,
-            before=before,
-            limit=limit,
-        )
-
-    async def aread_log(
-        self,
-        config: RunnableConfig,
-        channel: str,
-        *,
-        after: int | None = None,
-        before: int | None = None,
-        limit: int | None = None,
-    ) -> LogPage:
-        return self.read_log(config, channel, after=after, before=before, limit=limit)
-
     def get_delta_channel_history(
         self, *, config: RunnableConfig, channels: Sequence[str]
     ) -> Mapping[str, DeltaChannelHistory]:
@@ -347,6 +255,7 @@ class InMemorySaver(
         if checkpoint_id := get_checkpoint_id(config):
             if saved := self.storage[thread_id][checkpoint_ns].get(checkpoint_id):
                 checkpoint, metadata, parent_checkpoint_id = saved
+                writes = self._ordered_writes(thread_id, checkpoint_ns, checkpoint_id)
                 checkpoint_: Checkpoint = self.serde.loads_typed(checkpoint)
                 return CheckpointTuple(
                     config=config,
@@ -357,9 +266,9 @@ class InMemorySaver(
                         ),
                     },
                     metadata=self.serde.loads_typed(metadata),
-                    pending_writes=self._pending_writes(
-                        thread_id, checkpoint_ns, checkpoint_id
-                    ),
+                    pending_writes=[
+                        (id, c, self.serde.loads_typed(v)) for id, c, v, _ in writes
+                    ],
                     parent_config=(
                         {
                             "configurable": {
@@ -376,6 +285,7 @@ class InMemorySaver(
             if checkpoints := self.storage[thread_id][checkpoint_ns]:
                 checkpoint_id = max(checkpoints.keys())
                 checkpoint, metadata, parent_checkpoint_id = checkpoints[checkpoint_id]
+                writes = self._ordered_writes(thread_id, checkpoint_ns, checkpoint_id)
                 checkpoint_ = self.serde.loads_typed(checkpoint)
                 return CheckpointTuple(
                     config={
@@ -392,9 +302,9 @@ class InMemorySaver(
                         ),
                     },
                     metadata=self.serde.loads_typed(metadata),
-                    pending_writes=self._pending_writes(
-                        thread_id, checkpoint_ns, checkpoint_id
-                    ),
+                    pending_writes=[
+                        (id, c, self.serde.loads_typed(v)) for id, c, v, _ in writes
+                    ],
                     parent_config=(
                         {
                             "configurable": {
@@ -478,6 +388,10 @@ class InMemorySaver(
                     elif limit is not None:
                         limit -= 1
 
+                    writes = self._ordered_writes(
+                        thread_id, checkpoint_ns, checkpoint_id
+                    )
+
                     checkpoint_: Checkpoint = self.serde.loads_typed(checkpoint)
 
                     yield CheckpointTuple(
@@ -508,9 +422,9 @@ class InMemorySaver(
                             if parent_checkpoint_id
                             else None
                         ),
-                        pending_writes=self._pending_writes(
-                            thread_id, checkpoint_ns, checkpoint_id
-                        ),
+                        pending_writes=[
+                            (id, c, self.serde.loads_typed(v)) for id, c, v, _ in writes
+                        ],
                     )
 
     def put(
@@ -537,22 +451,8 @@ class InMemorySaver(
         c = checkpoint.copy()
         thread_id = config["configurable"]["thread_id"]
         checkpoint_ns = config["configurable"]["checkpoint_ns"]
-        parent_id = config["configurable"].get("checkpoint_id")
         values: dict[str, Any] = c.pop("channel_values")  # type: ignore[misc]
         for k, v in new_versions.items():
-            if isinstance(values.get(k), LogStep):
-                # a log channel: the step row is its "blob" at this version
-                self.log.put_step(
-                    thread_id,
-                    checkpoint_ns,
-                    k,
-                    self._version(thread_id, checkpoint_ns, parent_id, k),
-                    parent_id,
-                    checkpoint["id"],
-                    v,
-                    values[k],
-                )
-                continue
             self.blobs[(thread_id, checkpoint_ns, k, v)] = (
                 self.serde.dumps_typed(values[k]) if k in values else ("empty", b"")
             )
@@ -600,19 +500,6 @@ class InMemorySaver(
         outer_key = (thread_id, checkpoint_ns, checkpoint_id)
         outer_writes_ = self.writes.get(outer_key)
         for idx, (c, v) in enumerate(writes):
-            if isinstance(v, LogAppend):
-                self.log.put_append(
-                    thread_id,
-                    checkpoint_ns,
-                    c,
-                    self._version(thread_id, checkpoint_ns, checkpoint_id, c),
-                    checkpoint_id,
-                    task_id,
-                    task_path,
-                    idx,
-                    v,
-                )
-                continue
             inner_key = (task_id, WRITES_IDX_MAP.get(c, idx))
             if inner_key[1] >= 0 and outer_writes_ and inner_key in outer_writes_:
                 continue
@@ -641,72 +528,6 @@ class InMemorySaver(
         for k in list(self.blobs.keys()):
             if k[0] == thread_id:
                 del self.blobs[k]
-        self.log.delete_thread(thread_id)
-
-    def copy_thread(self, source_thread_id: str, target_thread_id: str) -> None:
-        """Copy all checkpoints, writes, blobs and log rows to another thread."""
-        for ns, checkpoints in self.storage.get(source_thread_id, {}).items():
-            self.storage[target_thread_id][ns] = dict(checkpoints)
-        for (t, ns, cid), rows in list(self.writes.items()):
-            if t == source_thread_id:
-                self.writes[(target_thread_id, ns, cid)] = dict(rows)
-        for (t, ns, ch, ver), blob in list(self.blobs.items()):
-            if t == source_thread_id:
-                self.blobs[(target_thread_id, ns, ch, ver)] = blob
-        self.log.copy_thread(source_thread_id, target_thread_id)
-
-    def prune(
-        self, thread_ids: Sequence[str], *, strategy: str = "keep_latest"
-    ) -> None:
-        """Prune checkpoints; the log keeps what remaining checkpoints reach.
-
-        `"keep_latest"` keeps the latest checkpoint per namespace, `"delete"`
-        deletes every checkpoint. Writes and blobs no remaining checkpoint
-        uses are deleted with them.
-        """
-        if strategy not in ("keep_latest", "delete"):
-            raise ValueError(f"Unknown prune strategy: {strategy}")
-        for thread_id in thread_ids:
-            keep = {
-                ns: ({max(cps)} if strategy == "keep_latest" and cps else set())
-                for ns, cps in self.storage.get(thread_id, {}).items()
-            }
-            self._retain(thread_id, keep)
-
-    def delete_for_runs(self, run_ids: Sequence[str]) -> None:
-        """Delete the checkpoints the given runs created; the log keeps what
-        the remaining checkpoints reach."""
-        runs = set(run_ids)
-        for thread_id, namespaces in list(self.storage.items()):
-            keep = {
-                ns: {
-                    cid
-                    for cid, saved in cps.items()
-                    if self.serde.loads_typed(saved[1]).get("run_id") not in runs
-                }
-                for ns, cps in namespaces.items()
-            }
-            self._retain(thread_id, keep)
-
-    def _retain(self, thread_id: str, keep: dict[str, set[str]]) -> None:
-        namespaces = self.storage.get(thread_id, {})
-        for ns, cps in list(namespaces.items()):
-            for cid in [c for c in cps if c not in keep.get(ns, set())]:
-                del cps[cid]
-                self.writes.pop((thread_id, ns, cid), None)
-        used = {
-            (thread_id, ns, ch, ver)
-            for ns, cps in namespaces.items()
-            for saved in cps.values()
-            for ch, ver in self.serde.loads_typed(saved[0])["channel_versions"].items()
-        }
-        for k in [k for k in self.blobs if k[0] == thread_id and k not in used]:
-            del self.blobs[k]
-        self.log.collect(
-            thread_id,
-            {ns: dict.fromkeys(cps) for ns, cps in namespaces.items()},
-            lambda ns, cid, ch: self._version(thread_id, ns, cid, ch),
-        )
 
     async def aget_tuple(self, config: RunnableConfig) -> CheckpointTuple | None:
         """Asynchronous version of `get_tuple`.
@@ -798,17 +619,6 @@ class InMemorySaver(
         """
         return self.delete_thread(thread_id)
 
-    async def acopy_thread(self, source_thread_id: str, target_thread_id: str) -> None:
-        return self.copy_thread(source_thread_id, target_thread_id)
-
-    async def aprune(
-        self, thread_ids: Sequence[str], *, strategy: str = "keep_latest"
-    ) -> None:
-        return self.prune(thread_ids, strategy=strategy)
-
-    async def adelete_for_runs(self, run_ids: Sequence[str]) -> None:
-        return self.delete_for_runs(run_ids)
-
     def get_next_version(self, current: str | None, channel: None) -> str:
         if current is None:
             current_v = 0

libs/checkpoint/langgraph/checkpoint/memory/_log.py

@@ -1,401 +0,0 @@
-"""Log channel storage for `InMemorySaver` (transcript log prototype).
-
-The reference implementation of the log storage design: entries stored once,
-keyed in path order; one step row per committing channel version; segments
-for linear runs, with parent pointers between them. Reads are range reads
-over a segment chain, and lifecycle is reachability from the checkpoints that
-remain.
-
-Rows, per `(thread_id, checkpoint_ns, channel)`:
-
-- segment: `seg -> (parent_seg | None, fork_pos)`
-- step: `version -> StepRow(seg, start, count, batch)`, unique on `(seg, start)`
-- entry: `seg -> {(start, batch, task_path, task_id, idx, j): json_text}`
-
-`batch` names the execution that wrote a step's entries: the checkpoint the
-step started from for entries that came through `put_writes`, the committing
-checkpoint for entries a `LogStep` carried inline.
-"""
-
-from __future__ import annotations
-
-import json
-import threading
-import uuid
-from collections import defaultdict
-from collections.abc import Callable, Iterable
-from dataclasses import dataclass, field
-from typing import Any
-
-from langgraph.checkpoint.base import LogPage, log_range, writes_sort_key
-from langgraph.checkpoint.serde.types import LogAppend, LogStep
-
-_SEGMENT_NS = uuid.UUID("6f6c6f67-0000-4000-8000-6c6f67736567")
-
-EntryKey = tuple[int, str, str, str, int, int]
-
-
-@dataclass
-class StepRow:
-    seg: str
-    start: int
-    count: int
-    batch: str
-    exec: str
-
-    @property
-    def end(self) -> int:
-        return self.start + self.count
-
-
-@dataclass
-class ChannelLog:
-    segments: dict[str, tuple[str | None, int]] = field(default_factory=dict)
-    steps: dict[str, StepRow] = field(default_factory=dict)
-    step_at: dict[tuple[str, int], str] = field(default_factory=dict)
-    entries: defaultdict[str, dict[EntryKey, str]] = field(
-        default_factory=lambda: defaultdict(dict)
-    )
-    batch_segments: defaultdict[str, list[str]] = field(
-        default_factory=lambda: defaultdict(list)
-    )
-
-    def copy(self) -> ChannelLog:
-        new = ChannelLog()
-        new.segments = dict(self.segments)
-        new.steps = {
-            v: StepRow(r.seg, r.start, r.count, r.batch, r.exec)
-            for v, r in self.steps.items()
-        }
-        new.step_at = dict(self.step_at)
-        for seg, rows in self.entries.items():
-            new.entries[seg] = dict(rows)
-        for batch, segs in self.batch_segments.items():
-            new.batch_segments[batch] = list(segs)
-        return new
-
-    # -- structure ---------------------------------------------------------
-
-    def committed(self, seg: str) -> bool:
-        return any(s == seg for s, _ in self.step_at)
-
-    def tip(self, seg: str) -> int:
-        ends = [self.steps[v].end for (s, _), v in self.step_at.items() if s == seg]
-        return max(ends) if ends else self.segments[seg][1]
-
-    def chain(self, seg: str, upto: int) -> list[tuple[str, int]]:
-        """`(segment, upto)` pairs from the leaf's segment to the root."""
-        out: list[tuple[str, int]] = []
-        cur: str | None = seg
-        while cur is not None:
-            out.append((cur, upto))
-            cur, upto = self.segments[cur]
-        return out
-
-    def segment_for(self, leaf: tuple[str | None, int], batch: str, exec_: str) -> str:
-        """The fork rule: continue the leaf's segment if the leaf is its tip;
-        otherwise use a new segment forking at the leaf, reusing one this
-        batch already started and nothing committed to."""
-        seg, end = leaf
-        if seg is not None and self.tip(seg) == end:
-            return seg
-        for cand in self.batch_segments.get(batch, ()):
-            if self.segments[cand] == leaf and not self.committed(cand):
-                return cand
-        new = str(
-            uuid.uuid5(
-                _SEGMENT_NS, f"{batch}:{exec_}:{len(self.batch_segments[batch])}"
-            )
-        )
-        self.segments[new] = leaf
-        self.batch_segments[batch].append(new)
-        return new
-
-    def step_texts(self, seg: str, start: int, batch: str) -> list[str]:
-        rows = self.entries.get(seg, {})
-        keys = sorted(
-            (k for k in rows if k[0] == start and k[1] == batch),
-            key=lambda k: (writes_sort_key(k[2], k[3], k[4]), k[5]),
-        )
-        return [rows[k] for k in keys]
-
-    def replace_write(
-        self,
-        seg: str,
-        start: int,
-        batch: str,
-        task_path: str,
-        task_id: str,
-        idx: int,
-        texts: Iterable[str],
-    ) -> None:
-        rows = self.entries[seg]
-        for k in [k for k in rows if k[:5] == (start, batch, task_path, task_id, idx)]:
-            del rows[k]
-        for j, text in enumerate(texts):
-            rows[(start, batch, task_path, task_id, idx, j)] = text
-
-    def is_committed_step(self, seg: str, start: int, batch: str) -> bool:
-        v = self.step_at.get((seg, start))
-        return v is not None and self.steps[v].batch == batch
-
-    def pending(self, batch: str) -> list[tuple[str, str, int, LogAppend, str]]:
-        """Uncommitted writes stored under `batch`, as
-        `(task_path, task_id, idx, LogAppend, exec)`, in write order."""
-        groups: dict[tuple[str, int, str, str, int], list[tuple[int, str]]] = (
-            defaultdict(list)
-        )
-        for seg, rows in self.entries.items():
-            for (start, b, task_path, task_id, idx, j), text in rows.items():
-                if b != batch or self.is_committed_step(seg, start, b):
-                    continue
-                groups[(seg, start, task_path, task_id, idx)].append((j, text))
-        out = []
-        for (_, start, task_path, task_id, idx), items in groups.items():
-            texts = tuple(t for _, t in sorted(items))
-            out.append((task_path, task_id, idx, LogAppend(start, texts), ""))
-        out.sort(key=lambda w: writes_sort_key(w[0], w[1], w[2]))
-        return out
-
-
-class InMemoryLog:
-    """Log storage for one `InMemorySaver`."""
-
-    def __init__(self) -> None:
-        self.logs: dict[tuple[str, str, str], ChannelLog] = {}
-        self.lock = threading.RLock()
-
-    def _log(self, thread_id: str, ns: str, channel: str) -> ChannelLog:
-        key = (thread_id, ns, channel)
-        if key not in self.logs:
-            self.logs[key] = ChannelLog()
-        return self.logs[key]
-
-    def is_log_version(
-        self, thread_id: str, ns: str, channel: str, version: Any
-    ) -> bool:
-        log = self.logs.get((thread_id, ns, channel))
-        return log is not None and version in log.steps
-
-    def marker(
-        self, thread_id: str, ns: str, channel: str, version: Any
-    ) -> LogStep | None:
-        log = self.logs.get((thread_id, ns, channel))
-        if log is None or version not in log.steps:
-            return None
-        row = log.steps[version]
-        return LogStep(row.start, row.count, row.exec)
-
-    def leaf(
-        self, thread_id: str, ns: str, channel: str, version: Any
-    ) -> tuple[str | None, int]:
-        if version is None:
-            return (None, 0)
-        log = self.logs.get((thread_id, ns, channel))
-        if log is None or version not in log.steps:
-            raise ValueError(
-                f"log channel {channel!r}: version {version} has no step row"
-            )
-        row = log.steps[version]
-        return (row.seg, row.end)
-
-    # -- writes ------------------------------------------------------------
-
-    def put_append(
-        self,
-        thread_id: str,
-        ns: str,
-        channel: str,
-        parent_version: Any,
-        batch: str,
-        task_id: str,
-        task_path: str,
-        idx: int,
-        value: LogAppend,
-    ) -> None:
-        with self.lock:
-            log = self._log(thread_id, ns, channel)
-            leaf = self.leaf(thread_id, ns, channel, parent_version)
-            if value.start != leaf[1]:
-                raise ValueError(
-                    f"log channel {channel!r}: append at {value.start}, but the "
-                    f"checkpoint's log has {leaf[1]} entries"
-                )
-            seg = log.segment_for(leaf, batch, value.exec)
-            if log.is_committed_step(seg, value.start, batch):
-                return  # already committed: a reused write, nothing to do
-            log.replace_write(
-                seg, value.start, batch, task_path, task_id, idx, value.entries
-            )
-
-    def put_step(
-        self,
-        thread_id: str,
-        ns: str,
-        channel: str,
-        parent_version: Any,
-        parent_id: str | None,
-        checkpoint_id: str,
-        version: Any,
-        step: LogStep,
-    ) -> None:
-        with self.lock:
-            log = self._log(thread_id, ns, channel)
-            leaf = self.leaf(thread_id, ns, channel, parent_version)
-            if step.start != leaf[1]:
-                raise ValueError(
-                    f"log channel {channel!r}: step starts at {step.start}, but "
-                    f"the parent checkpoint's log has {leaf[1]} entries"
-                )
-            inline = step.entries is not None
-            batch = checkpoint_id if inline or parent_id is None else parent_id
-            seg = log.segment_for(leaf, batch, step.exec)
-            if inline:
-                log.replace_write(seg, step.start, batch, "", "", 0, step.entries)
-            texts = log.step_texts(seg, step.start, batch)
-            if len(texts) != step.count:
-                raise ValueError(
-                    f"log channel {channel!r}: the step at {step.start} commits "
-                    f"{step.count} entries, but {len(texts)} were written"
-                )
-            existing = log.step_at.get((seg, step.start))
-            if existing is not None and existing != version:
-                raise ValueError(
-                    f"log channel {channel!r}: position {step.start} of segment "
-                    f"{seg} was already committed by another step (concurrent "
-                    "writers on one checkpoint)"
-                )
-            log.steps[version] = StepRow(seg, step.start, step.count, batch, step.exec)
-            log.step_at[(seg, step.start)] = version
-
-    # -- reads -------------------------------------------------------------
-
-    def read(
-        self,
-        thread_id: str,
-        ns: str,
-        channel: str,
-        version: Any,
-        batch: str | None,
-        *,
-        after: int | None,
-        before: int | None,
-        limit: int | None,
-    ) -> LogPage:
-        with self.lock:
-            log = self.logs.get((thread_id, ns, channel))
-            pending: list[Any] = []
-            if log is not None and batch is not None:
-                pending = [
-                    json.loads(text)
-                    for *_, value, _ in log.pending(batch)
-                    for text in value.entries
-                ]
-            if log is None or version is None or version not in log.steps:
-                return LogPage([], 0, pending)
-            row = log.steps[version]
-            lo, hi = log_range(row.end, after, before, limit)
-            out: list[tuple[int, Any]] = []
-            for seg, upto in log.chain(row.seg, row.end):
-                if upto <= lo:
-                    break
-                starts = sorted(s for (sg, s) in log.step_at if sg == seg and s < upto)
-                for start in starts:
-                    srow = log.steps[log.step_at[(seg, start)]]
-                    if srow.end <= lo or srow.start >= hi:
-                        continue
-                    texts = log.step_texts(seg, start, srow.batch)
-                    if len(texts) != srow.count:
-                        raise ValueError(
-                            f"log channel {channel!r}: step at {start} has "
-                            f"{len(texts)} entries, expected {srow.count}"
-                        )
-                    for i, text in enumerate(texts):
-                        if lo <= start + i < hi:
-                            out.append((start + i, json.loads(text)))
-            out.sort(key=lambda e: e[0])
-            return LogPage(out, row.end, pending)
-
-    def pending_writes(
-        self, thread_id: str, ns: str, checkpoint_id: str
-    ) -> list[tuple[str, str, str, int, LogAppend]]:
-        """Uncommitted log writes stored on a checkpoint, as
-        `(task_path, task_id, channel, idx, LogAppend)`."""
-        with self.lock:
-            out = []
-            for (t, n, channel), log in self.logs.items():
-                if t != thread_id or n != ns:
-                    continue
-                for task_path, task_id, idx, value, _ in log.pending(checkpoint_id):
-                    out.append((task_path, task_id, channel, idx, value))
-            return out
-
-    # -- lifecycle ---------------------------------------------------------
-
-    def delete_thread(self, thread_id: str) -> None:
-        with self.lock:
-            for key in [k for k in self.logs if k[0] == thread_id]:
-                del self.logs[key]
-
-    def copy_thread(self, source: str, target: str) -> None:
-        with self.lock:
-            for (t, ns, channel), log in list(self.logs.items()):
-                if t == source:
-                    self.logs[(target, ns, channel)] = log.copy()
-
-    def collect(
-        self,
-        thread_id: str,
-        remaining: dict[str, dict[str, Any]],
-        version_of: Callable[[str, str, str], Any],
-    ) -> None:
-        """Keep exactly what remaining checkpoints reach.
-
-        `remaining` maps each namespace to its remaining checkpoint ids;
-        `version_of(ns, checkpoint_id, channel)` returns a checkpoint's
-        version of a channel.
-        """
-        with self.lock:
-            for (t, ns, channel), log in list(self.logs.items()):
-                if t != thread_id:
-                    continue
-                cids = remaining.get(ns, {})
-                reach: dict[str, int] = {}
-                for cid in cids:
-                    version = version_of(ns, cid, channel)
-                    if version is None or version not in log.steps:
-                        continue
-                    row = log.steps[version]
-                    for seg, upto in log.chain(row.seg, row.end):
-                        reach[seg] = max(reach.get(seg, -1), upto)
-                kept_steps = {
-                    v: r
-                    for v, r in log.steps.items()
-                    if r.seg in reach and r.start < reach[r.seg]
-                }
-                kept_keys = {(r.seg, r.start, r.batch) for r in kept_steps.values()}
-                for seg in list(log.entries):
-                    rows = log.entries[seg]
-                    for k in list(rows):
-                        start, batch = k[0], k[1]
-                        if (seg, start, batch) in kept_keys:
-                            continue
-                        if batch in cids and not log.is_committed_step(
-                            seg, start, batch
-                        ):
-                            continue  # pending at a remaining checkpoint
-                        del rows[k]
-                    if not rows:
-                        del log.entries[seg]
-                log.steps = kept_steps
-                log.step_at = {(r.seg, r.start): v for v, r in kept_steps.items()}
-                live = set(reach) | set(log.entries)
-                log.segments = {s: p for s, p in log.segments.items() if s in live}
-                for batch in list(log.batch_segments):
-                    segs = [s for s in log.batch_segments[batch] if s in live]
-                    if segs:
-                        log.batch_segments[batch] = segs
-                    else:
-                        del log.batch_segments[batch]
-                if not log.steps and not log.entries:
-                    del self.logs[(t, ns, channel)]

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

@@ -34,8 +34,6 @@ 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 (
-    LogAppend,
-    LogStep,
     SendProtocol,
     _DeltaSnapshot,
 )
@@ -324,29 +322,11 @@ EXT_PYDANTIC_V1 = 4
 EXT_PYDANTIC_V2 = 5
 EXT_NUMPY_ARRAY = 6
 EXT_DELTA_SNAPSHOT = 7
-EXT_LOG_APPEND = 8
-EXT_LOG_STEP = 9
 
 
 def _msgpack_default(obj: Any) -> str | ormsgpack.Ext:
     if isinstance(obj, _DeltaSnapshot):
         return ormsgpack.Ext(EXT_DELTA_SNAPSHOT, _msgpack_enc(obj.value))
-    elif isinstance(obj, LogAppend):
-        return ormsgpack.Ext(
-            EXT_LOG_APPEND, _msgpack_enc([obj.start, list(obj.entries), obj.exec])
-        )
-    elif isinstance(obj, LogStep):
-        return ormsgpack.Ext(
-            EXT_LOG_STEP,
-            _msgpack_enc(
-                [
-                    obj.start,
-                    obj.count,
-                    obj.exec,
-                    None if obj.entries is None else list(obj.entries),
-                ]
-            ),
-        )
     elif hasattr(obj, "model_dump") and callable(obj.model_dump):  # pydantic v2
         return ormsgpack.Ext(
             EXT_PYDANTIC_V2,
@@ -679,14 +659,6 @@ def _create_msgpack_ext_hook(
                     data, ext_hook=ext_hook, option=ormsgpack.OPT_NON_STR_KEYS
                 )
             )
-        elif code == EXT_LOG_APPEND:
-            start, entries, exec_ = ormsgpack.unpackb(data)
-            return LogAppend(start, tuple(entries), exec_)
-        elif code == EXT_LOG_STEP:
-            start, count, exec_, entries = ormsgpack.unpackb(data)
-            return LogStep(
-                start, count, exec_, None if entries is None else tuple(entries)
-            )
         elif code == EXT_CONSTRUCTOR_SINGLE_ARG:
             tup = None
             try:

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

@@ -31,52 +31,6 @@ class _DeltaSnapshot(NamedTuple):
     value: Any
 
 
-class LogAppend(NamedTuple):
-    """One task write to a log channel, as handed to `put_writes`.
-
-    !!! warning "Prototype"
-
-        Part of the transcript log prototype. Shape and semantics may change.
-
-    `start` is the log's length at the checkpoint the step started from (the
-    position the step's entries begin at). `entries` are the appended entries
-    as JSON text, exactly as written. `exec` identifies the execution that
-    wrote them, so a log-aware saver can keep two executions from one
-    checkpoint apart.
-    """
-
-    start: int
-    entries: tuple[str, ...]
-    exec: str = ""
-
-
-class LogStep(NamedTuple):
-    """A log channel's value in a checkpoint: the step that produced its version.
-
-    !!! warning "Prototype"
-
-        Part of the transcript log prototype. Shape and semantics may change.
-
-    The step appended `count` entries starting at position `start`, so the
-    log as of the checkpoint has `start + count` entries. `entries` carries
-    the step's entries inline when they did not reach the saver through
-    `put_writes` (graph input, `update_state`, `durability="exit"`); it is
-    `None` when they did.
-    """
-
-    start: int
-    count: int
-    exec: str = ""
-    entries: tuple[str, ...] | None = None
-
-    @property
-    def end(self) -> int:
-        return self.start + self.count
-
-    def stripped(self) -> "LogStep":
-        return LogStep(self.start, self.count, self.exec, None)
-
-
 Value = TypeVar("Value", covariant=True)
 Update = TypeVar("Update", contravariant=True)
 C = TypeVar("C")

libs/cli/README.md

@@ -86,6 +86,71 @@ langgraph dockerfile SAVE_PATH [OPTIONS]
   -c, --config FILE       Config file path
 ```
 
+### `langgraph deploy metrics`
+
+Fetch deployment monitoring time series as JSON through the LangSmith control plane.
+Use `langgraph deploy list` to find the deployment ID. Authentication uses the same
+API key and workspace configuration as the other deployment commands.
+
+```bash
+langgraph deploy metrics DEPLOYMENT_ID \
+  --start-time 2026-10-28T00:00:00Z \
+  --end-time 2026-10-28T01:00:00Z \
+  --metrics cpu_usage,memory_usage,worker_count
+```
+
+`--metrics` accepts a comma-separated list of these names (also listed in
+`langgraph deploy metrics --help`):
+
+- Resource usage: `memory_usage`, `cpu_usage`, `disk_usage`
+- Counts: `restart_count`, `replica_count`, `worker_count`, `lg_run_count`
+- HTTP traffic: `responses_per_second`, `error_responses_per_second`, `p95_latency`
+- Queue: `run_queue_wait_time`
+
+These are exact metric names, not free-text search terms. Availability depends on
+the deployment and platform; a supported metric may have no data. Use
+`lg_run_count` for deployment runs, not the UI schema's placeholder `run_count`.
+
+Omit `--metrics` to fetch all available metrics. Time bounds default to the last
+15 minutes, and the backend picks the resolution from the time
+range. This command never prompts; for an organization-scoped key, set
+`LANGSMITH_TENANT_ID` to the workspace ID.
+
+Default output is compact JSON grouped by section title, chart title, and series
+name. Each series contains its real `project_metric` as `metric`, inferred `unit`
+(`percent`, `count`, or `null`), `latest`, `min`, `max`, `avg`, and
+`points: [[iso_timestamp, value], ...]`. Values are rounded to three decimals;
+statistics use unrounded finite values and ignore missing samples. `latest` is
+the latest non-missing value. Missing samples remain `null` gaps, and series with
+no values have null statistics. Empty sections are marked `{"_empty":true}`.
+
+The top level includes `deployment_id`, `start_time`, `end_time`, and
+`step_seconds`. Bounds always describe the requested window, not the observed
+point bounds. The CLI resolves omitted bounds once: end defaults to now (UTC),
+and start defaults to 15 minutes before the resolved end. With only `--end-time`,
+start is 15 minutes before that value; with only `--start-time`, end is now. Both
+values are sent explicitly to the backend and output, even when there are no points. `step_seconds` is the most common gap between consecutive
+timestamps within series, with ties broken by the smallest gap. Whole seconds
+are integers; fractional seconds are preserved. It is `null` only when every
+series has fewer than two timestamps. UI metadata and repeated series IDs are
+omitted. The host-backend response itself is unchanged.
+
+```bash
+langgraph deploy metrics DEPLOYMENT_ID --summary
+langgraph deploy metrics DEPLOYMENT_ID --raw
+```
+
+`--summary` returns the same shape without `points`. `--raw` returns the original
+UI chart schema without reshaping or rounding. These flags are mutually exclusive.
+Neither mode returns traces.
+
+Size comparison using the realistic synthetic unit-test fixture (compact JSON
+serialization for all modes; not a live deployment benchmark):
+
+| Before: raw UI schema | After: default | After: summary |
+| --- | --- | --- |
+| 4,302 bytes | 1,226 bytes (72% smaller) | 806 bytes (81% smaller) |
+
 ## Configuration
 
 The CLI uses a `langgraph.json` configuration file with these key settings:

libs/cli/langgraph_cli/__init__.py

@@ -1 +1 @@
-__version__ = "0.4.40"
+__version__ = "0.4.42"

libs/cli/langgraph_cli/deploy.py

@@ -11,8 +11,9 @@ import time
 from collections.abc import Callable, Mapping, Sequence
 from contextlib import contextmanager
 from dataclasses import asdict, dataclass, field
-from datetime import datetime, timezone
+from datetime import datetime, timedelta, timezone
 from typing import Generic, Protocol, TypeVar
+from uuid import UUID
 
 import click
 import click.exceptions
@@ -23,6 +24,7 @@ from langgraph_cli.analytics import log_command
 from langgraph_cli.config import Config
 from langgraph_cli.constants import DEFAULT_CONFIG
 from langgraph_cli.dependency_tracking import find_tracked_packages
+from langgraph_cli.deployment_metrics import compact_deployment_metrics
 from langgraph_cli.docker import build_docker_image, can_build_locally
 from langgraph_cli.exec import CommandRunner, Runner, subp_exec
 from langgraph_cli.host_backend import (
@@ -2634,6 +2636,81 @@ def deploy_list(
 # ---------------------------------------------------------------------------
 
 
+@OPT_HOST_API_KEY
+@OPT_HOST_URL
+@click.argument("deployment_id", type=click.UUID)
+@click.option(
+    "--start-time",
+    help="ISO8601 start time. Defaults to 15 minutes before --end-time.",
+)
+@click.option("--end-time", help="ISO8601 end time. Defaults to now.")
+@click.option(
+    "--metrics",
+    help=(
+        "Comma-separated metric names. Defaults to all metrics. Supported names: "
+        "memory_usage, cpu_usage, disk_usage, restart_count, replica_count, "
+        "worker_count, lg_run_count, responses_per_second, "
+        "error_responses_per_second, p95_latency, run_queue_wait_time. "
+        "Availability depends on the deployment and platform."
+    ),
+)
+@click.option(
+    "--summary", is_flag=True, help="Omit points and print per-series statistics only."
+)
+@click.option(
+    "--raw", is_flag=True, help="Print the original host-backend chart schema."
+)
+@deploy.command(
+    "metrics", help="[Beta] Fetch deployment monitoring time series as compact JSON."
+)
+def deploy_metrics(
+    api_key: str | None,
+    host_url: str | None,
+    deployment_id: UUID,
+    start_time: str | None,
+    end_time: str | None,
+    metrics: str | None,
+    summary: bool,
+    raw: bool,
+) -> None:
+    if summary and raw:
+        raise click.UsageError("--summary and --raw are mutually exclusive.")
+    end_time = end_time or datetime.now(timezone.utc).isoformat()
+    if start_time is None:
+        try:
+            end = datetime.fromisoformat(end_time.replace("Z", "+00:00"))
+        except ValueError as exc:
+            raise click.BadParameter(
+                "Expected an ISO8601 timestamp.", param_hint="--end-time"
+            ) from exc
+        end = end.replace(tzinfo=end.tzinfo or timezone.utc).astimezone(timezone.utc)
+        start_time = (end - timedelta(minutes=15)).isoformat()
+    params = {
+        key: value
+        for key, value in {
+            "start_time": start_time,
+            "end_time": end_time,
+            "metrics": metrics,
+        }.items()
+        if value is not None
+    }
+    client = _create_host_backend_client(host_url, api_key, no_input=True)
+    result = _call_host_backend_with_optional_tenant(
+        client,
+        lambda c: c.get_deployment_metrics(str(deployment_id), params),
+        no_input=True,
+    )
+    if not raw:
+        result = compact_deployment_metrics(
+            result,
+            str(deployment_id),
+            start_time=start_time,
+            end_time=end_time,
+            summary=summary,
+        )
+    click.echo(json_mod.dumps(result, separators=(",", ":")))
+
+
 @deploy.group(
     "listeners",
     cls=NestedHelpGroup,

libs/cli/langgraph_cli/deployment_metrics.py

@@ -0,0 +1,95 @@
+"""Compact deployment chart responses for command-line consumers."""
+
+import math
+from collections import Counter, defaultdict
+from datetime import datetime, timezone
+from statistics import fmean
+from typing import Any
+
+
+def _timestamp(value: str) -> datetime:
+    timestamp = datetime.fromisoformat(value.replace("Z", "+00:00"))
+    return timestamp.replace(tzinfo=timestamp.tzinfo or timezone.utc).astimezone(
+        timezone.utc
+    )
+
+
+def _iso(value: datetime) -> str:
+    return value.isoformat().replace("+00:00", "Z")
+
+
+def _unit(title: str, metric: str | None) -> str | None:
+    if "%" in title:
+        return "percent"
+    if metric in {
+        "restart_count",
+        "replica_count",
+        "worker_count",
+        "lg_run_count",
+        "run_count",
+    }:
+        return "count"
+    return None
+
+
+def compact_deployment_metrics(
+    response: dict[str, Any],
+    deployment_id: str,
+    *,
+    start_time: str,
+    end_time: str,
+    summary: bool = False,
+) -> dict[str, Any]:
+    """Reshape UI charts without mutating the response; step is in seconds."""
+    sections = {}
+    spacings: Counter[float] = Counter()
+    source_sections = list(response.get("sub_sections") or [])
+    if response.get("charts"):
+        source_sections.insert(0, response)
+    for section in source_sections:
+        charts = {}
+        for chart in section.get("charts") or []:
+            by_series = defaultdict(list)
+            for point in chart.get("data") or []:
+                timestamp = _timestamp(point["timestamp"])
+                value = point.get("value")
+                if value is not None and not math.isfinite(value):
+                    value = None
+                by_series[point["series_id"]].append((timestamp, value))
+            series_output = {}
+            for series in chart.get("series") or []:
+                points = sorted(by_series[series["id"]], key=lambda point: point[0])
+                times = sorted({timestamp for timestamp, _ in points})
+                spacings.update(
+                    (b - a).total_seconds()
+                    for a, b in zip(times, times[1:], strict=False)
+                )
+                values = [value for _, value in points if value is not None]
+                metric = series.get("project_metric")
+                stats = {
+                    "metric": metric,
+                    "unit": _unit(chart["title"], metric),
+                    "latest": round(values[-1], 3) if values else None,
+                    "min": round(min(values), 3) if values else None,
+                    "max": round(max(values), 3) if values else None,
+                    "avg": round(fmean(values), 3) if values else None,
+                }
+                if not summary:
+                    stats["points"] = [
+                        [
+                            _iso(timestamp),
+                            round(value, 3) if value is not None else None,
+                        ]
+                        for timestamp, value in points
+                    ]
+                series_output[series["name"]] = stats
+            charts[chart["title"]] = series_output or {"_empty": True}
+        sections[section["title"]] = charts or {"_empty": True}
+    step = min(spacings, key=lambda gap: (-spacings[gap], gap)) if spacings else None
+    return {
+        "deployment_id": deployment_id,
+        "start_time": start_time,
+        "end_time": end_time,
+        "step_seconds": int(step) if step is not None and step.is_integer() else step,
+        "sections": sections or {"_empty": True},
+    }

libs/cli/langgraph_cli/host_backend.py

@@ -362,6 +362,13 @@ class HostBackendClient:
             f"/v2/deployments/{deployment_id}/revisions/{revision_id}",
         )
 
+    def get_deployment_metrics(
+        self, deployment_id: str, params: dict[str, Any]
+    ) -> dict[str, Any]:
+        return self._request(
+            "GET", f"/v2/deployments/{deployment_id}/metrics", params=params
+        )
+
     def get_build_logs(
         self, project_id: str, revision_id: str, payload: dict[str, Any]
     ) -> Any:

libs/cli/tests/unit_tests/cli/test_deploy_monitoring.py

@@ -0,0 +1,166 @@
+import json
+from datetime import datetime, timezone
+
+import httpx
+import pytest
+from click.testing import CliRunner
+
+import langgraph_cli.deploy as deploy_module
+from langgraph_cli.cli import cli
+from langgraph_cli.deployment_metrics import compact_deployment_metrics
+from langgraph_cli.host_backend import HostBackendClient
+
+DEPLOYMENT_ID = "019a0000-0000-7000-8000-000000000001"
+
+
+def invoke(monkeypatch, args, handler, input=None):
+    client = HostBackendClient(
+        "https://api.example.com",
+        "key",
+        tenant_id="workspace-id",
+        transport=httpx.MockTransport(handler),
+    )
+    monkeypatch.setattr(deploy_module, "HostBackendClient", lambda *a, **kw: client)
+    return CliRunner().invoke(
+        cli,
+        ["deploy", *args, "--api-key", "key"],
+        input=input,
+    )
+
+
+@pytest.mark.parametrize(
+    "bounds", [[], ["start_time"], ["end_time"], ["start_time", "end_time"]]
+)
+@pytest.mark.parametrize("mode", [None, "--summary", "--raw"])
+def test_metrics(monkeypatch, bounds, mode, deployment_metrics_response):
+    charts = deployment_metrics_response
+
+    class FrozenDatetime(datetime):
+        @classmethod
+        def now(cls, tz=None):
+            return cls(2026, 10, 28, 23, 2, 33, tzinfo=timezone.utc)
+
+    monkeypatch.setattr(deploy_module, "datetime", FrozenDatetime)
+    explicit = {
+        "start_time": "2026-10-27T22:32:33Z",
+        "end_time": "2026-10-28T21:32:33Z",
+    }
+    options = {key: explicit[key] for key in bounds}
+    if bounds:
+        options["metrics"] = "cpu_usage,memory_usage"
+    params = {
+        "start_time": (
+            "2026-10-28T21:17:33+00:00"
+            if "end_time" in bounds
+            else "2026-10-28T22:47:33+00:00"
+        ),
+        "end_time": "2026-10-28T23:02:33+00:00",
+        **options,
+    }
+
+    def handler(request):
+        assert request.method == "GET"
+        assert request.url.path == f"/v2/deployments/{DEPLOYMENT_ID}/metrics"
+        assert dict(request.url.params) == params
+        assert request.headers["x-tenant-id"] == "workspace-id"
+        assert request.headers["x-api-key"] == "key"
+        return httpx.Response(200, json=charts)
+
+    args = ["metrics", DEPLOYMENT_ID]
+    for key, value in options.items():
+        args.extend([f"--{key.replace('_', '-')}", value])
+    if mode:
+        args.append(mode)
+    result = invoke(monkeypatch, args, handler)
+    assert result.exit_code == 0, result.output
+    expected = (
+        charts
+        if mode == "--raw"
+        else compact_deployment_metrics(
+            charts,
+            DEPLOYMENT_ID,
+            start_time=params.get("start_time"),
+            end_time=params.get("end_time"),
+            summary=mode == "--summary",
+        )
+    )
+    assert json.loads(result.output) == expected
+    if mode != "--raw":
+        assert expected["start_time"] == params["start_time"]
+        assert expected["end_time"] == params["end_time"]
+    assert result.output.strip() == json.dumps(expected, separators=(",", ":"))
+
+
+@pytest.mark.parametrize(
+    "args",
+    [
+        ["metrics", DEPLOYMENT_ID, "--step-seconds", "60"],
+        ["metrics", "invalid-id"],
+        ["metrics", DEPLOYMENT_ID, "--summary", "--raw"],
+    ],
+)
+def test_invalid_options_do_not_send_requests(monkeypatch, args):
+    def handler(request):
+        pytest.fail("Invalid options must not send a request")
+
+    result = invoke(monkeypatch, args, handler)
+    assert result.exit_code == 2, result.output
+
+
+def test_end_only_with_timezone_offset(monkeypatch):
+    def handler(request):
+        assert request.url.params["end_time"] == "2026-10-28T01:05:00+02:00"
+        assert request.url.params["start_time"] == "2026-10-27T22:50:00+00:00"
+        return httpx.Response(200, json={"charts": [], "sub_sections": []})
+
+    result = invoke(
+        monkeypatch,
+        ["metrics", DEPLOYMENT_ID, "--end-time", "2026-10-28T01:05:00+02:00"],
+        handler,
+    )
+    assert result.exit_code == 0, result.output
+    output = json.loads(result.output)
+    assert output["start_time"] == "2026-10-27T22:50:00+00:00"
+    assert output["end_time"] == "2026-10-28T01:05:00+02:00"
+
+
+def test_invalid_end_only_does_not_send_request(monkeypatch):
+    def handler(request):
+        pytest.fail("Invalid end time must not send a request")
+
+    result = invoke(
+        monkeypatch, ["metrics", DEPLOYMENT_ID, "--end-time", "not-a-date"], handler
+    )
+    assert result.exit_code == 2, result.output
+    assert "--end-time" in result.output
+    assert "ISO8601" in result.output
+
+
+def test_metrics_help_lists_supported_filters():
+    result = CliRunner().invoke(cli, ["deploy", "metrics", "--help"])
+    assert result.exit_code == 0, result.output
+    for metric in (
+        "memory_usage",
+        "cpu_usage",
+        "disk_usage",
+        "restart_count",
+        "replica_count",
+        "worker_count",
+        "lg_run_count",
+        "responses_per_second",
+        "error_responses_per_second",
+        "p95_latency",
+        "run_queue_wait_time",
+    ):
+        assert metric in result.output
+
+
+@pytest.mark.parametrize("status", [403, 422, 429])
+def test_backend_errors(monkeypatch, status):
+    def handler(request):
+        return httpx.Response(status, json={"detail": "Operation rejected"})
+
+    args = ["metrics", DEPLOYMENT_ID]
+    result = invoke(monkeypatch, args, handler)
+    assert result.exit_code == 1
+    assert "Operation rejected" in result.output

libs/cli/tests/unit_tests/conftest.py

@@ -1,9 +1,16 @@
+import json
 import os
+from pathlib import Path
 from unittest.mock import patch
 
 import pytest
 
 
+@pytest.fixture
+def deployment_metrics_response():
+    return json.loads(Path(__file__).with_name("deployment_metrics.json").read_text())
+
+
 @pytest.fixture(autouse=True)
 def disable_analytics_env() -> None:
     """Disable analytics for unit tests LANGGRAPH_CLI_NO_ANALYTICS."""

libs/cli/tests/unit_tests/deployment_metrics.json

@@ -0,0 +1,215 @@
+{
+  "id": "019a0000-0000-7000-8000-000000000001-metrics",
+  "title": "Metrics for deployment",
+  "charts": [],
+  "sub_sections": [
+    {
+      "id": "019a0000-0000-7000-8000-000000000001-queue",
+      "title": "Queue",
+      "description": "Queue metrics",
+      "index": 0,
+      "charts": [
+        {
+          "id": "019a0000-0000-7000-8000-000000000001-Memory Usage %",
+          "title": "Memory Usage %",
+          "description": "Resource usage over time",
+          "index": 0,
+          "chart_type": "line",
+          "series": [
+            {
+              "id": "019a0000-0000-7000-8000-000000000001-Avg Memory Usage %",
+              "name": "Avg Memory Usage %",
+              "metric": "run_count",
+              "project_metric": "memory_usage",
+              "metadata": null,
+              "filters": null,
+              "feedback_key": null,
+              "workspace_id": null,
+              "metric_definition": null,
+              "group_by_definitions": null,
+              "filter_definition": null,
+              "group_by": null
+            },
+            {
+              "id": "019a0000-0000-7000-8000-000000000001-Max Memory Usage %",
+              "name": "Max Memory Usage %",
+              "metric": "run_count",
+              "project_metric": "memory_usage",
+              "metadata": null,
+              "filters": null,
+              "feedback_key": null,
+              "workspace_id": null,
+              "metric_definition": null,
+              "group_by_definitions": null,
+              "filter_definition": null,
+              "group_by": null
+            }
+          ],
+          "data": [
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Max Memory Usage %",
+              "timestamp": "2026-10-28T00:02:00+00:00",
+              "value": 50.33333,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Max Memory Usage %",
+              "timestamp": "2026-10-28T00:01:00+00:00",
+              "value": 40.22222,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Max Memory Usage %",
+              "timestamp": "2026-10-28T00:00:00+00:00",
+              "value": 30.11111,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Avg Memory Usage %",
+              "timestamp": "2026-10-28T00:02:00+00:00",
+              "value": null,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Avg Memory Usage %",
+              "timestamp": "2026-10-28T00:01:00+00:00",
+              "value": 20.23456,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Avg Memory Usage %",
+              "timestamp": "2026-10-28T00:00:00+00:00",
+              "value": 10.12345,
+              "group": null
+            }
+          ]
+        },
+        {
+          "id": "019a0000-0000-7000-8000-000000000001-Restarts",
+          "title": "Restarts",
+          "description": "Resource usage over time",
+          "index": 0,
+          "chart_type": "line",
+          "series": [
+            {
+              "id": "019a0000-0000-7000-8000-000000000001-Restarts",
+              "name": "Restarts",
+              "metric": "run_count",
+              "project_metric": "restart_count",
+              "metadata": null,
+              "filters": null,
+              "feedback_key": null,
+              "workspace_id": null,
+              "metric_definition": null,
+              "group_by_definitions": null,
+              "filter_definition": null,
+              "group_by": null
+            }
+          ],
+          "data": [
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Restarts",
+              "timestamp": "2026-10-28T00:02:00+00:00",
+              "value": 2,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Restarts",
+              "timestamp": "2026-10-28T00:01:00+00:00",
+              "value": 1,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-Restarts",
+              "timestamp": "2026-10-28T00:00:00+00:00",
+              "value": 0,
+              "group": null
+            }
+          ]
+        },
+        {
+          "id": "019a0000-0000-7000-8000-000000000001-Queue wait time",
+          "title": "Queue wait time",
+          "description": "Resource usage over time",
+          "index": 0,
+          "chart_type": "line",
+          "series": [
+            {
+              "id": "019a0000-0000-7000-8000-000000000001-Queue wait time",
+              "name": "Queue wait time",
+              "metric": "run_count",
+              "project_metric": "run_queue_wait_time",
+              "metadata": null,
+              "filters": null,
+              "feedback_key": null,
+              "workspace_id": null,
+              "metric_definition": null,
+              "group_by_definitions": null,
+              "filter_definition": null,
+              "group_by": null
+            }
+          ],
+          "data": []
+        }
+      ]
+    },
+    {
+      "id": "019a0000-0000-7000-8000-000000000001-api",
+      "title": "API",
+      "description": "API metrics",
+      "index": 1,
+      "charts": [
+        {
+          "id": "019a0000-0000-7000-8000-000000000001-Latency",
+          "title": "Latency",
+          "description": "Resource usage over time",
+          "index": 0,
+          "chart_type": "line",
+          "series": [
+            {
+              "id": "019a0000-0000-7000-8000-000000000001-P95 Latency",
+              "name": "P95 Latency",
+              "metric": "run_count",
+              "project_metric": "p95_latency",
+              "metadata": null,
+              "filters": null,
+              "feedback_key": null,
+              "workspace_id": null,
+              "metric_definition": null,
+              "group_by_definitions": null,
+              "filter_definition": null,
+              "group_by": null
+            }
+          ],
+          "data": [
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-P95 Latency",
+              "timestamp": "2026-10-28T00:02:00+00:00",
+              "value": 0.34567,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-P95 Latency",
+              "timestamp": "2026-10-28T00:01:00+00:00",
+              "value": 0.23456,
+              "group": null
+            },
+            {
+              "series_id": "019a0000-0000-7000-8000-000000000001-P95 Latency",
+              "timestamp": "2026-10-28T00:00:00+00:00",
+              "value": 0.12345,
+              "group": null
+            }
+          ]
+        }
+      ]
+    },
+    {
+      "id": "019a0000-0000-7000-8000-000000000001-pg",
+      "title": "Postgres",
+      "description": "Postgres metrics",
+      "index": 2,
+      "charts": []
+    }
+  ]
+}

libs/cli/tests/unit_tests/test_deployment_metrics.py

@@ -0,0 +1,139 @@
+from copy import deepcopy
+
+import pytest
+
+from langgraph_cli.deployment_metrics import compact_deployment_metrics
+
+
+def reshape(response, deployment_id, **kwargs):
+    return compact_deployment_metrics(
+        response,
+        deployment_id,
+        start_time=kwargs.pop("start_time", "2026-10-28T00:00:00Z"),
+        end_time=kwargs.pop("end_time", "2026-10-28T01:00:00Z"),
+        **kwargs,
+    )
+
+
+def test_compact_metrics(deployment_metrics_response):
+    original = deepcopy(deployment_metrics_response)
+    result = reshape(deployment_metrics_response, "deployment-id")
+    assert deployment_metrics_response == original
+    assert result["deployment_id"] == "deployment-id"
+    assert result["start_time"] == "2026-10-28T00:00:00Z"
+    assert result["end_time"] == "2026-10-28T01:00:00Z"
+    assert result["step_seconds"] == 60
+    assert result["sections"]["Postgres"] == {"_empty": True}
+    queue = result["sections"]["Queue"]
+    memory = queue["Memory Usage %"]
+    assert memory["Avg Memory Usage %"] == {
+        "metric": "memory_usage",
+        "unit": "percent",
+        "latest": 20.235,
+        "min": 10.123,
+        "max": 20.235,
+        "avg": 15.179,
+        "points": [
+            ["2026-10-28T00:00:00Z", 10.123],
+            ["2026-10-28T00:01:00Z", 20.235],
+            ["2026-10-28T00:02:00Z", None],
+        ],
+    }
+    assert memory["Max Memory Usage %"]["max"] == 50.333
+    assert queue["Restarts"]["Restarts"]["unit"] == "count"
+    assert queue["Queue wait time"]["Queue wait time"] == {
+        "metric": "run_queue_wait_time",
+        "unit": None,
+        "latest": None,
+        "min": None,
+        "max": None,
+        "avg": None,
+        "points": [],
+    }
+    assert result["sections"]["API"]["Latency"]["P95 Latency"]["unit"] is None
+
+
+def test_summary_and_requested_bounds(deployment_metrics_response):
+    result = reshape(
+        deployment_metrics_response,
+        "id",
+        start_time="2026-10-27T23:00:00Z",
+        end_time="2026-10-28T01:00:00Z",
+        summary=True,
+    )
+    assert result["start_time"] == "2026-10-27T23:00:00Z"
+    assert result["end_time"] == "2026-10-28T01:00:00Z"
+    for section in result["sections"].values():
+        if section == {"_empty": True}:
+            continue
+        for chart in section.values():
+            for series in chart.values():
+                assert set(series) == {"metric", "unit", "latest", "min", "max", "avg"}
+
+
+@pytest.mark.parametrize("values", [[], [None], [float("nan"), float("inf")]])
+def test_empty_and_nonfinite_values(deployment_metrics_response, values):
+    chart = deployment_metrics_response["sub_sections"][0]["charts"][0]
+    chart["series"] = chart["series"][:1]
+    chart["data"] = [
+        {
+            "series_id": chart["series"][0]["id"],
+            "timestamp": f"2026-10-28T00:0{i}:00Z",
+            "value": value,
+        }
+        for i, value in enumerate(values)
+    ]
+    result = reshape(deployment_metrics_response, "id")
+    series = result["sections"]["Queue"]["Memory Usage %"]["Avg Memory Usage %"]
+    assert all(series[key] is None for key in ["latest", "min", "max", "avg"])
+    assert all(point[1] is None for point in series["points"])
+
+
+def test_tied_spacing_and_top_level_charts(deployment_metrics_response):
+    response = deployment_metrics_response
+    chart = response["sub_sections"][1]["charts"][0]
+    chart["data"][0]["timestamp"] = "2026-10-28T00:02:30Z"
+    response["charts"] = [chart]
+    response["sub_sections"] = []
+    result = reshape(response, "id")
+    assert result["step_seconds"] == 60
+    assert "Latency" in result["sections"][response["title"]]
+
+
+def test_missing_point_preserves_common_spacing(deployment_metrics_response):
+    chart = deployment_metrics_response["sub_sections"][0]["charts"][0]
+    series_id = chart["series"][0]["id"]
+    chart["data"] = [
+        point
+        for point in chart["data"]
+        if not (point["series_id"] == series_id and "00:01:00" in point["timestamp"])
+    ]
+    result = reshape(deployment_metrics_response, "id")
+    assert result["step_seconds"] == 60
+    assert type(result["step_seconds"]) is int
+
+
+def test_only_single_point_and_empty_series(deployment_metrics_response):
+    for section in deployment_metrics_response["sub_sections"]:
+        for chart in section["charts"]:
+            chart["data"] = chart["data"][:1]
+    assert reshape(deployment_metrics_response, "id")["step_seconds"] is None
+
+
+def test_fractional_spacing(deployment_metrics_response):
+    chart = deployment_metrics_response["sub_sections"][1]["charts"][0]
+    chart["data"][0]["timestamp"] = "2026-10-28T00:00:01Z"
+    chart["data"][1]["timestamp"] = "2026-10-28T00:00:00.500Z"
+    deployment_metrics_response["sub_sections"] = []
+    deployment_metrics_response["charts"] = [chart]
+    assert reshape(deployment_metrics_response, "id")["step_seconds"] == 0.5
+
+
+def test_no_data():
+    assert reshape({"charts": [], "sub_sections": []}, "id") == {
+        "deployment_id": "id",
+        "start_time": "2026-10-28T00:00:00Z",
+        "end_time": "2026-10-28T01:00:00Z",
+        "step_seconds": None,
+        "sections": {"_empty": True},
+    }

libs/cli/uv.lock

@@ -506,11 +506,28 @@ wheels = [
 
 [[package]]
 name = "filelock"
-version = "3.28.0"
+version = "4.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/17/6e8890271880903e3538660a21d63a6c1fea969ac71d0d6b608b78727fa9/filelock-3.28.0.tar.gz", hash = "sha256:4ed1010aae813c4ee8d9c660e4792475ee60c4a0ba76073ceaf862bd317e3ca6", size = 56474, upload-time = "2026-04-14T22:54:33.625Z" }
+resolution-markers = [
+    "python_full_version < '3.11'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/4c/58/6fd434bec86eff7c38a3168454cb132b762b2bea9b3ac094101a2f7bc32a/filelock-4.1.0.tar.gz", hash = "sha256:ad7f724afef953e731b1cc39bcd3a09166d72ed7fcdf29e6e88b1c3235c6715d", size = 561277, upload-time = "2026-10-09T19:57:20.34Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3b/21/2f728888c45033d34a417bfcd248ea2564c9e08ab1bfd301377cf05d5586/filelock-3.28.0-py3-none-any.whl", hash = "sha256:de9af6712788e7171df1b28b15eba2446c69721433fa427a9bee07b17820a9db", size = 39189, upload-time = "2026-04-14T22:54:32.037Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/86/032133892a5de43b5a98200b01aadcad68cc255e274a762f08b8a76d2912/filelock-4.1.0-py3-none-any.whl", hash = "sha256:2ce9818e3e2d8f284c1a964414447ef148d42a5fd5e2a477a7118e574b293ec1", size = 133003, upload-time = "2026-10-09T19:57:18.716Z" },
+]
+
+[[package]]
+name = "filelock"
+version = "4.2.9"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15'",
+    "python_full_version >= '3.12' and python_full_version < '3.15' and sys_platform == 'emscripten'",
+    "python_full_version == '3.11.*' or (python_full_version >= '3.12' and python_full_version < '3.15' and sys_platform != 'emscripten')",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a3/1d/d730c664fcb4f1d264a722722a3134cf0881854f73c1fd58abf87572f232/filelock-4.2.9.tar.gz", hash = "sha256:96530b7c538d4ea08493ab067247aab7948c54d8cd622cce711c97cccc5d9896", size = 663116, upload-time = "2026-11-04T18:37:10.014Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/05/76184fe08339723d643ab47887a8e4de8f2921ca4e008617ab7490af7857/filelock-4.2.9-py3-none-any.whl", hash = "sha256:a379c50a729e5b68c8519a4d26489f755d9769960a236ecd838190e2a78db2e9", size = 164734, upload-time = "2026-11-04T18:37:08.273Z" },
 ]
 
 [[package]]
@@ -533,139 +550,139 @@ wheels = [
 
 [[package]]
 name = "grpcio"
-version = "1.80.0"
+version = "1.81.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions", version = "4.15.0", source = { registry = "https://pypi.org/simple" } },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/b5/1ff353970a87eda4c98251e34d2dfd214abd4982dc89119c9252a2a482d2/grpcio-1.81.1.tar.gz", hash = "sha256:6fa10a767143a5e82e8eaab53918af0cd8909a57a27f8cb2288b80a613ac671b", size = 13026582, upload-time = "2026-06-11T12:46:51.673Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/cd/bb7b7e54084a344c03d68144450da7ddd5564e51a298ae1662de65f48e2d/grpcio-1.80.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:886457a7768e408cdce226ad1ca67d2958917d306523a0e21e1a2fdaa75c9c9c", size = 6050363, upload-time = "2026-03-30T08:46:20.894Z" },
-    { url = "https://files.pythonhosted.org/packages/16/02/1417f5c3460dea65f7a2e3c14e8b31e77f7ffb730e9bfadd89eda7a9f477/grpcio-1.80.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:7b641fc3f1dc647bfd80bd713addc68f6d145956f64677e56d9ebafc0bd72388", size = 12026037, upload-time = "2026-03-30T08:46:25.144Z" },
-    { url = "https://files.pythonhosted.org/packages/43/98/c910254eedf2cae368d78336a2de0678e66a7317d27c02522392f949b5c6/grpcio-1.80.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:33eb763f18f006dc7fee1e69831d38d23f5eccd15b2e0f92a13ee1d9242e5e02", size = 6602306, upload-time = "2026-03-30T08:46:27.593Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f8/88ca4e78c077b2b2113d95da1e1ab43efd43d723c9a0397d26529c2c1a56/grpcio-1.80.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:52d143637e3872633fc7dd7c3c6a1c84e396b359f3a72e215f8bf69fd82084fc", size = 7301535, upload-time = "2026-03-30T08:46:29.556Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/96/f28660fe2fe0f153288bf4a04e4910b7309d442395135c88ed4f5b3b8b40/grpcio-1.80.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c51bf8ac4575af2e0678bccfb07e47321fc7acb5049b4482832c5c195e04e13a", size = 6808669, upload-time = "2026-03-30T08:46:31.984Z" },
-    { url = "https://files.pythonhosted.org/packages/47/eb/3f68a5e955779c00aeef23850e019c1c1d0e032d90633ba49c01ad5a96e0/grpcio-1.80.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:50a9871536d71c4fba24ee856abc03a87764570f0c457dd8db0b4018f379fed9", size = 7409489, upload-time = "2026-03-30T08:46:34.684Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/a7/d2f681a4bfb881be40659a309771f3bdfbfdb1190619442816c3f0ffc079/grpcio-1.80.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a72d84ad0514db063e21887fbacd1fd7acb4d494a564cae22227cd45c7fbf199", size = 8423167, upload-time = "2026-03-30T08:46:36.833Z" },
-    { url = "https://files.pythonhosted.org/packages/97/8a/29b4589c204959aa35ce5708400a05bba72181807c45c47b3ec000c39333/grpcio-1.80.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f7691a6788ad9196872f95716df5bc643ebba13c97140b7a5ee5c8e75d1dea81", size = 7846761, upload-time = "2026-03-30T08:46:40.091Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/d2/ed143e097230ee121ac5848f6ff14372dba91289b10b536d54fb1b7cbae7/grpcio-1.80.0-cp310-cp310-win32.whl", hash = "sha256:46c2390b59d67f84e882694d489f5b45707c657832d7934859ceb8c33f467069", size = 4156534, upload-time = "2026-03-30T08:46:42.026Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/c9/df8279bb49b29409995e95efa85b72973d62f8aeff89abee58c91f393710/grpcio-1.80.0-cp310-cp310-win_amd64.whl", hash = "sha256:dc053420fc75749c961e2a4c906398d7c15725d36ccc04ae6d16093167223b58", size = 4889869, upload-time = "2026-03-30T08:46:44.219Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" },
-    { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" },
-    { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" },
-    { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" },
-    { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" },
-    { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" },
-    { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" },
-    { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" },
-    { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" },
-    { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" },
-    { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" },
-    { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" },
-    { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" },
-    { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" },
-    { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" },
-    { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/d5/f2b159d8eec08be2a855ef698f5b6f7f9fdda022e4dd9e4f5d968affd678/grpcio-1.81.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:6f9a0c9c1cc15c112d1c053064fd032b64917062292c3d70aea280e02ae10b77", size = 6086868, upload-time = "2026-06-11T12:44:19.364Z" },
+    { url = "https://files.pythonhosted.org/packages/80/41/9c95232b94b219ed8b14029d9cd000e0381cafba869c451dda60af84f4ba/grpcio-1.81.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:69ef28e54fc85397f91b8c19592b8ef3d81952080366914823bd8572a2958120", size = 12062291, upload-time = "2026-06-11T12:44:27.142Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8b/bd9284bdd665ddf877a3e8bc2930d1bcf6ebdbae7b0da5c783dc26bd6e33/grpcio-1.81.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:15641444eca4a29358107b3dceb74c1c6305c55c822fd199b458aaea4068a7fb", size = 6635242, upload-time = "2026-06-11T12:44:30.741Z" },
+    { url = "https://files.pythonhosted.org/packages/60/24/78fa025517a925f1a17da71c4ef9d5f1c6f9fa65af22dfb523c5c6317a21/grpcio-1.81.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d4b2dddfc219f54f956ccd53cf76a1d338ffe68fc7f2849ec9c7feb9927ff692", size = 7332974, upload-time = "2026-06-11T12:44:33.72Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/11/402295b388dd35861007f8a26a37c2e2f284212d57bdf407c31f36043746/grpcio-1.81.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ca1cc11d82677b9662082e5478b7528e2b7db7beaa6bdff42bd62789d81be399", size = 6836597, upload-time = "2026-06-11T12:44:36.108Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/71/37b10fd4fd579ffade6e695c14e9df5e8cba9e2365b81c131da438b67c34/grpcio-1.81.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:aa2ba7d2ad6df4d80127cea65e5b8d5e2c3adbf153ff4804452836328aca7c54", size = 7440660, upload-time = "2026-06-11T12:44:38.664Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d5/40203f828abc83d458b634666df6df13778032f178c03845ad5a93682388/grpcio-1.81.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:592b5fee597faa91cce2dd294dd7d9a1c83d76c4dbf877e33ec1adb866b2fbed", size = 8443171, upload-time = "2026-06-11T12:44:41.678Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/2c/0ed82ea35b5ec595e10444940c1db8c0e0ef57aa46bc8797d5ff838a219e/grpcio-1.81.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:62481553b1793a27e9b9c3cf9e5bd483ef045ca72462592074b46d42b0c4d9b9", size = 7868905, upload-time = "2026-06-11T12:44:44.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1f/dcbdc1a68a07cc2b631c3098953794f17d75f93426a019240b90ce5423d6/grpcio-1.81.1-cp310-cp310-win32.whl", hash = "sha256:bb693b1e3d9a2f3fd228e2110daf4b5aeedb36761ca1e4282f74725f6d89f611", size = 4202215, upload-time = "2026-06-11T12:44:47.165Z" },
+    { url = "https://files.pythonhosted.org/packages/75/a1/d7ab9f1f42efcb7d9e6111d38be6b367737a72ea2c534e1f55c81e1b6436/grpcio-1.81.1-cp310-cp310-win_amd64.whl", hash = "sha256:88268ca418cacea64cecb0d1d600d3c6b3a8038fcba02e1e205178c5b1f47661", size = 4936582, upload-time = "2026-06-11T12:44:49.479Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ea/1c2fa386b718ff493225e61cfc052ef400b4d6ffc54cbe261026432624b5/grpcio-1.81.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:d71d30f2d92f67d944631c523713934fee37292469e182ebcd2c1dd8a64ce53f", size = 6093112, upload-time = "2026-06-11T12:44:52.131Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/18/acf45fa8bd1bc5d7b0c2fd3dc4c209379fbd5bb396b440b68a83342226b7/grpcio-1.81.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:b137f4bf3ada9dc44d411478decc6ff09a79ed30b306cd2abaa98408c3588137", size = 12074277, upload-time = "2026-06-11T12:44:55.354Z" },
+    { url = "https://files.pythonhosted.org/packages/48/d7/ee86a60699b7db039f772a2c4a7e4facc7138984ff42c0130933a0063884/grpcio-1.81.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a3acb384427816dd5d470f47e62137b87f74da694faa8a50147012cf40df276a", size = 6640348, upload-time = "2026-06-11T12:44:59.223Z" },
+    { url = "https://files.pythonhosted.org/packages/26/ee/d2de5e47378ffc207d476c230fea3be4d2601edbce9995f4fe45535d4896/grpcio-1.81.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f9a0ebbe45c29b5e5866593c12b78bd9035f0f0f0d4bc8361680cd580d99db49", size = 7331842, upload-time = "2026-06-11T12:45:02.001Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d6/abeda5c2b896a0b341584fe5ac411bbf72e197a9a374c355fb90965e08d2/grpcio-1.81.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a37165cc80b1a368384b383e63a4c38116a10467ae44c904d2d7468c4470ec2", size = 6842229, upload-time = "2026-06-11T12:45:04.76Z" },
+    { url = "https://files.pythonhosted.org/packages/10/1c/1f0da7d590b4aeee006826ba568d0e419ca14b23e18f901a3da3e9fba613/grpcio-1.81.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6282caffb41ec326d4cb67ca9cf53b739d1b2f975a2acb498c7418e9f7d9a416", size = 7446096, upload-time = "2026-06-11T12:45:07.499Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/81/5c505d508f7c887aa7982d21443a4126597c80d34b0bcf40f9cec576d7f3/grpcio-1.81.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a35009284d0d3d5c2c9601c164a911b8b4331608d98a9a66d47d97bb2f522b70", size = 8445238, upload-time = "2026-06-11T12:45:10.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/b2/524847365122ee509ca17bcc4e092198b700e94af7bfd5bb5e6dd9f3ee66/grpcio-1.81.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1b22c80559854b789a01fd89e8929b3798a156c0829b5282a8939f33ad4115ad", size = 7873989, upload-time = "2026-06-11T12:45:13.102Z" },
+    { url = "https://files.pythonhosted.org/packages/18/fa/07c037c50b006909d1d13a5848774f8aa7b242f70dc03a035c64eea0e6db/grpcio-1.81.1-cp311-cp311-win32.whl", hash = "sha256:428bec0161b48d8cf583c068591bc0016d0d9cfff52462b72b3884861ea768c5", size = 4202223, upload-time = "2026-06-11T12:45:16.166Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ed/6bff15376920942fac6b95b9802752b837437172c9e8fc2d3170546b89cc/grpcio-1.81.1-cp311-cp311-win_amd64.whl", hash = "sha256:30e825f6848d9f18bba350ed6c75c1b02a0b5184474a31db9a32b1fa66fd8c79", size = 4941303, upload-time = "2026-06-11T12:45:18.724Z" },
+    { url = "https://files.pythonhosted.org/packages/85/07/9a979c81738863a738dc23d65177056e71fbb2db817740ed870b33434e7a/grpcio-1.81.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:8b39472beafc0bdcafc4c8c73ad082ebfdb449d566897a61e7acb4fa88089115", size = 6053264, upload-time = "2026-06-11T12:45:21.017Z" },
+    { url = "https://files.pythonhosted.org/packages/75/95/539706ca0d3bd40dbad583dc56fd883da941f37556b629132da5762781b9/grpcio-1.81.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:12b7524c88d4026d3dcb7b0ebe16b6714f3b4af402ddd0f0639ab064a00c87c3", size = 12052560, upload-time = "2026-06-11T12:45:23.652Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/44/f257b7e0bd69c93b06c6cb8ac8d1b901ccb42bedabd83c1a4c77a71f8810/grpcio-1.81.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1e123f9b37edb8375fd74130d1f69c944bbf0a7b06761ae7211154b8759e94d2", size = 6595983, upload-time = "2026-06-11T12:45:26.963Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/f3/19782aa04c960968bef8c5539329d8e3bbc3364e2e46d19eb5e5cc5e43b7/grpcio-1.81.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:2c2e2ae6867c2966b8daccc836d54a13218e0007e9a490aeb81dd05be64d22d7", size = 7303455, upload-time = "2026-06-11T12:45:29.707Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/8c/dea020b6d91508cd84463917a63149ec196ee7db505d032ae43fcb3303b9/grpcio-1.81.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:766bc7c9a9c340342f4c864ccbda8e78111e4751f13b895812b9c148fb79e9d0", size = 6809167, upload-time = "2026-06-11T12:45:32.52Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/c7/3030dd940408083bd32cd95d634777a71605ade4887154d93e8a89244946/grpcio-1.81.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b259a04a737cb3496be0901328eb8b7552ed8df4865d8c8f1cf1bffcfc0776a3", size = 7412536, upload-time = "2026-06-11T12:45:35.403Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/dd/1172a9e42b168edcafefad6115346ef619a3fc02158bb170e66ced24bcdd/grpcio-1.81.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:85b10a45b8993d195c4f3ff57025b8d1e11834909ee475c403bfa60cb4caefaf", size = 8408276, upload-time = "2026-06-11T12:45:37.78Z" },
+    { url = "https://files.pythonhosted.org/packages/25/7a/71437c7f3596e5246155c515852795a85a1a8d228190212432b13b97a95d/grpcio-1.81.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8ea1936c26b99999b27479853039a7f34713f56c49375ad52b38535ec93a796c", size = 7849660, upload-time = "2026-06-11T12:45:40.627Z" },
+    { url = "https://files.pythonhosted.org/packages/65/40/7debc0da45d2efebafb82da75644be347497fe4ee250514b8cd3b86ae8bf/grpcio-1.81.1-cp312-cp312-win32.whl", hash = "sha256:a185a04039df6cae8648bc8ab6d6fde7bf94f7188ecf7828e76ac52eef1e41d6", size = 4185819, upload-time = "2026-06-11T12:45:43.027Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b9/8fe3ba5ed462067774ebc1f9c7f26aa7ebcc280ddd476be107153de1339e/grpcio-1.81.1-cp312-cp312-win_amd64.whl", hash = "sha256:3ad74f8bb1a18963914c5452d289422830b39459e8776ebbcd207be1fbfb1d94", size = 4930461, upload-time = "2026-06-11T12:45:45.775Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/42/dcc2e4b600538ef18327c0839d56b7d3c3812337c5d710df5877dbb39b1e/grpcio-1.81.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:b10e1ff4756ed27d5a29d7fc79cfce7ef1ff56ad20025b89bac7cf79e09abbbe", size = 6054466, upload-time = "2026-06-11T12:45:48.43Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/4a/a36e03210183a8a7d4c80c3936acee679f4bd77d5861f369db47b2cc5f05/grpcio-1.81.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:819edbdcb42ab8598b494bcf0222684bbb7a3c772bd1b1f0be7e029a6063c28e", size = 12048795, upload-time = "2026-06-11T12:45:54.011Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/d5/d68e30b29098f63beab6fe501100fe82674ff142b32c672532da86a99b3a/grpcio-1.81.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5bf2dc311127d91230cc79b92188c082634a06cf66c5234db49a43b910183b0", size = 6599094, upload-time = "2026-06-11T12:45:57.799Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b3/e837954d279754f638a11cca5dcf6b24a005efb398984cefaf7735945a54/grpcio-1.81.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e8ca6a1fcdb2943c9cbc1804a1baf3acb6071d72a471591678ded84218006e14", size = 7307182, upload-time = "2026-06-11T12:46:00.568Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/1e/b47957057e729adc6cdf519a47f8be2562b7140e280f1418443eb4022192/grpcio-1.81.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e64dd101d380a115cc5a0c7856788adb535f1a4e21fc543775602f8be95180ae", size = 6810962, upload-time = "2026-06-11T12:46:03.312Z" },
+    { url = "https://files.pythonhosted.org/packages/40/26/569868e364e05b19ec8f969da53d230bcd89c962cd198f7c29943155c4d3/grpcio-1.81.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:98a07f9bf591e3a8919797bee1c53f026ba4acd587e5a4404c8e57c9ec36b2a5", size = 7415698, upload-time = "2026-06-11T12:46:06.005Z" },
+    { url = "https://files.pythonhosted.org/packages/36/0c/5440a0582cb5653fc42a6e262eeb22700943313f8076f9dc927491b20a59/grpcio-1.81.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c261d74b1a945cf895a9d6eccd1685a8e837531beaab782da4d630a8d12deffb", size = 8407779, upload-time = "2026-06-11T12:46:08.84Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/aa/66fe9f39871d766987d869a03ee0842a026f499c7b1e62decb9e78a8088e/grpcio-1.81.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:58ad1131c300d3c9b933802b3cc4dc69d380822935ba50b28703156ea826fbf7", size = 7844521, upload-time = "2026-06-11T12:46:12.171Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/9e/69bb7194861bcd28fb3193261d4f9c3831b4446993f002cf59068943e7ab/grpcio-1.81.1-cp313-cp313-win32.whl", hash = "sha256:78e29211f26da2fdd0e9c6d2b79f489476140cf7029b6a64808ade7ca4156a42", size = 4182786, upload-time = "2026-06-11T12:46:15.192Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/20/3da8bb0d637feccdc3e1e419bb511ce93651ce7d54164f95de22cc0b8b34/grpcio-1.81.1-cp313-cp313-win_amd64.whl", hash = "sha256:edb59506291b647a30884b1d51a599d605f40b20af4a7dc3d33786a47a31de60", size = 4928648, upload-time = "2026-06-11T12:46:17.823Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/58/19414622b1bf6981bc9c05a365bd548e71876c89000083b3af489251e9c0/grpcio-1.81.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:506f48f2f9c29b143fca3dad7b0d518c188b6c9648c75a2ae6e2d9f2c13a060b", size = 6055336, upload-time = "2026-06-11T12:46:20.557Z" },
+    { url = "https://files.pythonhosted.org/packages/32/f1/2ec88adb92b0eba970dd0e0e7dd086341daa3c75eba4f735f9e44bf684b0/grpcio-1.81.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d865db4a6318e1c1bea83292e0ed231090538fc4ca45425b0f0480eb338bbc6e", size = 12056279, upload-time = "2026-06-11T12:46:24.255Z" },
+    { url = "https://files.pythonhosted.org/packages/41/36/e8c5f8c6ec71de73733695ebc809e98b178b534ec6d8eaa31a7ebab4ad4c/grpcio-1.81.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e2aa72e3ce1770317ef534f63d397b55e130725f5149bd36077c3b539019db27", size = 6608225, upload-time = "2026-06-11T12:46:27.601Z" },
+    { url = "https://files.pythonhosted.org/packages/30/22/96fc577a845ab093326d9ab1adb874bd4936c8cf98ac8ed2f3db13a0a2fb/grpcio-1.81.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0490c30c261eded63f3f354979f9dc4502a9fb944cccb60cd9dc85f5a7349854", size = 7306576, upload-time = "2026-06-11T12:46:30.514Z" },
+    { url = "https://files.pythonhosted.org/packages/76/7b/61dab5d5969f28d97fb1009cead1df0a5cd987d3315e1b37f18a4449f8bc/grpcio-1.81.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:410482da976329fe5f4067270401b12cf2bd552ff8020f054ecfaddb5475f9d6", size = 6812165, upload-time = "2026-06-11T12:46:33.699Z" },
+    { url = "https://files.pythonhosted.org/packages/82/78/6e501929d4f5f96462fd82fd9f0f06e5f9612207582b862868d68757b27d/grpcio-1.81.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3657301562ac3cb8018d30d0d3ebfa39932239f7b5703422057ef14b69949f5", size = 7422962, upload-time = "2026-06-11T12:46:36.511Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/7e/f2157589e66daa78ebb3165942d05a08bdea93b9d11c2bc1e172aef89685/grpcio-1.81.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:24c8e57504c8f45b237e40b99262d181071e5099a07053695b75d97bb53053a0", size = 8408176, upload-time = "2026-06-11T12:46:39.803Z" },
+    { url = "https://files.pythonhosted.org/packages/da/df/c6717fef716e00d235ffb96123baf6dce76d6004f6233fa767c502861460/grpcio-1.81.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b427c19380991a4eaab2f6144b64b99b412043314c6bf4ab544f97bb31ee4190", size = 7846681, upload-time = "2026-06-11T12:46:43.013Z" },
+    { url = "https://files.pythonhosted.org/packages/36/84/3502e9f210a6a5c4438c8aca3f88edd2e04f6a27f3d41b26cf0a0024b096/grpcio-1.81.1-cp314-cp314-win32.whl", hash = "sha256:61233fe8951e5c85dff81c2458b6528624760166946b5b47ea150a589168411f", size = 4264615, upload-time = "2026-06-11T12:46:45.741Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b0/4af731ff7492c68a96e4c71bfd0f4590acde92b31c6fe4894e6465c10ff6/grpcio-1.81.1-cp314-cp314-win_amd64.whl", hash = "sha256:3768a5ff1b2125e6f552e561b6b2dca0e64982d8949689b4df145cf8b98d7821", size = 5070275, upload-time = "2026-06-11T12:46:48.486Z" },
 ]
 
 [[package]]
 name = "grpcio-health-checking"
-version = "1.80.0"
+version = "1.81.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "grpcio" },
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/a2/aa3cc47f19c03f8e5287b987317059753141a3af8f66b96d5a64b3be10b8/grpcio_health_checking-1.80.0.tar.gz", hash = "sha256:2cc5f08bc8b816b8655ab6f59c71450063ba20766d31e21a493e912e3560c8b1", size = 17117, upload-time = "2026-03-30T08:54:41.899Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/46/6b6678b5a922765ae7637205bb6d0618a4da8b35f2ce6116f8bcff262370/grpcio_health_checking-1.81.1.tar.gz", hash = "sha256:ecc61480e25058a4a04e11e4ab6900ad7439b32e60a8ce4ece7d9f219221c85d", size = 17107, upload-time = "2026-06-11T12:58:49.632Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/d1/d97eb30386feff6ac2a662620e2ed68be352e9a182d62e06213db694906a/grpcio_health_checking-1.80.0-py3-none-any.whl", hash = "sha256:d804d4549cbb71e90ca2c7bf0c501060135dfd220aca8e2c54f96d3e79e210e5", size = 19125, upload-time = "2026-03-30T08:53:44.835Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/87/174bbfb5613794862c45b5cdf567fcfb478ad5a3a7b594e11d998656b2f9/grpcio_health_checking-1.81.1-py3-none-any.whl", hash = "sha256:cbc6a4171825ec64389de2f062d296ba129a5c27eefd0dd55fa837909184bdf9", size = 19120, upload-time = "2026-06-11T12:58:38.008Z" },
 ]
 
 [[package]]
 name = "grpcio-tools"
-version = "1.80.0"
+version = "1.81.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "grpcio" },
     { name = "protobuf" },
     { name = "setuptools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/94/c8/1223f29c84a143ae9a56c084fc96894de0ba84b6e8d60a26241abd81d278/grpcio_tools-1.80.0.tar.gz", hash = "sha256:26052b19c6ce0dcf52d1024496aea3e2bdfa864159f06dc7b97b22d041a94b26", size = 6133212, upload-time = "2026-03-30T08:52:39.077Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/b3/1c5951352d6777fd7f99a0ccee04617fdfd8a5dbf2918a1f58c8b2b280b8/grpcio_tools-1.81.1.tar.gz", hash = "sha256:a22a3870180927fdd84e2b27d079ef5b7f5f8c6110181b6736afc17a463481f1", size = 6236155, upload-time = "2026-06-11T12:51:21.235Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7a/54/1de67f5080da305a258758a8deb33f85666fa759f56785042a80b114a53f/grpcio_tools-1.80.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:727477b9afa4b53f5ec70cafb41c3965d893835e0d4ea9b542fe3d0d005602bf", size = 2549601, upload-time = "2026-03-30T08:50:09.498Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/b4/6d57ea199c5b880d182a2234aafa9a686f9c54c708ea7be75bd19d5aa825/grpcio_tools-1.80.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:85fe8d15f146c62cb76f38d963e256392d287442b9232717d30ae9e3bbda9bc3", size = 5712717, upload-time = "2026-03-30T08:50:15.028Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/1a/5505ee2277d368b409c796c78f22ea34a2a517b7d16755247efd663dc7af/grpcio_tools-1.80.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:95f0fffb5ca00519f3b602f938169b4dfa04b165e03258323965a9dfe8cc4d80", size = 2595941, upload-time = "2026-03-30T08:50:17.299Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/39/7fc1d16d8b767805079d76365d73e82c88dfaf179034473dbc9fbccedb77/grpcio_tools-1.80.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:7a0106af212748823a6ebd8ffbd9043414216f47cae3835f3187de0a62c415d3", size = 2909304, upload-time = "2026-03-30T08:50:19.485Z" },
-    { url = "https://files.pythonhosted.org/packages/97/d8/276ee759755d8f34f2ca5e9d2debd1a59f29f66059fb790bc369f2236c26/grpcio_tools-1.80.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:31fd01a4038b5dfc4ec79504a17061344f670f851833411717fef66920f13cd7", size = 2660269, upload-time = "2026-03-30T08:50:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/51/04/a6bb47942ad52901d777a649324d3203cf19d487f1d446263637f7a5bf12/grpcio_tools-1.80.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:57da9e19607fac4a01c48ead333c0dd15d91ed38794dce1194eda308f73e2038", size = 3109798, upload-time = "2026-03-30T08:50:23.267Z" },
-    { url = "https://files.pythonhosted.org/packages/be/50/7ee69b2919916739787d725f205b878e8d1619dd30422b8278e324664669/grpcio_tools-1.80.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:90968f751851abb8b145593609800fa70c837e1c93ba0792c480b1c8d8bc29ef", size = 3658930, upload-time = "2026-03-30T08:50:25.458Z" },
-    { url = "https://files.pythonhosted.org/packages/92/61/6d50783092b0e8bbcb04152d5388bf50ecf3ea2f783d95288ff6c3bb00fa/grpcio_tools-1.80.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b69dc5d6376ab43406304d1e2fc61ccf960b287d4325d77c3d45448c37a9d2da", size = 3326562, upload-time = "2026-03-30T08:50:27.809Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/58/d272ba549f6b1f0d8504f5fc4cd0a296f2c495a64d6e987fe871c4151557/grpcio_tools-1.80.0-cp310-cp310-win32.whl", hash = "sha256:3e8dcfebe34cb54df095de3d5871a4562a85a29f26d0f8bb41ee2c3dcfb11c3c", size = 997620, upload-time = "2026-03-30T08:50:29.959Z" },
-    { url = "https://files.pythonhosted.org/packages/70/5f/9f45a9946a0298711c72ca48b2c1f46a7d0c207a44cd3e4bb59d04556ba3/grpcio_tools-1.80.0-cp310-cp310-win_amd64.whl", hash = "sha256:fc622ed4ca400695f41c9eae3266276c6ba007e4c28164ce53b44e7ccc5e492b", size = 1162466, upload-time = "2026-03-30T08:50:32.242Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/d7/225dc91e6cb4f8d4830f16a478a468e9c6f342dcdf8cacc3772cc1d1f607/grpcio_tools-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:1c43e5c768578fe0c6de3dbfaabe64af642951e1aa05c487cacedda63fa6c6c4", size = 2549937, upload-time = "2026-03-30T08:50:34.651Z" },
-    { url = "https://files.pythonhosted.org/packages/97/3d/a3684cb7677f3bea8db434eae02a9ce30135d7a268cd473b1bc8041c4722/grpcio_tools-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:a225348456575f3ac7851d8e23163195e76d2a905ee340cf73f33da62fba08aa", size = 5713099, upload-time = "2026-03-30T08:50:37.158Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/81/5665c697173ec346076358bfbfed0f7386825852494593ca14386478dfee/grpcio_tools-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a9396f02820d3f51c368c2c9dee15c55c77636c91be48a4d5c702e98d6fe0fdc", size = 2595776, upload-time = "2026-03-30T08:50:39.087Z" },
-    { url = "https://files.pythonhosted.org/packages/03/4f/fb81384f08a8226fa079972ba88272ac6277581fc72e8ab234d74c7e065b/grpcio_tools-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:797c08460cae16b402326eac329aec720dccf45c9f9279b95a352792eb53cf0f", size = 2909144, upload-time = "2026-03-30T08:50:40.922Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/9c/c957618f1c2a3195ecf5e83b03edcb364c2c1391f74183cb76e5763fa536/grpcio_tools-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1872a867eb6217de19edb70a4ce4a374ced9d94293533dfd42fa649713f55bf4", size = 2660477, upload-time = "2026-03-30T08:50:42.766Z" },
-    { url = "https://files.pythonhosted.org/packages/42/c7/23913da184febfd4eaf04de256a26bc5ff0411a5feb753e2adcff10fa86a/grpcio_tools-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:db122ba5ee357e3bb14e8944d69bbebcbdae91d5eace29ed4df3edc53cbc6528", size = 3110164, upload-time = "2026-03-30T08:50:44.761Z" },
-    { url = "https://files.pythonhosted.org/packages/af/fa/b25ed85ebdb0396910eaa250b1346d75527d22fca586265416bd4330dcd5/grpcio_tools-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ddefd48c227e6f4d640fe576fac5fb2c4a8898196f513604c8ec7671b3b3d421", size = 3658988, upload-time = "2026-03-30T08:50:47.546Z" },
-    { url = "https://files.pythonhosted.org/packages/60/85/2a55147cc9645e2ed777d1afcd2dc68cb34ba6f6c726bd4378ddb001a5ea/grpcio_tools-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:970ec058fa469dd6dae6ebc687501c5da670d95dead75f62f5b0933dce2c9794", size = 3326662, upload-time = "2026-03-30T08:50:49.59Z" },
-    { url = "https://files.pythonhosted.org/packages/68/ed/b05bee2a992e6f9bda81909692ea920d0896cfa05c5c9dd77ba03f2d22fb/grpcio_tools-1.80.0-cp311-cp311-win32.whl", hash = "sha256:526b4402d47a0e9b31cd6087e42b7674784617916cc73c764e0bc35ed41b4ee5", size = 997969, upload-time = "2026-03-30T08:50:51.539Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/9a/cb50c8270e2f6285ff2761130ae257ac4e51789ded4b9d9710ce0381814d/grpcio_tools-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:ee101ecda7231770f6a5da1024a9a6ed587a7785f8fe23ab8283f4a1acb3ffe6", size = 1162742, upload-time = "2026-03-30T08:50:54.232Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b9/65929df8c9614792db900a8e45d4997fadbd1734c827da3f0eb1f2fe4866/grpcio_tools-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:d19d5a8244311947b96f749c417b32d144641c6953f1164824579e1f0a51d040", size = 2550856, upload-time = "2026-03-30T08:50:57.3Z" },
-    { url = "https://files.pythonhosted.org/packages/28/17/af1557544d68d1aeca9d9ea53ed16524022d521fec6ba334ab3530e9c1a6/grpcio_tools-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:fb599a3dc89ed1bb24489a2724b2f6dd4cddbbf0f7bdd69c073477bab0dc7554", size = 5710883, upload-time = "2026-03-30T08:51:00.077Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/48/aa9b4f7519ca972bc40d315d5c28f05ca28fa08de13d4e8b69f551b798ab/grpcio_tools-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:623ee31fc2ff7df9a987b4f3d139c30af17ce46a861ae0e25fb8c112daa32dd8", size = 2598004, upload-time = "2026-03-30T08:51:02.102Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/b8/b01371c119924b3beca1fe3f047b1bc2cdc66b3d37f0f3acc9d10c567a43/grpcio_tools-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b46570a68378539ee2b75a5a43202561f8d753c832798b1047099e3c551cf5d6", size = 2909568, upload-time = "2026-03-30T08:51:04.159Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/7c/1108f7bdb58475a7e701ec89b55eb494538b6e76acd211ba0d4cc5fd28e8/grpcio_tools-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51caf99c28999e7e0f97e9cea190c1405b7681a57bb2e0631205accd92b43fa4", size = 2660938, upload-time = "2026-03-30T08:51:06.126Z" },
-    { url = "https://files.pythonhosted.org/packages/67/59/d1c0063d4cd3b85363c7044ff3e5159d6d5df96e2692a9a5312d9c8cb290/grpcio_tools-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cdaa1c9aa8d3a87891a96700cadd29beec214711d6522818d207277f6452567c", size = 3113814, upload-time = "2026-03-30T08:51:08.834Z" },
-    { url = "https://files.pythonhosted.org/packages/76/21/18d34a4efe524c903cf66b0cfa5260d81f277b6ae668b647edf795df9ce5/grpcio_tools-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3399b5fd7b59bcffd59c6b9975a969d9f37a3c87f3e3d63c3a09c147907acb0d", size = 3662793, upload-time = "2026-03-30T08:51:11.094Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/40/cf2d9295a6bd593244ea703858f8fc2efd315046ca3ef7c6f9ebc5b810fa/grpcio_tools-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9c6abc08d3485b2aac99bb58afcd31dc6cd4316ce36cf263ff09cb6df15f287f", size = 3329149, upload-time = "2026-03-30T08:51:13.066Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/1d/fc34b32167966df20d69429b71dfca83c48434b047a5ac4fd6cd91ca4eed/grpcio_tools-1.80.0-cp312-cp312-win32.whl", hash = "sha256:18c51e07652ac7386fcdbd11866f8d55a795de073337c12447b5805575339f74", size = 997519, upload-time = "2026-03-30T08:51:14.87Z" },
-    { url = "https://files.pythonhosted.org/packages/91/98/6d6563cdf51085b75f8ec24605c6f2ce84197571878ca8ab4af949c6be2d/grpcio_tools-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac6fdd42d5bb18f0d903a067e2825be172deff70cf197164b6f65676cb506c9b", size = 1162407, upload-time = "2026-03-30T08:51:16.793Z" },
-    { url = "https://files.pythonhosted.org/packages/44/d9/f7887a4805939e9a85d03744b66fc02575dc1df3c3e8b4d9ec000ee7a33d/grpcio_tools-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e7046837859bbfd10b01786056145480155c16b222c9e209215b68d3be13060e", size = 2550319, upload-time = "2026-03-30T08:51:19.117Z" },
-    { url = "https://files.pythonhosted.org/packages/57/5a/c8a05b32bd7203f1b9f4c0151090a2d6179d6c97692d32f2066dc29c67a6/grpcio_tools-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:a447f28958a8fe84ff0d9d3d9473868feb27ee4a9c9c805e66f5b670121cec59", size = 5709681, upload-time = "2026-03-30T08:51:21.991Z" },
-    { url = "https://files.pythonhosted.org/packages/82/6b/794350ed645c12c310008f97068f6a6fd927150b0d0d08aad1d909e880b1/grpcio_tools-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:75f00450e08fe648ad8a1eeb25bc52219679d54cdd02f04dfdddc747309d83f6", size = 2596820, upload-time = "2026-03-30T08:51:24.323Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/b2/b39e7b79f7c878135e0784a53cd7260ee77260c8c7f2c9e46bca8e05d017/grpcio_tools-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3db830eaff1f2c2797328f2fa86c9dcdbd7d81af573a68db81e27afa2182a611", size = 2909193, upload-time = "2026-03-30T08:51:27.025Z" },
-    { url = "https://files.pythonhosted.org/packages/10/f3/abe089b058f87f9910c9a458409505cbeb0b3e1c2d993a79721d02ee6a32/grpcio_tools-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7982b5fe42f012686b667dda12916884de95c4b1c65ff64371fb7232a1474b23", size = 2660197, upload-time = "2026-03-30T08:51:29.392Z" },
-    { url = "https://files.pythonhosted.org/packages/09/c3/3f7806ad8b731d8a89fe3c6ed496473abd1ef4c9c42c9e9a8836ce96e377/grpcio_tools-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6451b3f4eb52d12c7f32d04bf8e0185f80521f3f088ad04b8d222b3a4819c71e", size = 3113144, upload-time = "2026-03-30T08:51:31.671Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/f5/415ef205e0b7e75d2a2005df6120145c4f02fda28d7b3715b55d924fe1a4/grpcio_tools-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:258bc30654a9a2236be4ca8e2ad443e2ac6db7c8cc20454d34cce60265922726", size = 3661897, upload-time = "2026-03-30T08:51:34.849Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/d3/2ad54764c2a9547080dd8518f4a4dc7899c7e6e747a1b1de542ce6a12066/grpcio_tools-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:865a2b8e6334c838976ab02a322cbd55c863d2eaf3c1e1a0255883c63996772a", size = 3328786, upload-time = "2026-03-30T08:51:37.265Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/63/23ab7db01f9630ab4f3742a2fc9fbff38b0cfc30c976114f913950664a75/grpcio_tools-1.80.0-cp313-cp313-win32.whl", hash = "sha256:f760ac1722f33e774814c37b6aa0444143f612e85088ead7447a0e9cd306a1f1", size = 997087, upload-time = "2026-03-30T08:51:39.137Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/af/b1c1c4423fb49cb7c8e9d2c02196b038c44160b7028b425466743c6c81fa/grpcio_tools-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:7843b9ac6ff8ca508424d0dd968bd9a1a4559967e4a290f26be5bd6f04af2234", size = 1162167, upload-time = "2026-03-30T08:51:41.498Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/44/7beeee2348f9f412804f5bf80b7d13b81d522bf926a338ae3da46b2213b7/grpcio_tools-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:12f950470449dbeec78317dbc090add7a00eb6ca812af7b0538ab7441e0a42c3", size = 2550303, upload-time = "2026-03-30T08:51:44.373Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/aa/f77dd85409a1855f8c6319ffc69d81e8c3ffe122ee3a7136653e1991d8b6/grpcio_tools-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d3f9a376a29c9adf62bb56f7ff5bc81eb4abeaf53d1e7dde5015564832901a51", size = 5709778, upload-time = "2026-03-30T08:51:47.112Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/7c/ab7af4883ebdfdc228b853de89fed409703955e8d47285b321a5794856bd/grpcio_tools-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1ba1ffbf2cff71533615e2c5a138ed5569611eec9ae7f9c67b8898e127b54ac0", size = 2597928, upload-time = "2026-03-30T08:51:49.494Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e8/4381a963d472e3ab6690ba067ed2b1f1abf8518b10f402678bd2dcb79a54/grpcio_tools-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:13f60f8d9397c514c6745a967d22b5c8c698347e88deebca1ff2e1b94555e450", size = 2909333, upload-time = "2026-03-30T08:51:52.124Z" },
-    { url = "https://files.pythonhosted.org/packages/94/cb/356b5fdf79dd99455b425fb16302fe60995554ceb721afbf3cf770a19208/grpcio_tools-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:88d77bad5dd3cd5e6f952c4ecdd0ee33e0c02ecfc2e4b0cbee3391ac19e0a431", size = 2660217, upload-time = "2026-03-30T08:51:55.066Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/d7/1752018cc2c36b2c5612051379e2e5f59f2dbe612de23e817d2f066a9487/grpcio_tools-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:017945c3e98a4ed1c4e21399781b4137fc08dfc1f802c8ace2e64ef52d32b142", size = 3113896, upload-time = "2026-03-30T08:51:57.3Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/17/695bbe454f70df35c03e22b48c5314683b913d3e6ed35ec90d065418c1ab/grpcio_tools-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a33e265d4db803495007a6c623eafb0f6b9bb123ff4a0af89e44567dad809b88", size = 3661950, upload-time = "2026-03-30T08:51:59.867Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/d0/533d87629ec823c02c9169ee20228f734c264b209dcdf55268b5a14cde0a/grpcio_tools-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6c129da370c5f85f569be2e545317dda786a60dd51d7deea29b03b0c05f6aac3", size = 3328755, upload-time = "2026-03-30T08:52:02.942Z" },
-    { url = "https://files.pythonhosted.org/packages/08/a1/504d7838770c73a9761e8a8ff4869dba1146b44f297ff0ac6641481942d3/grpcio_tools-1.80.0-cp314-cp314-win32.whl", hash = "sha256:25742de5958ae4325249a37e724e7c0e5120f8e302a24a977ebd1737b48a5e97", size = 1019620, upload-time = "2026-03-30T08:52:05.342Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/75/8b7cd281c5cdfb4ca2c308f7e9b2799bab2be6e7a9e9212ea5a82e2aecd4/grpcio_tools-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:bbf8eeef78fda1966f732f79c1c802fadd5cfd203d845d2af4d314d18569069c", size = 1194210, upload-time = "2026-03-30T08:52:08.105Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/e1/1fcf884902ae7255d8da224cfa638ea88a46d50f62a33d06d35c8960b029/grpcio_tools-1.81.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:9b6ba8a72cfda576508701a7c0bbeebe6f6f9843320d4f12e74efd19ddccd965", size = 2586261, upload-time = "2026-06-11T12:49:21.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/d7/1815110b2d40ec99dbb0a7e6d7eafd591cd1f1e9bf9d3858cd9cf3ffacbd/grpcio_tools-1.81.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:ac47a9ea1224df8b653072614e6f0207e9fbfe63fdabaa5918a60ca5fc931b88", size = 5817509, upload-time = "2026-06-11T12:49:25.958Z" },
+    { url = "https://files.pythonhosted.org/packages/23/e8/af99579842b5a555312fa782f32ce0f99bd35b2b7a1243294b2755468857/grpcio_tools-1.81.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eac4bb645ceff0c147cc720a40ae68f97427eaafb4968e866dd8fcc20d3d4831", size = 2634112, upload-time = "2026-06-11T12:49:27.937Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cd/235ad56ac728c49c17e9218c4daccd5831e6ec7af94236bec0cc66c71c68/grpcio_tools-1.81.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:cc410b621dd85193766c12dca2e238696199a27a65d2b31b6f0a4c6c0043ff26", size = 2957950, upload-time = "2026-06-11T12:49:29.619Z" },
+    { url = "https://files.pythonhosted.org/packages/77/3e/9103e8b4610597bf89db49eb112091c91bf5d63ddef2a951e11a4be05f2b/grpcio_tools-1.81.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b62d254c214faa3773eac709376ae25cf7abff1a76ba5fc4dbcd7b14fc4e4ae6", size = 2697765, upload-time = "2026-06-11T12:49:31.702Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/86/beb2a43fbb93570a2305696083f6736566301d957869f463308ec6839f95/grpcio_tools-1.81.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bd0b68dc76b10b3384b9b6e9f59202b83dcaafd8098eb644759a69316686acf8", size = 3147588, upload-time = "2026-06-11T12:49:33.748Z" },
+    { url = "https://files.pythonhosted.org/packages/af/4d/b0182d9948631cd837a372b6625cf59d6e335d4aab0f425d4b7306619074/grpcio_tools-1.81.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a28d231455ab6e3558299f7d831a73c8be8ee6b7ec614ecf39eb50c0ed15767f", size = 3708798, upload-time = "2026-06-11T12:49:35.979Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9b/f452a189d399051d85cf82fe2f27a070efaa52512a2c5e3ae6ef1ae99a1f/grpcio_tools-1.81.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:82740248eb6f3b6a38988cb5e64adb7303af9ea5cb4197c8ed08c1fabc767440", size = 3366969, upload-time = "2026-06-11T12:49:37.911Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/48/0075cb4f6ae7db280f461de2dbba700b22ae62e351ae13e6e461cd6804de/grpcio_tools-1.81.1-cp310-cp310-win32.whl", hash = "sha256:801d9d8ab5cddf8f8e064225292f0713427011252a07828a6b54e2ed64d534de", size = 1008713, upload-time = "2026-06-11T12:49:39.791Z" },
+    { url = "https://files.pythonhosted.org/packages/17/bd/7692bc698259e5645b68720e77e7b176d376f6ae0c9db8b5b750a02f1958/grpcio_tools-1.81.1-cp310-cp310-win_amd64.whl", hash = "sha256:3c8611d6e4e859ac5373422ef27c4b7540cf98c9991c9abc6722613ef72b13aa", size = 1174752, upload-time = "2026-06-11T12:49:41.43Z" },
+    { url = "https://files.pythonhosted.org/packages/18/76/14ff87090199a36f914388299a1148d0734a20cea1b0ca8480bae1f373f1/grpcio_tools-1.81.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:8161f398f957a376cae7385ea7c8684f439d460ef702b528912da3bcb31fc515", size = 2586251, upload-time = "2026-06-11T12:49:43.514Z" },
+    { url = "https://files.pythonhosted.org/packages/87/a8/d5aa99de9d8b2dd2a8192c1779796eda8b0d0f1dd915422e0a8a61b80391/grpcio_tools-1.81.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:53ef76cc3b0493ff734a5e8c39d5b519e1822236fcccdfe7677c5e1efd767761", size = 5818063, upload-time = "2026-06-11T12:49:45.975Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/cb/2e9a6dbc6a514dd3cd264fb3bf9217937453a4d45dbc3ca6ca4ee34ba1a7/grpcio_tools-1.81.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:690e6dcaa8b8a7886ce206ba344e2127211597e1a1ddab73df9f3d80c8f6707e", size = 2634061, upload-time = "2026-06-11T12:49:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/2b/2ccd1a929e6c8ad84a0aa8d66ad9f615b4a8e79d9927373d86aa36b4ba2e/grpcio_tools-1.81.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ad7a997c07bd345e84842e60561e7e2cc090ce6c4e1d2f0407e31b85b40fc49a", size = 2958029, upload-time = "2026-06-11T12:49:50.466Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/67/2da8cd312edc348f44f26f82096b25cdb7d2905cd786acc6bf777b169502/grpcio_tools-1.81.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b6bd163ece4535726e5292b845ed80ae9b2cae73ba091c7d6c66033c430e3857", size = 2698031, upload-time = "2026-06-11T12:49:52.292Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/ba/ad1680fbdf9317c4f1e54c37c96d1f422370df66ac9adbd175c7cb3531d7/grpcio_tools-1.81.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2baa7e735f35b2a648144c03348a126097b13e101d3c242d5edb6ac91437ccbe", size = 3147541, upload-time = "2026-06-11T12:49:54.43Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c1/57cd08eef293d713cb8935295e4f08d8f0013480b2ba3aad1af0271eb7ba/grpcio_tools-1.81.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1d602b410b2b2addc434cace9ce4fe2035974a3078228f98ffa049a5c90acc2f", size = 3708524, upload-time = "2026-06-11T12:49:56.544Z" },
+    { url = "https://files.pythonhosted.org/packages/52/31/01ea8ca9c82fe2c79b5b594c3ae427d56699bc106b2d91caca129add8b10/grpcio_tools-1.81.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f8cb64f87c45ccca8234fa47e6b21f09e43801ff11b556deecb461b3b3e9f292", size = 3367022, upload-time = "2026-06-11T12:49:59.608Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/35/8140cd175602df3d17215cfb28a7ea55b7a67e2b872be76e1ee4af5c4df9/grpcio_tools-1.81.1-cp311-cp311-win32.whl", hash = "sha256:87b25ca0e27373a4a32a629a4ba976f5764b9887dd50d6fe017d38009a0363e8", size = 1008980, upload-time = "2026-06-11T12:50:01.422Z" },
+    { url = "https://files.pythonhosted.org/packages/be/86/1bd29ab3c52457702b96536f1f208ab27695322d855f95c9666dfb713019/grpcio_tools-1.81.1-cp311-cp311-win_amd64.whl", hash = "sha256:204de03b539a4b08772c6553b92bcc112cbc965e0ac22f909f6d133b8ac33a8c", size = 1174840, upload-time = "2026-06-11T12:50:03.408Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8a/824a9ca20bcdce8a568bb8c9f98bfeb7fad62129235e6d2ae7576fd1250a/grpcio_tools-1.81.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:353b1fafcc739c31ed42271052709595b340d34f27c459beeb78a32938305bb5", size = 2585927, upload-time = "2026-06-11T12:50:05.671Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/35/e5f9f671378b1b89a896150d3e4fa2c6ec61a5e1e9e5107ce4c140ccc931/grpcio_tools-1.81.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:768f584c2423cbeb6cb6867817a39365b987ff16b8259a3adbc6546b9e303a4e", size = 5815665, upload-time = "2026-06-11T12:50:08.178Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/02/631b628e4072e988c669bd8f1b2406ef3c9a4cfcb2625bbf2a308a07b71d/grpcio_tools-1.81.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1680b35a84f4694401819ac4acac42dda6dbc7bb8fc74112fd1a60425a07adf4", size = 2635518, upload-time = "2026-06-11T12:50:10.391Z" },
+    { url = "https://files.pythonhosted.org/packages/de/7c/2e3537e3ea3d1c0ddd6766cf6a7c62b487d89fb005713df2781d5f21483a/grpcio_tools-1.81.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f64e665c8ec639278ecf009beb92cbdcc5994f617c1af3d58036e1f70b1423ec", size = 2958252, upload-time = "2026-06-11T12:50:12.677Z" },
+    { url = "https://files.pythonhosted.org/packages/35/68/14013cb2942bdac354746b643b4c37dd91906da8dce00f41c616e88bf33d/grpcio_tools-1.81.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f1ae82ad199f43448995715445cc623fb20d3882382e4be61f0da8ccb3f0e", size = 2698439, upload-time = "2026-06-11T12:50:15.017Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/45/000c14c0338a7ad36054b9f17ea41842deb7841c05c067dd36cc831bc0f4/grpcio_tools-1.81.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b7b6d1e986d5923751bfe2b5cca9c4cb3d5653446e4fa4aacd438033e2dc360a", size = 3152160, upload-time = "2026-06-11T12:50:17.3Z" },
+    { url = "https://files.pythonhosted.org/packages/41/97/881930ca3967d2c8a95649bea8ebc991a7cf2331bc96679fd3600450dccc/grpcio_tools-1.81.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7f208c207aca639dcb34648d3826c38d7cf3485118fb2065117e9fc4827406b3", size = 3710468, upload-time = "2026-06-11T12:50:19.479Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b5/67baeba7366162652cdc1dbd962289accde07241bc8f42f6f02b305efcc6/grpcio_tools-1.81.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:724ecb69af63d2f6d4ccea3e6fa0ca110ed9c5824d48c2f887c631bbb03c1c3c", size = 3370797, upload-time = "2026-06-11T12:50:21.501Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/5d/34f2dce2125ccb107e32b57f5a9c1257edcc0793b0d2fef1e8b13a6bac3c/grpcio_tools-1.81.1-cp312-cp312-win32.whl", hash = "sha256:895a6782cec86beac71ccebb4b9848259c6f04a3028b8e42fa8d40cfe5146593", size = 1008453, upload-time = "2026-06-11T12:50:23.358Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/be/09da8256ec8d2a5ce8a1acc51cbbc4ca52a462d78ed3412778440a56502e/grpcio_tools-1.81.1-cp312-cp312-win_amd64.whl", hash = "sha256:0265fd1386b7458302f79542558345880d484f8fa92ae196c0c0268242c5f23a", size = 1174857, upload-time = "2026-06-11T12:50:25.685Z" },
+    { url = "https://files.pythonhosted.org/packages/76/90/5faa8b26e03495e5117f93bef8293cbada4af136362745dad7d1813ef0b0/grpcio_tools-1.81.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:3d604b4fd114b79ebb9f865bf3e04fd3ae93c704e1fad96f7fd03b0865c263b7", size = 2586071, upload-time = "2026-06-11T12:50:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/9a/85dc589fa6ae2439451eaa81a1578de31e29c676980d38bef7549b8a1f45/grpcio_tools-1.81.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:3389e705460efa3f3758141ba5520e6743b131c9576197c944fb9cbe49048126", size = 5813299, upload-time = "2026-06-11T12:50:31.295Z" },
+    { url = "https://files.pythonhosted.org/packages/77/fd/c53994e58a837e6eefe48f53eb3492afc04f2b8af255df4adb37d14378f8/grpcio_tools-1.81.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8a17d8ceeb6a855fadf39f5171c80a382d97c4db98d5943eca553497fdebf84b", size = 2634668, upload-time = "2026-06-11T12:50:33.938Z" },
+    { url = "https://files.pythonhosted.org/packages/34/32/de988e86688686a2117e7ce6ce9eff4f638c929bb55b0afe60d6fbd2e45c/grpcio_tools-1.81.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:43baf71dc60fd653062da2e95e95c73b35dd130be8f9fa3d544c3af3f808a290", size = 2957930, upload-time = "2026-06-11T12:50:36.726Z" },
+    { url = "https://files.pythonhosted.org/packages/72/97/3f18a0ea32b5f809d21961dbd0bc382b589a4c3d501e3d67c345d5456ed3/grpcio_tools-1.81.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136e90906af0df51ad929713244ba812d0dbb1844b4f467d5d86bdb054698f90", size = 2697760, upload-time = "2026-06-11T12:50:39.108Z" },
+    { url = "https://files.pythonhosted.org/packages/49/c0/dbf5cbc877290ff7504a59959a8af4fdcfdaa1e84237948405ccf1aa82a6/grpcio_tools-1.81.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd6c3bf3ea6a61eb58c54368d72ada591f2a270f3a31a32e8536e773337e76d9", size = 3151456, upload-time = "2026-06-11T12:50:41.983Z" },
+    { url = "https://files.pythonhosted.org/packages/de/ea/16fe2dc83140a59e5c0a0b9dc2693dd36bfaa6bd835724b4ec66a68eab7b/grpcio_tools-1.81.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c306c307f8f74cddc4056fdbb6f1da55de087a21120efbd02bd915daa5a52fd", size = 3710469, upload-time = "2026-06-11T12:50:44.596Z" },
+    { url = "https://files.pythonhosted.org/packages/22/7d/df987d7d81e7ad2f7516d9e9d56ff29c54dbc6d8587e425688dca9a28e49/grpcio_tools-1.81.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bdbdc927be2e0ea13c32564a72ee31d712a716fb6f8c0d53d37a77d8277c272c", size = 3370488, upload-time = "2026-06-11T12:50:47.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/c5/5a63444d694ea47bf670138208f71830cc1759c402c8818092b28ab2dc5f/grpcio_tools-1.81.1-cp313-cp313-win32.whl", hash = "sha256:9d383724bcd67244b6def9e9164c640ee9380c0b7534ee7545a6fb0022a59afe", size = 1008229, upload-time = "2026-06-11T12:50:49.527Z" },
+    { url = "https://files.pythonhosted.org/packages/00/75/3945e26d5c94ae6ed9be5caef73d4d66c47dc8cfdd7b4995efaf942754e0/grpcio_tools-1.81.1-cp313-cp313-win_amd64.whl", hash = "sha256:f3eb15849979ca7bb864ce81a74d68b0f225a7f111ed3fe212bfc08cf9812b10", size = 1174523, upload-time = "2026-06-11T12:50:51.755Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/08/e581ad42ae517a61172285047e4d710e2ac75f2f1915f7c91f284254e6d5/grpcio_tools-1.81.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:7d168ea26390717d0462c0d0408331dc98a60fc7f7e6118afac9b73f5a66d87c", size = 2585944, upload-time = "2026-06-11T12:50:54.528Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c8/200d90ebad685af7eea5ff7e0360c504dd01ec053fe0f1f9c4abe3ea2d5a/grpcio_tools-1.81.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:43c528655b226375013036692d8db4cd59060c1f41dd62c77f4d17b69f6ce828", size = 5813492, upload-time = "2026-06-11T12:50:57.291Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c0/60da2a1af37aa8eb47308cec24d9f7709a8976fdec3a53fd35b56b358326/grpcio_tools-1.81.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a9c6fcc68c9d5a208967bfe4fd3224d3c3be9a950c3e827e8f4b17e15c2dc555", size = 2634991, upload-time = "2026-06-11T12:50:59.767Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/7f/dede28b579ae9bf9079ba1aa913e8088d1dc0cdbe21c85caa22f0790cad2/grpcio_tools-1.81.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:a987c85dcbe1b32066d7acd46266d1a428aecbd629331bf5b853e74c835bf876", size = 2957913, upload-time = "2026-06-11T12:51:02.31Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/38/4de2118adb58ec7ffba65ec623b5836db769665c192517cbf187db3f6145/grpcio_tools-1.81.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a882382507bb5ec6d7edc9648053dfd3bc8f9285cde56a6fa9b9a83b4bd07f1c", size = 2697709, upload-time = "2026-06-11T12:51:05.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e1/762ced51059e4f694fd337ecae491581d42a4e61dcb0415d8c5c60e6ddcb/grpcio_tools-1.81.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7746e508d4239a02f7e93638be5bc0ebb0120ddb796f7506aaae9d47a4599d97", size = 3151884, upload-time = "2026-06-11T12:51:07.593Z" },
+    { url = "https://files.pythonhosted.org/packages/19/d8/9823090dc801e7229944874e7429c3b98e741ac778d8dc373f60240e1c43/grpcio_tools-1.81.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fc3d2a41a7a4467fa03b391394fffada9291fe8feebc8679b526f6bc36942b25", size = 3710404, upload-time = "2026-06-11T12:51:10.172Z" },
+    { url = "https://files.pythonhosted.org/packages/64/4e/4eae98d02148cb6f9f452f09942afba407afa6851e6c1fddc5ae9ec0b4ed/grpcio_tools-1.81.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:21bb3ba90e6d8df1ff663d4ee39a4e5b25a64e8ed4902476ca9ded0954d3917a", size = 3370525, upload-time = "2026-06-11T12:51:12.678Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/3e/2206e597a128da6a03a6106d2eaf2c3e72c7d80843d4be933e3a3d10d02a/grpcio_tools-1.81.1-cp314-cp314-win32.whl", hash = "sha256:3dca56016d90a710c4d9861bae793dc089c1430a90c79ce672e948ddb65fa539", size = 1030582, upload-time = "2026-06-11T12:51:14.906Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/f2/bbeef86c687225b7bbc7c0acdfbd25c8bcaa3f5b1c941db053e5c3d9e859/grpcio_tools-1.81.1-cp314-cp314-win_amd64.whl", hash = "sha256:cb08172b7b629e75cb33866928d319a3196540a725eaab628ba721007140f1af", size = 1207490, upload-time = "2026-06-11T12:51:17.598Z" },
 ]
 
 [[package]]
@@ -1043,9 +1060,10 @@ wheels = [
 
 [[package]]
 name = "langgraph-api"
-version = "0.10.0"
+version = "0.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "anyio" },
     { name = "cloudpickle" },
     { name = "cryptography" },
     { name = "grpcio" },
@@ -1063,8 +1081,10 @@ dependencies = [
     { name = "langsmith", extra = ["otel"] },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-exporter-otlp-proto-http" },
+    { name = "opentelemetry-exporter-prometheus" },
     { name = "opentelemetry-sdk" },
     { name = "orjson" },
+    { name = "prometheus-client" },
     { name = "protobuf" },
     { name = "pyjwt" },
     { name = "sse-starlette" },
@@ -1079,9 +1099,9 @@ dependencies = [
     { name = "websockets" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7d/17/a23ecdad3de7e48209bc8d534312ba83e332126ec60da9e6487461b02597/langgraph_api-0.10.0.tar.gz", hash = "sha256:f594a160857e2cd7fb2352bba585111177a4a394625ad0cf5898814754fb7bc1", size = 713903, upload-time = "2026-06-11T14:36:50.469Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/c2/3a5baab0dd010dffdbf92fecd34f0fe25d4fac42281469ed8b494e4b3511/langgraph_api-0.17.1.tar.gz", hash = "sha256:08bf7df9cc2bd7e45fbf2f1cb97267264f149794032010e55dafb50d64cbded7", size = 886040, upload-time = "2026-11-03T21:27:09.883Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/38/6b0cdcaaed9b3105102b452a5a70fb08894a9511458cf00c061c4725347c/langgraph_api-0.10.0-py3-none-any.whl", hash = "sha256:f4b545bf1936c4e90bed1cc07a6852b1be37e1667007ab4736d800cc18e9f9b3", size = 577475, upload-time = "2026-06-11T14:36:48.838Z" },
+    { url = "https://files.pythonhosted.org/packages/89/84/a61803f1a2dd895718abbe4dbb076bb19ff04238c36d217697f5a485188e/langgraph_api-0.17.1-py3-none-any.whl", hash = "sha256:e070f5675713adf3322ba993992e618f5ec587ec0aec80441c563dfc404d14f2", size = 663034, upload-time = "2026-11-03T21:27:07.552Z" },
 ]
 
 [[package]]
@@ -1193,7 +1213,7 @@ wheels = [
 
 [[package]]
 name = "langgraph-runtime-inmem"
-version = "0.30.0"
+version = "0.37.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "blockbuster" },
@@ -1204,9 +1224,9 @@ dependencies = [
     { name = "starlette" },
     { name = "structlog" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/98/19/5d330e22e3ee2569742d3577b4ddfbb6b8e383f2edd9724b4a4b73735717/langgraph_runtime_inmem-0.30.0.tar.gz", hash = "sha256:31954e1de6cd43c284b425243d4faeae818f68b3daca4dbe4313e651b6f5e11d", size = 129940, upload-time = "2026-06-11T14:22:46.985Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/03/96d55a65eedf319da923a93e99d7a879364e0cd5b1159a15b7a58f2eaf9b/langgraph_runtime_inmem-0.37.1.tar.gz", hash = "sha256:c52a5105d0559994b3c9218a67eee3e746b65eb7b40d731ebb7d87247683395f", size = 142119, upload-time = "2026-11-03T21:20:31.19Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/df/cfb15c70fa4dcab9ea48f8fda9f4ed87d1767eea6e4d2901dc704da297ba/langgraph_runtime_inmem-0.30.0-py3-none-any.whl", hash = "sha256:08a36b83b5e32fe6e30cb25062a1e671a42e2a0206e4043cc95f41198dcbbb12", size = 51762, upload-time = "2026-06-11T14:22:46.012Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bc/df823ed5cdf54cac16a85fb7f0bc4dde9a77a736b0ce1d38e9da97e620af/langgraph_runtime_inmem-0.37.1-py3-none-any.whl", hash = "sha256:b6504d50970e962947bd43a1dd2666b4f1f069d8fa08da6b7364b3f5a23b35a9", size = 62099, upload-time = "2026-11-03T21:20:29.734Z" },
 ]
 
 [[package]]
@@ -1416,6 +1436,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
+[[package]]
+name = "opentelemetry-exporter-prometheus"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-sdk" },
+    { name = "prometheus-client" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ed/58/e552853748c3a1478d3f0db31bb4e3bef2e45385f64d658148693183410e/opentelemetry_exporter_prometheus-0.66b1.tar.gz", hash = "sha256:1c702a0cc7a1b8c5e1f3f246aeb4273dbd707179af30dbb66182a75e16a06ed8", size = 16987, upload-time = "2026-10-06T17:33:06.358Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/8a/5e7262d970586a8d69dd159bebc68fbee7457088883b179599a562881a6f/opentelemetry_exporter_prometheus-0.66b1-py3-none-any.whl", hash = "sha256:a938e6af7295d5bacf82da9ca845cab9a9cb1c5f565abe39f54ef8bf511c05d9", size = 13222, upload-time = "2026-10-06T17:32:44.94Z" },
+]
+
 [[package]]
 name = "opentelemetry-proto"
 version = "1.45.1"
@@ -1640,6 +1674,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/54/20/4d324d65cc6d9205fabedc306948156824eb9f0ee1633355a8f7ec5c66bf/pluggy-1.6.0-py3-none-any.whl", hash = "sha256:e920276dd6813095e9377c0bc5566d94c932c33b27a3e3945d8389c374dd4746", size = 20538, upload-time = "2025-05-15T12:30:06.134Z" },
 ]
 
+[[package]]
+name = "prometheus-client"
+version = "0.26.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/52/73/f1334c29c2af4cd9dba6c7817e61b611bd0215e2eb5565c6064a4de18802/prometheus_client-0.26.0.tar.gz", hash = "sha256:04a91bcf94e2cf74a44a1a874d651a2e853ed354b6e822f3b7487751465d5c2b", size = 92910, upload-time = "2026-07-24T19:36:41.893Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/eb/a3/b69efbf4143b5b9859b977770bbbabcc2796b702fa69dc40271e45cd5a56/prometheus_client-0.26.0-py3-none-any.whl", hash = "sha256:fa93d06737aa02bacd05794768508bb97d2fbee28cb3bca04eaae92f0ca953d6", size = 64494, upload-time = "2026-07-24T19:36:40.854Z" },
+]
+
 [[package]]
 name = "protobuf"
 version = "6.33.6"
@@ -1905,7 +1948,8 @@ name = "python-discovery"
 version = "1.6.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "filelock" },
+    { name = "filelock", version = "4.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "filelock", version = "4.2.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/0c/57/250bd238b966cece44328235eb85290045d059265fdaf7527a3a958123db/python_discovery-1.6.1.tar.gz", hash = "sha256:cf87d3627dfb4412437fdd5b13eae402607722998d21567993aedbc59b23c15e", size = 84338, upload-time = "2026-09-18T01:31:53.971Z" }
 wheels = [
@@ -2328,31 +2372,62 @@ wheels = [
 
 [[package]]
 name = "uuid-utils"
-version = "0.14.1"
+version = "0.19.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7b/d1/38a573f0c631c062cf42fa1f5d021d4dd3c31fb23e4376e4b56b0c9fbbed/uuid_utils-0.14.1.tar.gz", hash = "sha256:9bfc95f64af80ccf129c604fb6b8ca66c6f256451e32bc4570f760e4309c9b69", size = 22195, upload-time = "2026-02-20T22:50:38.833Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/f1/0f/cd9b3e495e514441e9af3a42c5c63436aee620f61412cafcce67e259228b/uuid_utils-0.19.0.tar.gz", hash = "sha256:4b2996bb9d12da9b62f6f4c64a066b26926fa75dbe47b4f8e309e24e187abf1d", size = 43343, upload-time = "2026-10-26T10:55:23.821Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/b7/add4363039a34506a58457d96d4aa2126061df3a143eb4d042aedd6a2e76/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:93a3b5dc798a54a1feb693f2d1cb4cf08258c32ff05ae4929b5f0a2ca624a4f0", size = 604679, upload-time = "2026-02-20T22:50:27.469Z" },
-    { url = "https://files.pythonhosted.org/packages/dd/84/d1d0bef50d9e66d31b2019997c741b42274d53dde2e001b7a83e9511c339/uuid_utils-0.14.1-cp39-abi3-macosx_10_12_x86_64.whl", hash = "sha256:ccd65a4b8e83af23eae5e56d88034b2fe7264f465d3e830845f10d1591b81741", size = 309346, upload-time = "2026-02-20T22:50:31.857Z" },
-    { url = "https://files.pythonhosted.org/packages/ef/ed/b6d6fd52a6636d7c3eddf97d68da50910bf17cd5ac221992506fb56cf12e/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b56b0cacd81583834820588378e432b0696186683b813058b707aedc1e16c4b1", size = 344714, upload-time = "2026-02-20T22:50:42.642Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/a7/a19a1719fb626fe0b31882db36056d44fe904dc0cf15b06fdf56b2679cf7/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:bb3cf14de789097320a3c56bfdfdd51b1225d11d67298afbedee7e84e3837c96", size = 350914, upload-time = "2026-02-20T22:50:36.487Z" },
-    { url = "https://files.pythonhosted.org/packages/1d/fc/f6690e667fdc3bb1a73f57951f97497771c56fe23e3d302d7404be394d4f/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:60e0854a90d67f4b0cc6e54773deb8be618f4c9bad98d3326f081423b5d14fae", size = 482609, upload-time = "2026-02-20T22:50:37.511Z" },
-    { url = "https://files.pythonhosted.org/packages/54/6e/dcd3fa031320921a12ec7b4672dea3bd1dd90ddffa363a91831ba834d559/uuid_utils-0.14.1-cp39-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:ce6743ba194de3910b5feb1a62590cd2587e33a73ab6af8a01b642ceb5055862", size = 345699, upload-time = "2026-02-20T22:50:46.87Z" },
-    { url = "https://files.pythonhosted.org/packages/04/28/e5220204b58b44ac0047226a9d016a113fde039280cc8732d9e6da43b39f/uuid_utils-0.14.1-cp39-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:043fb58fde6cf1620a6c066382f04f87a8e74feb0f95a585e4ed46f5d44af57b", size = 372205, upload-time = "2026-02-20T22:50:28.438Z" },
-    { url = "https://files.pythonhosted.org/packages/c7/d9/3d2eb98af94b8dfffc82b6a33b4dfc87b0a5de2c68a28f6dde0db1f8681b/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:c915d53f22945e55fe0d3d3b0b87fd965a57f5fd15666fd92d6593a73b1dd297", size = 521836, upload-time = "2026-02-20T22:50:23.057Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/15/0eb106cc6fe182f7577bc0ab6e2f0a40be247f35c5e297dbf7bbc460bd02/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:0972488e3f9b449e83f006ead5a0e0a33ad4a13e4462e865b7c286ab7d7566a3", size = 625260, upload-time = "2026-02-20T22:50:25.949Z" },
-    { url = "https://files.pythonhosted.org/packages/3c/17/f539507091334b109e7496830af2f093d9fc8082411eafd3ece58af1f8ba/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_i686.whl", hash = "sha256:1c238812ae0c8ffe77d8d447a32c6dfd058ea4631246b08b5a71df586ff08531", size = 587824, upload-time = "2026-02-20T22:50:35.225Z" },
-    { url = "https://files.pythonhosted.org/packages/2e/c2/d37a7b2e41f153519367d4db01f0526e0d4b06f1a4a87f1c5dfca5d70a8b/uuid_utils-0.14.1-cp39-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:bec8f8ef627af86abf8298e7ec50926627e29b34fa907fcfbedb45aaa72bca43", size = 551407, upload-time = "2026-02-20T22:50:44.915Z" },
-    { url = "https://files.pythonhosted.org/packages/65/36/2d24b2cbe78547c6532da33fb8613debd3126eccc33a6374ab788f5e46e9/uuid_utils-0.14.1-cp39-abi3-win32.whl", hash = "sha256:b54d6aa6252d96bac1fdbc80d26ba71bad9f220b2724d692ad2f2310c22ef523", size = 183476, upload-time = "2026-02-20T22:50:32.745Z" },
-    { url = "https://files.pythonhosted.org/packages/83/92/2d7e90df8b1a69ec4cff33243ce02b7a62f926ef9e2f0eca5a026889cd73/uuid_utils-0.14.1-cp39-abi3-win_amd64.whl", hash = "sha256:fc27638c2ce267a0ce3e06828aff786f91367f093c80625ee21dad0208e0f5ba", size = 187147, upload-time = "2026-02-20T22:50:45.807Z" },
-    { url = "https://files.pythonhosted.org/packages/d9/26/529f4beee17e5248e37e0bc17a2761d34c0fa3b1e5729c88adb2065bae6e/uuid_utils-0.14.1-cp39-abi3-win_arm64.whl", hash = "sha256:b04cb49b42afbc4ff8dbc60cf054930afc479d6f4dd7f1ec3bbe5dbfdde06b7a", size = 188132, upload-time = "2026-02-20T22:50:41.718Z" },
-    { url = "https://files.pythonhosted.org/packages/91/f9/6c64bdbf71f58ccde7919e00491812556f446a5291573af92c49a5e9aaef/uuid_utils-0.14.1-pp311-pypy311_pp73-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:b197cd5424cf89fb019ca7f53641d05bfe34b1879614bed111c9c313b5574cd8", size = 591617, upload-time = "2026-02-20T22:50:24.532Z" },
-    { url = "https://files.pythonhosted.org/packages/d0/f0/758c3b0fb0c4871c7704fef26a5bc861de4f8a68e4831669883bebe07b0f/uuid_utils-0.14.1-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:12c65020ba6cb6abe1d57fcbfc2d0ea0506c67049ee031714057f5caf0f9bc9c", size = 303702, upload-time = "2026-02-20T22:50:40.687Z" },
-    { url = "https://files.pythonhosted.org/packages/85/89/d91862b544c695cd58855efe3201f83894ed82fffe34500774238ab8eba7/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0b5d2ad28063d422ccc2c28d46471d47b61a58de885d35113a8f18cb547e25bf", size = 337678, upload-time = "2026-02-20T22:50:39.768Z" },
-    { url = "https://files.pythonhosted.org/packages/ee/6b/cf342ba8a898f1de024be0243fac67c025cad530c79ea7f89c4ce718891a/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:da2234387b45fde40b0fedfee64a0ba591caeea9c48c7698ab6e2d85c7991533", size = 343711, upload-time = "2026-02-20T22:50:43.965Z" },
-    { url = "https://files.pythonhosted.org/packages/b3/20/049418d094d396dfa6606b30af925cc68a6670c3b9103b23e6990f84b589/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50fffc2827348c1e48972eed3d1c698959e63f9d030aa5dd82ba451113158a62", size = 476731, upload-time = "2026-02-20T22:50:30.589Z" },
-    { url = "https://files.pythonhosted.org/packages/77/a1/0857f64d53a90321e6a46a3d4cc394f50e1366132dcd2ae147f9326ca98b/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c1dbe718765f70f5b7f9b7f66b6a937802941b1cc56bcf642ce0274169741e01", size = 338902, upload-time = "2026-02-20T22:50:33.927Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/d0/5bf7cbf1ac138c92b9ac21066d18faf4d7e7f651047b700eb192ca4b9fdb/uuid_utils-0.14.1-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:258186964039a8e36db10810c1ece879d229b01331e09e9030bc5dcabe231bd2", size = 364700, upload-time = "2026-02-20T22:50:21.732Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/ce/78f9d79c820b8afc9b0498b0a5f5ef87ea970a19cc382127087f36cd4839/uuid_utils-0.19.0-cp310-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:84929d8c594381c6f1444afa2a25cce9ff7edac99d35e071ebc48275bae83730", size = 574701, upload-time = "2026-10-26T10:54:06.751Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/63/fe81dda73d651fb6bf8b0e21c4ea34209fc535ca109634c0d93f14ac21dc/uuid_utils-0.19.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:a416c78167b750186095a0ea950d95b8b4e157e3172fc6ccdc317b6ca2896580", size = 294226, upload-time = "2026-10-26T10:54:08.422Z" },
+    { url = "https://files.pythonhosted.org/packages/81/6c/118c7e11fb579b5631212bfbbb31542a1778936dfb7c55591aa9b52c7c99/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82573c0e5090732c0ae2e18626e06cb35fe7cfcf6fe9534d4c1638af41d25d36", size = 327869, upload-time = "2026-10-26T10:54:10.016Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/76/80e9bad735cbf92f127183ee5c44ee0d83604e56197bddcaaaed2c66f7e6/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c78d527fddf5495e80032caeca2f140731ef394298ef4cbecaaf51aa2c257e1e", size = 334737, upload-time = "2026-10-26T10:54:11.434Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/7b/c8eb8e45569e8681f20e381859248d18635d823b8aedc70de8a0bd5faca6/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c33b5c62cf82d509945c770201b1656448c2560e12931d1a8d698a683e9125d", size = 440438, upload-time = "2026-10-26T10:54:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/be/45/8238eac588b668e5c500cb187fd74a9f6d984c09f3f3f2fa4161d3c07eb7/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8060530a8fa27f11947489c79bc36e6ebb465b2d714945364dc397283309417", size = 330342, upload-time = "2026-10-26T10:54:14.309Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/45/8215129786e67842d479480a44066cac8a7086f345ac9707f629ed777cfe/uuid_utils-0.19.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:96429c78eab28ac71b2121fb47c66783bfe5d06632b5bd5200004707fdc0faad", size = 354275, upload-time = "2026-10-26T10:54:15.753Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/bc/a673bfd116eb26419dd82bffa9bc2bc1e915af02bf68ac8c09598dc678ec/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:80e0b37b3ddf60c50c51b869e1b02df61415941aa68bc903f61562fd8df04b18", size = 504446, upload-time = "2026-10-26T10:54:17.45Z" },
+    { url = "https://files.pythonhosted.org/packages/af/ff/61867210f202c603d4a5ca1c5b3c4c76e8d8724eeebd7cf1307d18b63a9a/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f629f2a4f95e46d99ee673536ab9706899696cdc6686e93314ea756d3b394ce4", size = 609016, upload-time = "2026-10-26T10:54:18.914Z" },
+    { url = "https://files.pythonhosted.org/packages/42/81/6fb8a2ee8010a6a0c5cb29f5efed2604717613cc9888f9e5c999dc36b84b/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:ec330297c09e40b82d613326b57bb381d68535e8a341fa2e501b46791cbdfeec", size = 570293, upload-time = "2026-10-26T10:54:20.328Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/2f/e1c749b65c584ebd8bc5379cf18e26c67cdff8f2bd9f8f77111a47083408/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:313de97d59dbbb09f4598cece2c799cc233d8673bb075ad7eff442cd485623c2", size = 535321, upload-time = "2026-10-26T10:54:21.735Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ba/f423f68fd784124e68ab1b1afe27ab4591ffd5363b39eccfcbaf8f3b0ff3/uuid_utils-0.19.0-cp310-abi3-pyemscripten_2025_0_wasm32.whl", hash = "sha256:5c47c7fc35e91a801996477f0d746d506a2e5b47a13accbf41dc29844786c40c", size = 103141, upload-time = "2026-10-26T10:54:23.192Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/9a/7a0a0dad166db9f4437f3d259e47ce74d552ccc50d8aa63d05b2510e3096/uuid_utils-0.19.0-cp310-abi3-pyemscripten_2026_0_wasm32.whl", hash = "sha256:23868cdc4dfa71021fec6cf43fbb83797345362ac1c866b50dbf17f479587413", size = 103069, upload-time = "2026-10-26T10:54:24.709Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/3c/c5fef96cea027de66a035b4173951fc29c2e83ed49a5d5b3fa7b632f95b5/uuid_utils-0.19.0-cp310-abi3-win32.whl", hash = "sha256:0cff166cf6348e9a705740e6575ce7bc727554a71a6add60b9ceceaaf169002a", size = 175479, upload-time = "2026-10-26T10:54:25.949Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/16/edfb8edc8a4624cfaf1387a57bf37cd53e5d7f213ebeb8dd6fbd2f6b2c64/uuid_utils-0.19.0-cp310-abi3-win_amd64.whl", hash = "sha256:b763ae8f23334ccd95d0b81fb19ee418f38f9e80ebfb521f313a9745280bc07c", size = 182891, upload-time = "2026-10-26T10:54:27.527Z" },
+    { url = "https://files.pythonhosted.org/packages/63/17/258e5dd380bc594731b2b705082360fb4cef1e5cbaab46ef307439a6f415/uuid_utils-0.19.0-cp310-abi3-win_arm64.whl", hash = "sha256:b244ea25bfe1b34e40fabf8f079d59a9f153b22bd4095842065bb0a9dfaa477b", size = 180849, upload-time = "2026-10-26T10:54:28.86Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/64/b5554f686d5395db970bc07944b9c59c26ab0e192a27d7c8b555e5fc6332/uuid_utils-0.19.0-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9adf8d69574f0018a25aed0cc194bffacc05fb91b922fdd8e794109c45ad80ed", size = 565592, upload-time = "2026-10-26T10:54:30.242Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/a3/d8d0b7bf4892c41dbbb0e81a356d20aad781cc28d3029669e167eb72d9a1/uuid_utils-0.19.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:ac37f30acc7fe01266c73f19a686d0ea1fbd22495d81205cc3b572e2fb2293a6", size = 292083, upload-time = "2026-10-26T10:54:32.053Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c1/770ccb569b4c15ee81c36bc40e74f03c5e0a2ee71ecc534d3fe7cfa5696d/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afc1dc05c83163ec58304350ee61d20f1f3285d0e8fb873e4d85a97988c284ad", size = 323275, upload-time = "2026-10-26T10:54:33.896Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/12/798e09469358bf59848534291aa62d16cc6fbd66767f469c5d8278d0bc4d/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:16e68b1a4b81301fa7ba52d500947094226d8b0c1521695746ec57ff0779ff6f", size = 328681, upload-time = "2026-10-26T10:54:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/42/16/71df642a7969381747de36d4e365e59683cdaa2c425da0530e9383e4de86/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:833edd2b38ef08a324e9f3aed4269d2ab955d4cb66417422eeb3af28a6237427", size = 434504, upload-time = "2026-10-26T10:54:36.96Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/18/35c86d901bbd6d3f088217f37a6ff01aae4ce8f8cdb3f9ddb5220887a122/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21356ba99b82c813c1945054a09ff7ebc1bf55b858b41a6ae084e6ed2c8bb9a9", size = 325810, upload-time = "2026-10-26T10:54:38.492Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/51/25427eee1031946d5abe0d8985123f6fd4a1931c8a5a8660b1c76368ca12/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2477161656105e787a5f986adb63191b61f129c9d7399b2bce406f87a1407b4d", size = 346300, upload-time = "2026-10-26T10:54:39.864Z" },
+    { url = "https://files.pythonhosted.org/packages/26/4b/edbb0ebdc948549a0250363f441883c31fef42fb4e4bb607b9a083efaeba/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ddf61d8443993d683c8d6fcd05cbb711c2655042952850fc0cf25af969e3a213", size = 501365, upload-time = "2026-10-26T10:54:41.268Z" },
+    { url = "https://files.pythonhosted.org/packages/68/e4/f5a788fae45e315d8d04d5889a0b0809543e27c8d08b9fe10b09d0766b9b/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cb9ead0aeae67ad2de3f660f2e978ece77e14ad3f2a7082b768e2c75866664a2", size = 604290, upload-time = "2026-10-26T10:54:42.686Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/90/3800a0b2083d6c156a4d686e75f26c055a48fcf315b9310ba211b7e3659c/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:4e5155902b7779ae7b692ac69e6031f41481d62fa85a530d3725c270799940a0", size = 563566, upload-time = "2026-10-26T10:54:44.068Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/37/1b58a17a041bd560a1d652afccd57ecd5d0e0c4d6280deded663b783de43/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd3bcc556e249bb70b1c7fd78e659a1ebfb5572e7ff2091d096aecbac62edb1c", size = 531143, upload-time = "2026-10-26T10:54:45.599Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ac/f6286bcfad2f321be2acd04961934a58e4a6c15ba78070a13d193cbbb9f0/uuid_utils-0.19.0-cp314-cp314t-win32.whl", hash = "sha256:9b9064d96c6fe5e43ff4486722c5c891083a7fa91ee36311286cfd833b4b5562", size = 172229, upload-time = "2026-10-26T10:54:46.925Z" },
+    { url = "https://files.pythonhosted.org/packages/87/45/0df876abf12875ef82bcd8f034c0c7adc1507dd721a5942232120b6267e8/uuid_utils-0.19.0-cp314-cp314t-win_amd64.whl", hash = "sha256:eeaf6b77ed2ec9815988e10d043d1533a1ae8c6535e7fb5479fd7e2e6ad25dff", size = 178436, upload-time = "2026-10-26T10:54:48.249Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/c9b4aaa8ee95581b444a7be681dc0ceb57a465b50b28b2f2517f5fec1c51/uuid_utils-0.19.0-cp314-cp314t-win_arm64.whl", hash = "sha256:ebb011b9010ddbd8acd4650896e87db2715f2cfc70fb194c03ebcbf4150d3844", size = 175725, upload-time = "2026-10-26T10:54:49.562Z" },
+    { url = "https://files.pythonhosted.org/packages/41/6e/3a3fdaa9689b687f105ba885e61f6b2e8336ec4d209fd51d41923ad83479/uuid_utils-0.19.0-cp315-cp315t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8c76f01a815a0ca8b698202f2f5e40098a4b3cd56305e1fc9ed3d959ac718ff0", size = 565325, upload-time = "2026-10-26T10:54:50.924Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1a/23dacf86dfe52f4606694501a6072379156025a3c6988e16f477f627249c/uuid_utils-0.19.0-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:f3828e1fc0831a9d539e702992e9fcfeb400e80f737467b8e557921cdc8ae067", size = 291930, upload-time = "2026-10-26T10:54:52.529Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f2/adf223ded569b0d75e8ac10db14be8fc253da900a63e678436bc3ff3b72a/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b25ddec2775c2f500a36029ab93af09f39d5c417786df02a464464e030152014", size = 322729, upload-time = "2026-10-26T10:54:54.01Z" },
+    { url = "https://files.pythonhosted.org/packages/88/df/0f78e7f22c778d2e48ef092a3a1c44d5b8b487b7e178e1044e7a39195b17/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1fc412a5ef2f1e6f96d132a6656af59bae2dba9fd04f8df2a2f6eb913fe6180a", size = 328838, upload-time = "2026-10-26T10:54:55.473Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/96/9a9d6f7bef37b3545203eaf643e7f4d574f4ea3a6364af8865c071847df5/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:94cbef978d789b18014c477f51c8311800803cd2a0c7e1de6d2af85377210053", size = 433992, upload-time = "2026-10-26T10:54:56.911Z" },
+    { url = "https://files.pythonhosted.org/packages/07/92/62f67dc40a036ab890ac3f55eaab610999c713654bb3d0b56d5676ce3eaa/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4b012d2a2c5516e11ded4fb70cdd730f36e2d40b45018b9a40c6605dc5c0666", size = 326138, upload-time = "2026-10-26T10:54:58.533Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b7/740525de1aa1a150eb7a80a667c997d54284f407b7f3b38ce8f90f948813/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4062c0dfd6697ce7c91a504d8ff6eb8dcaf4e790fb6adec69c4c83fd89870d4a", size = 346714, upload-time = "2026-10-26T10:55:00.01Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/1a/c9d2be770a2061da608164d022becda3fc7ddabb34ec7a1950d29ae51ca0/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:361cfd0fba0a49f1c8b6df741a35f7d948f0fae3d3914f8622ba261dc4656a5a", size = 500974, upload-time = "2026-10-26T10:55:01.392Z" },
+    { url = "https://files.pythonhosted.org/packages/36/2e/ee7522207a7f9477c58757f040f05c4eedb68f362623d4e40da4983bdf5b/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:a15c8943e02ac59992eaad1ce69793720dc711ce66188d386be1cbf8f5b5a2e4", size = 604607, upload-time = "2026-10-26T10:55:03.141Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b8/c9a1f21627238171a2021dd777177a211df20b12c0c5e45b828ee9bc3c84/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:4bd00a485e973cb3bcefe06f13a663cf4ee0c54caeacb2a656a5f901d1505a03", size = 563749, upload-time = "2026-10-26T10:55:04.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/9e/ed7d14d4d7bdb94159909e722337a557c855e8990a7fdff55ef6b016fb38/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:9fe68c4b2e017fb13c5e460b76b76c5cfa717ddd653cea184c2664bc2a852011", size = 530994, upload-time = "2026-10-26T10:55:06.511Z" },
+    { url = "https://files.pythonhosted.org/packages/07/92/5b84a87dd4127a14337d42eb4a24a764583e4decc2675a9949d4568b16e1/uuid_utils-0.19.0-cp315-cp315t-win32.whl", hash = "sha256:5397581f40e268535cd48230e4f2f372dc5f3e70ce79e0aff9cb5ceb838163c8", size = 172512, upload-time = "2026-10-26T10:55:08.261Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/a11a33e39f64c50f17483842652933b8ef769ce7cac3399ed7d2a2b928c2/uuid_utils-0.19.0-cp315-cp315t-win_amd64.whl", hash = "sha256:225752e3c36b7c861eb1bbceb5c9197c134c806b210ed53dcacf6339a3d599e6", size = 178626, upload-time = "2026-10-26T10:55:09.658Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/78/4f9dc891db194ce8107c9704d7e2e51da558af457e64134da1b1a7c5db1f/uuid_utils-0.19.0-cp315-cp315t-win_arm64.whl", hash = "sha256:bfcda2352c1500230227da5475139ab177bb2516309254cd74ade19a28cb842d", size = 175582, upload-time = "2026-10-26T10:55:11.001Z" },
+    { url = "https://files.pythonhosted.org/packages/61/60/751fb8688322e107e4b4b66747f084ac0e3de599eec6f800b1661b1bbf7b/uuid_utils-0.19.0-pp311-pypy311_pp73-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:492e621a6aa0d8b4a47cad5e71b9fbbebf5e7af6d0f568daea65d38353f713c1", size = 569090, upload-time = "2026-10-26T10:55:12.449Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/0c/2971bf13e98e2cab194fb43a81c3ffc47d2eaf84d4669d1d5b96ed89d98f/uuid_utils-0.19.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:68ab7e44d8be02c5d34e2501c465e32747b384c04cf7476de80c01729466a9dc", size = 290711, upload-time = "2026-10-26T10:55:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/18/a446ae37e9489a4dd905c738fcd98a4a49cd3c57ba36b300fc50372162b8/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0edba30609b6f1d6bc5eb9be5cc90759bf5d0c77f132d2b63fc7c62038b9304e", size = 325610, upload-time = "2026-10-26T10:55:15.237Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ee/32ae97908244fdbed279b4c7215fe186891a9aa1fe9d25f6760b4fe415bc/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6e137ad199860077c8cf732b71fc8350dbf4bc5e427c01fb82b27dbddd45e370", size = 333087, upload-time = "2026-10-26T10:55:16.728Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/dc1ad3783eb0409a912d7c87f0f00143b450cb60cecbb9e1648aabc06f30/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42f53089ba59a2d1777be98db285aa4948169d434421ee1474ce4615215326ea", size = 438894, upload-time = "2026-10-26T10:55:18.202Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/4c/07bbee76758ee4e425455477120899463eb8e05e5c533eb61c6314bf188c/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10d689c0f2715502b7d42426947e3bb5c76ac5ba91ae9bd23afc34283189b82", size = 328432, upload-time = "2026-10-26T10:55:19.512Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d6/1e70bbe1c3828fec80b060137f11db69d16b4f40f8ae32526d98b9e604ec/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0da57ba80366ae75307b686376bf437bdc76b3710d52e6ffe012c99a5c800927", size = 351628, upload-time = "2026-10-26T10:55:20.922Z" },
+    { url = "https://files.pythonhosted.org/packages/79/df/75f58b9ee63449e8f81b1698e9e3cb76efada622e6b5590b329d26242a6b/uuid_utils-0.19.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bb0c63bfa8d9af4228353b5c1b06917acf76067674d4d741c31d2117a3db09c5", size = 181546, upload-time = "2026-10-26T10:55:22.522Z" },
 ]
 
 [[package]]
@@ -2444,7 +2519,8 @@ version = "21.14.13"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "distlib" },
-    { name = "filelock" },
+    { name = "filelock", version = "4.1.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11'" },
+    { name = "filelock", version = "4.2.9", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11'" },
     { name = "packaging" },
     { name = "platformdirs" },
     { name = "python-discovery" },

libs/langgraph/langgraph/_internal/_constants.py

@@ -74,6 +74,8 @@ 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_STRICT_RESUME = sys.intern("__pregel_strict_resume")
+# when True, the root graph refuses a resume that can't be matched to its pending interrupts
 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 StreamingHandler only.
@@ -134,6 +136,7 @@ RESERVED = {
     CONFIG_KEY_CHECKPOINT_NS,
     CONFIG_KEY_TIMED_ATTEMPT_OBSERVER,
     CONFIG_KEY_RESUME_MAP,
+    CONFIG_KEY_STRICT_RESUME,
     CONFIG_KEY_STREAM_MESSAGES_V2,
     # other constants
     PUSH,

libs/langgraph/langgraph/channels/__init__.py

@@ -4,7 +4,6 @@ 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.log import Log, LogRef, MessagesLog
 from langgraph.channels.named_barrier_value import (
     NamedBarrierValue,
     NamedBarrierValueAfterFinish,
@@ -23,9 +22,6 @@ __all__ = (
     "EphemeralValue",
     "BinaryOperatorAggregate",
     "DeltaChannel",
-    "Log",
-    "LogRef",
-    "MessagesLog",
     "NamedBarrierValue",
     "NamedBarrierValueAfterFinish",
     # topics

libs/langgraph/langgraph/channels/binop.py

@@ -1,5 +1,4 @@
 import collections.abc
-import warnings
 from collections.abc import Callable, Sequence
 from typing import Any, Generic
 
@@ -30,26 +29,6 @@ def _strip_extras(t):  # type: ignore[no-untyped-def]
     return t
 
 
-def _is_add_messages(operator: Callable) -> bool:
-    """Whether `operator` is `add_messages`, alone or with `format=`."""
-    return getattr(operator, "_is_add_messages", False) or getattr(
-        getattr(operator, "func", None), "_is_add_messages", False
-    )
-
-
-def _warn_overwrite_messages() -> None:
-    from langgraph.warnings import LangGraphDeprecatedSinceV13
-
-    warnings.warn(
-        "Replacing all messages with `Overwrite` in an `add_messages` channel "
-        "is deprecated: stored history will be append-only. Build the messages "
-        "the model sees when calling it instead, and use the `MessagesLog` "
-        "channel, which stores messages once instead of in every checkpoint.",
-        category=LangGraphDeprecatedSinceV13,
-        stacklevel=4,
-    )
-
-
 def _get_overwrite(value: Any) -> tuple[bool, Any]:
     """Inspects the given value and returns (is_overwrite, overwrite_value).
 
@@ -161,8 +140,6 @@ class BinaryOperatorAggregate(Generic[Value], BaseChannel[Value, Value, Value]):
                         error_code=ErrorCode.INVALID_CONCURRENT_GRAPH_UPDATE,
                     )
                     raise InvalidUpdateError(msg)
-                if _is_add_messages(self.operator):
-                    _warn_overwrite_messages()
                 self.value = overwrite_value
                 seen_overwrite = True
                 continue

libs/langgraph/langgraph/channels/log.py

@@ -1,328 +0,0 @@
-"""Append-only log channels (transcript log prototype).
-
-!!! warning "Prototype"
-
-    The transcript log is a prototype. Its API and storage may change.
-
-A log channel is append-only and has no reducer: the only write is "append
-these entries". Its entries are not stored in checkpoints. A checkpoint's
-value for the channel is a marker (`LogStep`) for the step that produced its
-version, and the entries live in the saver's log storage, read with
-`BaseCheckpointSaver.read_log`.
-
-Two channel types share that storage:
-
-- `Log` holds JSON values. Anything that isn't JSON is rejected.
-- `MessagesLog` holds LangChain messages, stored as canonical JSON. Edit ops
-  (`RemoveMessage`, `Overwrite`, re-adding an existing id) are rejected; a
-  graph that needs a different model context builds it as a projection.
-
-A thread whose field held a plain list before it became a log channel (for
-example `Annotated[list, add_messages]` changed to `MessagesLog()`) keeps
-working: the stored list becomes the log's first entries, the "seed". The
-seed is committed with the first checkpoint saved after the change, and
-checkpoints from before the change still read as the list they stored.
-"""
-
-from __future__ import annotations
-
-import json
-import math
-import uuid
-from collections.abc import Sequence
-from typing import Any, NamedTuple
-
-from langgraph.checkpoint.serde.types import LogAppend, LogStep
-from typing_extensions import Self
-
-from langgraph._internal._typing import MISSING
-from langgraph.channels.base import BaseChannel
-from langgraph.channels.binop import _get_overwrite
-from langgraph.errors import EmptyChannelError, InvalidUpdateError
-
-__all__ = ("Log", "LogRef", "MessagesLog")
-
-
-class LogRef(NamedTuple):
-    """What state reads return for a log channel: the log's length at the
-    checkpoint. Read the entries with `read_log`."""
-
-    length: int
-
-
-def _check_json(value: Any, path: str = "entry") -> None:
-    if value is None or isinstance(value, (str, bool, int)):
-        return
-    if isinstance(value, float):
-        if not math.isfinite(value):
-            raise InvalidUpdateError(f"Log {path} is not JSON: {value!r}")
-        return
-    if isinstance(value, list):
-        for i, item in enumerate(value):
-            _check_json(item, f"{path}[{i}]")
-        return
-    if isinstance(value, dict):
-        for k, item in value.items():
-            if not isinstance(k, str):
-                raise InvalidUpdateError(f"Log {path} has a non-string key: {k!r}")
-            _check_json(item, f"{path}.{k}")
-        return
-    raise InvalidUpdateError(
-        f"Log {path} is not JSON: {type(value).__name__} {value!r}"
-    )
-
-
-def _dumps(value: Any) -> str:
-    return json.dumps(value, ensure_ascii=False, allow_nan=False, separators=(",", ":"))
-
-
-class Log(BaseChannel[list, list, LogStep]):
-    """An append-only log of JSON entries.
-
-    Write a list of entries to append them. Nodes read the whole log as a
-    list. State reads return a `LogRef` instead of the entries.
-    """
-
-    __slots__ = ("entries", "base", "marker", "loaded", "extra", "seed", "seeding")
-
-    def __init__(self, typ: Any = list) -> None:
-        super().__init__(typ)
-        self.entries: list[Any] = []
-        # length covered by the last committed step (the checkpoint's leaf)
-        self.base = 0
-        self.marker: LogStep | None = None
-        # False when built from a checkpoint without reading the log
-        self.loaded = True
-        # entries appended to a channel that was not loaded
-        self.extra = 0
-        # True while the entries hold a plain list stored before the field
-        # became a log channel, not committed to the log yet
-        self.seed = False
-        # True from the commit that includes the seed until the loop has
-        # stamped that checkpoint's step
-        self.seeding = False
-
-    def __eq__(self, other: object) -> bool:
-        return type(self) is type(other)
-
-    @property
-    def ValueType(self) -> Any:
-        return list
-
-    @property
-    def UpdateType(self) -> Any:
-        return list
-
-    # -- encoding ----------------------------------------------------------
-
-    def encode(self, entry: Any) -> Any:
-        """An entry as the JSON value stored for it."""
-        _check_json(entry)
-        return entry
-
-    def decode(self, data: Any) -> Any:
-        """A stored JSON value as the entry nodes see."""
-        return data
-
-    def coerce(self, value: Any) -> list[Any]:
-        """A write as the list of entries it appends."""
-        if not isinstance(value, list):
-            raise InvalidUpdateError(
-                f"Log channel {self.key!r} takes a list of entries, got "
-                f"{type(value).__name__}"
-            )
-        return value
-
-    def append_value(self, value: Any, exec_: str) -> LogAppend:
-        """A write as the `LogAppend` handed to the saver."""
-        self._reject_overwrite(value)
-        texts = tuple(_dumps(self.encode(e)) for e in self.coerce(value))
-        return LogAppend(self.base, texts, exec_)
-
-    # -- channel protocol --------------------------------------------------
-
-    def _new(self) -> Self:
-        new = self.__class__.__new__(self.__class__)
-        BaseChannel.__init__(new, self.typ, self.key)
-        new.entries = []
-        new.base = 0
-        new.marker = None
-        new.loaded = True
-        new.extra = 0
-        new.seed = False
-        new.seeding = False
-        return new
-
-    def copy(self) -> Self:
-        new = self._new()
-        new.entries = list(self.entries)
-        new.base = self.base
-        new.marker = self.marker
-        new.loaded = self.loaded
-        new.extra = self.extra
-        new.seed = self.seed
-        new.seeding = self.seeding
-        return new
-
-    def from_checkpoint(self, checkpoint: Any) -> Self:
-        """A channel that knows its marker but not its entries.
-
-        State reads build channels this way; `get` then returns a `LogRef`.
-        The loop builds log channels with `from_log` instead.
-
-        A plain list is what the field stored before it became a log channel.
-        The channel then holds it as its seed: uncommitted entries that the
-        next commit writes to the log, ahead of anything appended after.
-        """
-        new = self._new()
-        if isinstance(checkpoint, LogStep):
-            new.marker = checkpoint.stripped()
-            new.base = checkpoint.end
-            new.loaded = False
-        elif isinstance(checkpoint, list):
-            new.entries = self._seed_entries(checkpoint)
-            new.seed = bool(new.entries)
-        elif checkpoint is not MISSING and checkpoint is not None:
-            raise InvalidUpdateError(
-                f"Log channel {self.key!r} can't start from {type(checkpoint).__name__}"
-            )
-        return new
-
-    def _seed_entries(self, stored: list[Any]) -> list[Any]:
-        """The entries a stored plain list becomes."""
-        return list(stored)
-
-    def from_log(self, marker: Any, entries: Sequence[Any]) -> Self:
-        """A loaded channel: the marker, and the entries read from the log."""
-        new = self._new()
-        if isinstance(marker, LogStep):
-            if len(entries) != marker.end:
-                raise ValueError(
-                    f"Log channel {self.key!r}: read {len(entries)} entries, "
-                    f"the checkpoint has {marker.end}"
-                )
-            new.marker = marker.stripped()
-            new.base = marker.end
-        new.entries = [self.decode(e) for e in entries]
-        return new
-
-    def get(self) -> Any:
-        if not self.loaded:
-            return LogRef(self.base + self.extra)
-        if not self.entries:
-            raise EmptyChannelError()
-        return self.entries
-
-    def is_available(self) -> bool:
-        return (not self.loaded and self.base + self.extra > 0) or bool(self.entries)
-
-    def update(self, values: Sequence[Any]) -> bool:
-        if not values:
-            return False
-        appended: list[Any] = []
-        for value in values:
-            if isinstance(value, LogAppend):
-                # a write read back from the saver (pending writes on resume)
-                appended.extend(self.decode(json.loads(t)) for t in value.entries)
-                continue
-            self._reject_overwrite(value)
-            for entry in self.coerce(value):
-                self.encode(entry)  # validate before anything is applied
-                appended.append(entry)
-        if not appended:
-            return False
-        self._check_appends(appended)
-        if not self.loaded:
-            self.extra += len(appended)
-        else:
-            self.entries.extend(appended)
-        return True
-
-    def _check_appends(self, appended: list[Any]) -> None:
-        pass
-
-    def _reject_overwrite(self, value: Any) -> None:
-        if _get_overwrite(value)[0]:
-            raise InvalidUpdateError(
-                f"Log channel {self.key!r} is append-only: Overwrite is not supported"
-            )
-
-    def checkpoint(self) -> Any:
-        return MISSING if self.marker is None else self.marker
-
-    def commit(self) -> LogStep | None:
-        """The marker for a checkpoint about to be saved.
-
-        Entries appended since the last commit become a new `LogStep`
-        (carrying them inline; the loop strips them when they already reached
-        the saver through `put_writes`), and the channel's base moves to its
-        end.
-        """
-        if self.loaded and len(self.entries) > self.base:
-            texts = tuple(_dumps(self.encode(e)) for e in self.entries[self.base :])
-            step = LogStep(self.base, len(self.entries) - self.base, "", texts)
-            self.base = len(self.entries)
-            self.marker = step.stripped()
-            self.seeding, self.seed = self.seed, False
-            return step
-        return self.marker
-
-
-class MessagesLog(Log):
-    """An append-only log of LangChain messages.
-
-    Messages are stored as canonical JSON (`message_to_dict`). Every message
-    has an id; writing an id that is already in the log is an error, as are
-    `RemoveMessage` and `Overwrite`.
-    """
-
-    __slots__ = ()
-
-    def encode(self, entry: Any) -> Any:
-        from langchain_core.messages import BaseMessage, RemoveMessage, message_to_dict
-
-        if isinstance(entry, RemoveMessage):
-            raise InvalidUpdateError(
-                f"MessagesLog {self.key!r} is append-only: RemoveMessage is not "
-                "supported. To give the model a different set of messages, build "
-                "them when calling the model instead of changing stored history."
-            )
-        if not isinstance(entry, BaseMessage):
-            raise InvalidUpdateError(
-                f"MessagesLog {self.key!r} takes messages, got {type(entry).__name__}"
-            )
-        data = message_to_dict(entry)
-        _check_json(data, "message")
-        return data
-
-    def decode(self, data: Any) -> Any:
-        from langchain_core.messages import messages_from_dict
-
-        return messages_from_dict([data])[0]
-
-    def _seed_entries(self, stored: list[Any]) -> list[Any]:
-        # the list `add_messages` stored: already merged, so ids are unique
-        # and there are no `RemoveMessage`s
-        return self.coerce(stored)
-
-    def coerce(self, value: Any) -> list[Any]:
-        from langchain_core.messages import convert_to_messages
-
-        items = value if isinstance(value, list) else [value]
-        messages = convert_to_messages(items)
-        for m in messages:
-            if not m.id:
-                m.id = str(uuid.uuid4())
-        return messages
-
-    def _check_appends(self, appended: list[Any]) -> None:
-        seen = {m.id for m in self.entries} if self.loaded else set()
-        for m in appended:
-            if m.id in seen:
-                raise InvalidUpdateError(
-                    f"MessagesLog {self.key!r} already has a message with id "
-                    f"{m.id!r}: the log is append-only, so a message can't be "
-                    "replaced. Return only new messages from a node, not the "
-                    "whole list."
-                )
-            seen.add(m.id)

libs/langgraph/langgraph/errors.py

@@ -26,8 +26,10 @@ __all__ = (
     "NodeInterrupt",
     "NodeTimeoutError",
     "ParentCommand",
+    "RunCancelled",
     "EmptyInputError",
     "TaskNotFound",
+    "UnknownInterruptError",
     "is_invalid_resume",
 )
 
@@ -146,6 +148,46 @@ class TaskNotFound(Exception):
     pass
 
 
+class UnknownInterruptError(Exception):
+    """Raised in strict resume mode when a resume doesn't match the pending interrupts.
+
+    `reason` says how it doesn't match:
+
+    - `"not_pending"`: the resume names interrupts that aren't pending, listed in
+      `interrupt_ids`.
+    - `"empty_map"`: the resume is an empty map.
+    - `"ambiguous"`: the resume is a single value while several interrupts are
+      pending.
+
+    `pending_ids` lists the interrupts still waiting for an answer. The error is
+    raised before anything is written, so they can still be answered.
+
+    A single value with no interrupt pending is accepted, because it resumes a
+    graph paused at a static breakpoint (`interrupt_before` or `interrupt_after`).
+
+    Each `interrupt()` call in a task has its own id, so an answer retried after
+    the task asked its next question is refused instead of answering that
+    question.
+    """
+
+    reason: Literal["not_pending", "empty_map", "ambiguous"]
+    interrupt_ids: tuple[str, ...]
+    pending_ids: tuple[str, ...]
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        reason: Literal["not_pending", "empty_map", "ambiguous"],
+        interrupt_ids: Sequence[str] = (),
+        pending_ids: Sequence[str] = (),
+    ) -> None:
+        super().__init__(message)
+        self.reason = reason
+        self.interrupt_ids = tuple(interrupt_ids)
+        self.pending_ids = tuple(pending_ids)
+
+
 @dataclass(frozen=True, slots=True)
 class NodeError:
     """Failure context passed to a node-level error handler.
@@ -166,6 +208,25 @@ class NodeError:
     """Exception raised by the failed node."""
 
 
+class RunCancelled(Exception):
+    """Cancel message that asks the graph to run its cancel handler.
+
+    Pass an instance to `task.cancel()` on the task running the graph. A cancel
+    without one, such as `asyncio.timeout`, a task group stopping siblings, or a
+    process shutting down, skips the handler, so the run can be resumed as is.
+
+    Example:
+        ```python
+        run = asyncio.create_task(graph.ainvoke(inputs, config))
+        run.cancel(RunCancelled("user stop"))
+        ```
+    """
+
+    run_cancel_handler: bool = True
+    """Set to `False` in a subclass whose cancels should skip the handler, such as
+    a rollback that deletes the run."""
+
+
 class NodeCancelledError(Exception):
     """Raised when a node body raises ``asyncio.CancelledError`` itself.
 

libs/langgraph/langgraph/graph/message.py

@@ -27,7 +27,7 @@ from langgraph.graph.state import StateGraph
 from langgraph.pregel._messages import (
     _messages_delta_reducer as _messages_delta_reducer,
 )
-from langgraph.warnings import LangGraphDeprecatedSinceV10, LangGraphDeprecatedSinceV13
+from langgraph.warnings import LangGraphDeprecatedSinceV10
 
 __all__ = (
     "add_messages",
@@ -41,27 +41,7 @@ Messages = list[MessageLikeRepresentation] | MessageLikeRepresentation
 REMOVE_ALL_MESSAGES = "__remove_all__"
 
 
-_EDIT_DEPRECATION = (
-    "{what} through `add_messages` is deprecated: stored history will be "
-    "append-only. Build the messages the model sees when calling it instead "
-    "(for example from a summary kept in state), and use the `MessagesLog` "
-    "channel, which stores messages once instead of in every checkpoint."
-)
-
-
-def _warn_edit(what: str) -> None:
-    warnings.warn(
-        _EDIT_DEPRECATION.format(what=what),
-        category=LangGraphDeprecatedSinceV13,
-        stacklevel=3,
-    )
-
-
 def _add_messages_wrapper(func: Callable) -> Callable[[Messages, Messages], Messages]:
-    # lets `BinaryOperatorAggregate` recognize the reducer, alone or with
-    # `format=`, without importing this module
-    func._is_add_messages = True  # type: ignore[attr-defined]
-
     def _add_messages(
         left: Messages | None = None, right: Messages | None = None, **kwargs: Any
     ) -> Messages | Callable[[Messages, Messages], Messages]:
@@ -77,7 +57,6 @@ def _add_messages_wrapper(func: Callable) -> Callable[[Messages, Messages], Mess
             return partial(func, **kwargs)
 
     _add_messages.__doc__ = func.__doc__
-    _add_messages._is_add_messages = True  # type: ignore[attr-defined]
     return cast(Callable[[Messages, Messages], Messages], _add_messages)
 
 
@@ -234,11 +213,9 @@ def add_messages(
             remove_all_idx = idx
 
     if remove_all_idx is not None:
-        _warn_edit("Removing all messages with `REMOVE_ALL_MESSAGES`")
         return right[remove_all_idx + 1 :]
 
     # merge
-    left_ids = {m.id for m in left}
     merged = left.copy()
     merged_by_id = {m.id: i for i, m in enumerate(merged)}
     ids_to_remove = set()
@@ -258,10 +235,6 @@ def add_messages(
             merged_by_id[m.id] = len(merged)
             merged.append(m)
     merged = [m for m in merged if m.id not in ids_to_remove]
-    if any(isinstance(m, RemoveMessage) for m in right):
-        _warn_edit("Removing messages with `RemoveMessage`")
-    elif any(m.id in left_ids for m in right):
-        _warn_edit("Replacing a message by id")
 
     if format == "langchain-openai":
         merged = _format_messages(merged)

libs/langgraph/langgraph/graph/state.py

@@ -77,6 +77,7 @@ from langgraph.pregel._write import (
     ChannelWriteEntry,
     ChannelWriteTupleEntry,
 )
+from langgraph.runtime import Runtime
 from langgraph.types import (
     All,
     CachePolicy,
@@ -264,6 +265,8 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
         self.context_schema = context_schema
 
         self._node_defaults: _NodeDefaults = _NodeDefaults()
+        self._cancel_handler: Callable[[Any, Runtime[ContextT]], Any] | None = None
+        self._cancel_timeout = 5.0
 
         self._add_schema(self.state_schema)
         self._add_schema(self.input_schema, allow_managed=False)
@@ -334,6 +337,41 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
             defaults.timeout = coerce_timeout_policy(timeout)
         return self
 
+    def set_cancel_handler(
+        self,
+        handler: Callable[[StateT, Runtime[ContextT]], Any],
+        *,
+        timeout: float = 5.0,
+    ) -> Self:
+        """Set a handler that runs once when an async run of this graph is cancelled.
+
+        A cancelled node never reaches its `error_handler`, so state can be left
+        mid-step, for example an AI message whose tool call never got a result.
+        After the cancelled run finishes saving, the handler gets the latest state
+        and the run's `Runtime`. A returned update is saved with `update_state`,
+        then the cancellation propagates.
+
+        The handler runs only when the cancel message is a `RunCancelled`, as in
+        `task.cancel(RunCancelled("user stop"))`. Plain cancels, like `asyncio.timeout`
+        or a process shutting down, skip it so the run can be resumed as is.
+
+        Only top-level async runs with a checkpointer call the handler. It gets
+        `timeout` seconds in total; if it runs over or raises, the error is logged
+        and the update is skipped.
+
+        Args:
+            handler: Sync or async callable taking `(state, runtime)` and returning
+                a state update or `None`.
+            timeout: Seconds the handler may take, including the wait for the
+                cancelled run to finish saving.
+
+        Returns:
+            Self: The builder instance, for chaining.
+        """
+        self._cancel_handler = handler
+        self._cancel_timeout = timeout
+        return self
+
     @property
     def _all_edges(self) -> set[tuple[str, str]]:
         return self.edges | {
@@ -1365,6 +1403,8 @@ class StateGraph(Generic[StateT, ContextT, InputT, OutputT]):
             store=store,
             cache=cache,
             node_error_handler_map=node_error_handler_map,
+            cancel_handler=self._cancel_handler,
+            cancel_timeout=self._cancel_timeout,
             name=name or "LangGraph",
             stream_transformers=transformers,
         )

libs/langgraph/langgraph/pregel/_algo.py

@@ -85,6 +85,7 @@ from langgraph.types import (
     RetryPolicy,
     Send,
     TimeoutPolicy,
+    _interrupt_id,
 )
 
 GetNextVersion = Callable[[V | None, None], V]
@@ -626,7 +627,7 @@ def prepare_single_task(
                 config[CONF].get(CONFIG_KEY_SCRATCHPAD),
                 pending_writes,
                 task_id,
-                xxh3_128_hexdigest(task_checkpoint_ns.encode()),
+                task_checkpoint_ns,
                 config[CONF].get(CONFIG_KEY_RESUME_MAP),
                 step,
                 stop,
@@ -873,7 +874,7 @@ def prepare_push_task_functional(
             configurable.get(CONFIG_KEY_SCRATCHPAD),
             pending_writes,
             task_id,
-            xxh3_128_hexdigest(task_checkpoint_ns.encode()),
+            task_checkpoint_ns,
             configurable.get(CONFIG_KEY_RESUME_MAP),
             step,
             stop,
@@ -1035,7 +1036,7 @@ def prepare_push_task_send(
             config[CONF].get(CONFIG_KEY_SCRATCHPAD),
             pending_writes,
             task_id,
-            xxh3_128_hexdigest(task_checkpoint_ns.encode()),
+            task_checkpoint_ns,
             config[CONF].get(CONFIG_KEY_RESUME_MAP),
             step,
             stop,
@@ -1184,7 +1185,7 @@ def prepare_node_error_handler_task(
         config[CONF].get(CONFIG_KEY_SCRATCHPAD),
         pending_writes,
         task_id,
-        xxh3_128_hexdigest(task_checkpoint_ns.encode()),
+        task_checkpoint_ns,
         config[CONF].get(CONFIG_KEY_RESUME_MAP),
         step,
         stop,
@@ -1280,7 +1281,7 @@ def _scratchpad(
     parent_scratchpad: PregelScratchpad | None,
     pending_writes: list[PendingWrite],
     task_id: str,
-    namespace_hash: str,
+    task_checkpoint_ns: str,
     resume_map: dict[str, Any] | None,
     step: int,
     stop: int,
@@ -1307,10 +1308,15 @@ def _scratchpad(
             task_resume_write = []
         del w
 
-        # find namespace and task-specific resume value
-        if resume_map and namespace_hash in resume_map:
-            mapped_resume_write = resume_map[namespace_hash]
-            task_resume_write.append(mapped_resume_write)
+        # find the resume value for the task's next interrupt
+        if resume_map:
+            next_id = _interrupt_id(task_checkpoint_ns, len(task_resume_write))
+            first_id = _interrupt_id(task_checkpoint_ns, 0)
+            if next_id in resume_map:
+                task_resume_write.append(resume_map[next_id])
+            # Older versions gave all of a task's interrupts the first id.
+            elif first_id in resume_map:
+                task_resume_write.append(resume_map[first_id])
 
     else:
         null_resume_write = None

libs/langgraph/langgraph/pregel/_checkpoint.py

@@ -4,7 +4,7 @@ import uuid
 from collections.abc import Callable, Iterable, Mapping, Sequence
 from datetime import datetime, timezone
 from inspect import signature
-from typing import Any, Literal, cast
+from typing import Any, Literal
 
 from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import (
@@ -16,7 +16,7 @@ from langgraph.checkpoint.base import (
     PendingWrite,
 )
 from langgraph.checkpoint.base.id import uuid6
-from langgraph.checkpoint.serde.types import LogStep, _DeltaSnapshot
+from langgraph.checkpoint.serde.types import _DeltaSnapshot
 
 from langgraph._internal._config import (
     DELTA_MAX_SUPERSTEPS_SINCE_SNAPSHOT,
@@ -35,7 +35,6 @@ from langgraph._internal._typing import MISSING
 from langgraph.channels.base import BaseChannel
 from langgraph.channels.binop import BinaryOperatorAggregate, _get_overwrite
 from langgraph.channels.delta import DeltaChannel
-from langgraph.channels.log import Log
 from langgraph.managed.base import ManagedValueMapping, ManagedValueSpec
 
 LATEST_VERSION = 4
@@ -326,10 +325,6 @@ def create_checkpoint(
                     bumped[k] = (old, channel_versions[k])
                 values[k] = _DeltaSnapshot(ch.get())
             else:
-                if isinstance(ch, Log):
-                    if (log_step := ch.commit()) is not None:
-                        values[k] = log_step
-                    continue
                 v = ch.checkpoint()
                 if v is not MISSING:
                     values[k] = v
@@ -460,39 +455,12 @@ def _require_saver_for_history(
         )
 
 
-def _log_specs(
-    specs: Mapping[str, BaseChannel], checkpoint: Checkpoint, load_logs: bool
-) -> list[str]:
-    """Log channels whose entries must be read from the saver."""
-    if not load_logs:
-        return []
-    return [
-        k
-        for k, spec in specs.items()
-        if isinstance(spec, Log)
-        and isinstance(checkpoint["channel_values"].get(k), LogStep)
-    ]
-
-
-def _require_saver_for_log(
-    log_channels: list[str],
-    saver: BaseCheckpointSaver | None,
-    config: RunnableConfig | None,
-) -> None:
-    if log_channels and (saver is None or config is None):
-        raise ValueError(
-            f"Log channels {log_channels} have entries to read but no "
-            "checkpointer or config was passed to read them"
-        )
-
-
 def channels_from_checkpoint(
     specs: Mapping[str, BaseChannel | ManagedValueSpec],
     checkpoint: Checkpoint,
     *,
     saver: BaseCheckpointSaver | None = None,
     config: RunnableConfig | None = None,
-    load_logs: bool = True,
 ) -> tuple[Mapping[str, BaseChannel], ManagedValueMapping]:
     """Hydrate channels from a checkpoint.
 
@@ -519,20 +487,12 @@ def channels_from_checkpoint(
         histories = saver.get_delta_channel_history(
             config=config, channels=delta_channels
         )
-    log_channels = _log_specs(channel_specs, checkpoint, load_logs)
-    _require_saver_for_log(log_channels, saver, config)
-    logs: dict[str, list[Any]] = {}
-    if log_channels and saver is not None and config is not None:
-        for k in log_channels:
-            logs[k] = [e for _, e in saver.read_log(config, k).entries]
 
     channels: dict[str, BaseChannel] = {}
     for k, spec in channel_specs.items():
         ch: BaseChannel
         if k in histories:
             ch = _replay(spec, histories[k])
-        elif k in logs:
-            ch = cast(Log, spec).from_log(checkpoint["channel_values"][k], logs[k])
         else:
             ch = spec.from_checkpoint(checkpoint["channel_values"].get(k, MISSING))
         channels[k] = ch
@@ -545,7 +505,6 @@ async def achannels_from_checkpoint(
     *,
     saver: BaseCheckpointSaver | None = None,
     config: RunnableConfig | None = None,
-    load_logs: bool = True,
 ) -> tuple[Mapping[str, BaseChannel], ManagedValueMapping]:
     """Async version of `channels_from_checkpoint`. See docstring there."""
     channel_specs: dict[str, BaseChannel] = {}
@@ -563,20 +522,12 @@ async def achannels_from_checkpoint(
         histories = await saver.aget_delta_channel_history(
             config=config, channels=delta_channels
         )
-    log_channels = _log_specs(channel_specs, checkpoint, load_logs)
-    _require_saver_for_log(log_channels, saver, config)
-    logs: dict[str, list[Any]] = {}
-    if log_channels and saver is not None and config is not None:
-        for k in log_channels:
-            logs[k] = [e for _, e in (await saver.aread_log(config, k)).entries]
 
     channels: dict[str, BaseChannel] = {}
     for k, spec in channel_specs.items():
         ch: BaseChannel
         if k in histories:
             ch = _replay(spec, histories[k])
-        elif k in logs:
-            ch = cast(Log, spec).from_log(checkpoint["channel_values"][k], logs[k])
         else:
             ch = spec.from_checkpoint(checkpoint["channel_values"].get(k, MISSING))
         channels[k] = ch

libs/langgraph/langgraph/pregel/_loop.py

@@ -3,7 +3,6 @@ from __future__ import annotations
 import asyncio
 import binascii
 import concurrent.futures
-import json
 from collections import defaultdict, deque
 from collections.abc import Callable, Iterator, Mapping, Sequence
 from contextlib import (
@@ -13,7 +12,6 @@ from contextlib import (
     ExitStack,
 )
 from datetime import datetime, timezone
-from functools import partial
 from types import TracebackType
 from typing import (
     Any,
@@ -21,7 +19,7 @@ from typing import (
     TypeVar,
     cast,
 )
-from uuid import UUID, uuid4, uuid5
+from uuid import UUID, uuid5
 
 from langchain_core.callbacks import AsyncParentRunManager, ParentRunManager
 from langchain_core.runnables import RunnableConfig
@@ -35,7 +33,6 @@ from langgraph.checkpoint.base import (
     CheckpointTuple,
     PendingWrite,
 )
-from langgraph.checkpoint.serde.types import LogAppend, LogStep
 from langgraph.store.base import BaseStore
 from typing_extensions import ParamSpec, Self
 
@@ -51,6 +48,7 @@ from langgraph._internal._constants import (
     CONFIG_KEY_RUNTIME,
     CONFIG_KEY_SCRATCHPAD,
     CONFIG_KEY_STREAM,
+    CONFIG_KEY_STRICT_RESUME,
     CONFIG_KEY_TASK_ID,
     CONFIG_KEY_THREAD_ID,
     ERROR,
@@ -75,12 +73,12 @@ from langgraph.callbacks import (
 from langgraph.channels.base import BaseChannel
 from langgraph.channels.binop import _get_overwrite
 from langgraph.channels.delta import DeltaChannel
-from langgraph.channels.log import Log
 from langgraph.channels.untracked_value import UntrackedValue
 from langgraph.constants import TAG_HIDDEN
 from langgraph.errors import (
     EmptyInputError,
     GraphInterrupt,
+    UnknownInterruptError,
 )
 from langgraph.managed.base import (
     ManagedValueMapping,
@@ -360,9 +358,6 @@ class PregelLoop:
         self.retry_policy = retry_policy
         self.cache_policy = cache_policy
         self.durability = durability
-        # identifies this execution's log writes (transcript log prototype)
-        self._log_exec = str(uuid4())
-        self._log_inline_first_step = False
         self._has_graph_lifecycle_callbacks = has_graph_lifecycle_callbacks
         self._graph_lifecycle_events = deque()
         if self.stream is not None and CONFIG_KEY_STREAM in config[CONF]:
@@ -520,7 +515,6 @@ class PregelLoop:
         # save writes
         self.checkpoint_pending_writes.extend((task_id, c, v) for c, v in writes)
         if self.durability != "exit" and self.checkpointer_put_writes is not None:
-            writes_to_save = self._log_writes_for_saver(writes_to_save)
             config = patch_configurable(
                 self.checkpoint_config,
                 {
@@ -530,21 +524,13 @@ class PregelLoop:
                     CONFIG_KEY_CHECKPOINT_ID: self.checkpoint["id"],
                 },
             )
-            # A log write is placed relative to the log of the checkpoint it is
-            # stored on, so that checkpoint must be saved first.
-            put_writes_fn = self.checkpointer_put_writes
-            if any(isinstance(self.specs.get(c), Log) for c, _ in writes_to_save):
-                put_writes_fn = partial(
-                    self._put_writes_after_checkpoint,
-                    getattr(self, "_put_checkpoint_fut", None),
-                )
             if self.checkpointer_put_writes_accepts_task_path:
                 if hasattr(self, "tasks"):
                     task = self.tasks.get(task_id)
                 else:
                     task = None
                 fut = self.submit(
-                    put_writes_fn,
+                    self.checkpointer_put_writes,
                     config,
                     writes_to_save,
                     task_id,
@@ -552,16 +538,13 @@ class PregelLoop:
                 )
             else:
                 fut = self.submit(
-                    put_writes_fn,
+                    self.checkpointer_put_writes,
                     config,
                     writes_to_save,
                     task_id,
                 )
-            # the checkpoint that commits these writes must not be saved before
-            # them: a delta replay or a log step reads them
             if self._delta_write_futs is not None and any(
-                isinstance(self.specs.get(c), (DeltaChannel, Log))
-                for c, _ in writes_to_save
+                isinstance(self.specs.get(c), DeltaChannel) for c, _ in writes_to_save
             ):
                 self._delta_write_futs.append(fut)
             # ERROR_SOURCE_NODE is only appended by commit() when the task
@@ -575,24 +558,6 @@ class PregelLoop:
         if hasattr(self, "tasks"):
             self.output_writes(task_id, writes, cached=cached)
 
-    def _log_write_from_saver(self, channel: str, value: Any) -> Any:
-        """A saved `LogAppend` as the write it was: a list of entries."""
-        spec = self.specs.get(channel)
-        if isinstance(value, LogAppend) and isinstance(spec, Log):
-            return [spec.decode(json.loads(t)) for t in value.entries]
-        return value
-
-    def _log_writes_for_saver(self, writes: WritesT) -> WritesT:
-        """Writes to log channels as the `LogAppend`s handed to the saver."""
-        if not any(isinstance(self.channels.get(c), Log) for c, _ in writes):
-            return writes
-        return [
-            (c, ch.append_value(v, self._log_exec))
-            if isinstance(ch := self.channels.get(c), Log)
-            else (c, v)
-            for c, v in writes
-        ]
-
     def _put_pending_writes(self) -> None:
         if self.checkpointer_put_writes is None:
             return
@@ -616,7 +581,6 @@ class PregelLoop:
                 by_task[task_id].append((channel, value))
         # submit writes to checkpointer
         for task_id, writes in by_task.items():
-            writes = self._log_writes_for_saver(writes)
             if self.checkpointer_put_writes_accepts_task_path and hasattr(
                 self, "tasks"
             ):
@@ -1062,17 +1026,45 @@ class PregelLoop:
                         "Cannot use Command(resume=...) without checkpointer"
                     )
 
+                strict = (
+                    self.config[CONF].get(CONFIG_KEY_STRICT_RESUME, False)
+                    # Nested calls inherit the parent's configurable.
+                    and not self.is_nested
+                    # A finished task can rerun and interrupt again on replay, while
+                    # its earlier output still makes its interrupt look answered.
+                    and not self._addressed_checkpoint_superseded
+                )
                 if resume_is_map := (
                     isinstance(resume, dict)
                     and all(is_xxh3_128_hexdigest(k) for k in resume)
                 ):
+                    if strict:
+                        pending = self._pending_interrupts()
+                        if not resume:
+                            raise UnknownInterruptError(
+                                "The resume map names no interrupt",
+                                reason="empty_map",
+                                pending_ids=sorted(pending),
+                            )
+                        if unknown := sorted(resume.keys() - pending):
+                            raise UnknownInterruptError(
+                                f"Unknown or already-consumed interrupt: {unknown[0]}",
+                                reason="not_pending",
+                                interrupt_ids=unknown,
+                                pending_ids=sorted(pending),
+                            )
                     self.config[CONF][CONFIG_KEY_RESUME_MAP] = resume
                 else:
-                    if len(self._pending_interrupts()) > 1:
-                        raise RuntimeError(
+                    if len(pending := self._pending_interrupts()) > 1:
+                        message = (
                             "When there are multiple pending interrupts, you must specify the interrupt id when resuming. "
-                            "Docs: https://docs.langchain.com/oss/python/langgraph/add-human-in-the-loop#resume-multiple-interrupts-with-one-invocation."
+                            "Docs: https://docs.langchain.com/oss/python/langgraph/interrupts#handling-multiple-interrupts."
                         )
+                        if strict:
+                            raise UnknownInterruptError(
+                                message, reason="ambiguous", pending_ids=sorted(pending)
+                            )
+                        raise RuntimeError(message)
 
             writes: defaultdict[str, list[tuple[str, Any]]] = defaultdict(list)
             # group writes by task ID
@@ -1349,8 +1341,6 @@ class PregelLoop:
             stored_versions=self.checkpoint_previous_versions,
             trigger_to_nodes=self.trigger_to_nodes,
         )
-        if do_checkpoint:
-            self._finish_log_steps(metadata)
         for k in channels_to_snapshot:
             new_counters[k] = (0, 0)
         if do_checkpoint:
@@ -1423,51 +1413,6 @@ class PregelLoop:
             # increment step
             self.step += 1
 
-    def _finish_log_steps(self, metadata: CheckpointMetadata) -> None:
-        """Stamp the log steps of the checkpoint about to be saved.
-
-        A step's entries reached the saver through `put_writes` when the
-        checkpoint comes from the loop and writes are saved as they happen;
-        then the step carries no entries. Otherwise (graph input, a fork,
-        `durability="exit"`) it carries them inline.
-
-        A resume at a checkpoint the thread moved past re-runs finished tasks
-        on that same checkpoint, and a saver without native log support keeps
-        the first run's writes under the same keys. So the first step of such
-        a resume carries its entries inline too.
-
-        So does a step that commits a seed (the list a field stored before it
-        became a log channel), which never went through `put_writes`. The
-        channel's version is bumped if the step didn't change it, so that the
-        saver stores the step and the checkpoint points at the log.
-        """
-        inline = (
-            metadata.get("source") != "loop"
-            or self.durability == "exit"
-            or self._log_inline_first_step
-        )
-        if metadata.get("source") == "loop":
-            self._log_inline_first_step = False
-        values = self.checkpoint["channel_values"]
-        for k, ch in self.channels.items():
-            if not isinstance(ch, Log):
-                continue
-            step = values.get(k)
-            seeding, ch.seeding = ch.seeding, False
-            if seeding:
-                versions = self.checkpoint["channel_versions"]
-                if versions.get(k) == self.checkpoint_previous_versions.get(k):
-                    versions[k] = self.checkpointer_get_next_version(
-                        versions.get(k), None
-                    )
-            if isinstance(step, LogStep) and step.entries is not None:
-                values[k] = LogStep(
-                    step.start,
-                    step.count,
-                    self._log_exec,
-                    step.entries if inline or seeding else None,
-                )
-
     def _put_exit_delta_writes(self) -> None:
         """Stage stub + accumulated delta writes so final_checkpoint's put
         waits on them (visibility invariant: both must be durable before
@@ -1794,13 +1739,6 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
             self.checkpointer_put_writes = None
             self.checkpointer_put_writes_accepts_task_path = False
 
-    def _put_writes_after_checkpoint(
-        self, prev: concurrent.futures.Future | None, *args: Any
-    ) -> None:
-        if prev is not None:
-            prev.result()
-        cast(Callable[..., None], self.checkpointer_put_writes)(*args)
-
     def _checkpointer_put_after_previous(
         self,
         prev: concurrent.futures.Future | None,
@@ -1913,10 +1851,6 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
                 self._addressed_checkpoint_superseded = checkpoint_superseded(
                     self.checkpointer, self.checkpoint_config, saved
                 )
-                self._log_inline_first_step = (
-                    self._addressed_checkpoint_superseded
-                    and not self.checkpointer.supports_log
-                )
         elif replay_state := self.config[CONF].get(CONFIG_KEY_REPLAY_STATE):
             # Subgraph replay: the parent is replaying and passed us a
             # replay_state with its checkpoint_id. Look up our checkpoint
@@ -1961,10 +1895,7 @@ class SyncPregelLoop(PregelLoop, AbstractContextManager):
         self.checkpoint = saved.checkpoint
         self.checkpoint_metadata = saved.metadata
         self.checkpoint_pending_writes = (
-            [
-                (str(tid), k, self._log_write_from_saver(k, v))
-                for tid, k, v in saved.pending_writes
-            ]
+            [(str(tid), k, v) for tid, k, v in saved.pending_writes]
             if saved.pending_writes is not None
             else []
         )
@@ -2064,13 +1995,6 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
             self.checkpointer_put_writes = None
             self.checkpointer_put_writes_accepts_task_path = False
 
-    async def _put_writes_after_checkpoint(
-        self, prev: asyncio.Task | None, *args: Any
-    ) -> None:
-        if prev is not None:
-            await prev
-        await cast(Callable[..., Any], self.checkpointer_put_writes)(*args)
-
     async def _checkpointer_put_after_previous(
         self,
         prev: asyncio.Task | None,
@@ -2183,10 +2107,6 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
                 self._addressed_checkpoint_superseded = await acheckpoint_superseded(
                     self.checkpointer, self.checkpoint_config, saved
                 )
-                self._log_inline_first_step = (
-                    self._addressed_checkpoint_superseded
-                    and not self.checkpointer.supports_log
-                )
         elif replay_state := self.config[CONF].get(CONFIG_KEY_REPLAY_STATE):
             # Subgraph replay: the parent is replaying and passed us a
             # replay_state with its checkpoint_id. Look up our checkpoint
@@ -2231,10 +2151,7 @@ class AsyncPregelLoop(PregelLoop, AbstractAsyncContextManager):
         self.checkpoint = saved.checkpoint
         self.checkpoint_metadata = saved.metadata
         self.checkpoint_pending_writes = (
-            [
-                (str(tid), k, self._log_write_from_saver(k, v))
-                for tid, k, v in saved.pending_writes
-            ]
+            [(str(tid), k, v) for tid, k, v in saved.pending_writes]
             if saved.pending_writes is not None
             else []
         )

libs/langgraph/langgraph/pregel/_messages.py

@@ -26,7 +26,6 @@ from langgraph._internal._config import filter_to_user_tags
 from langgraph._internal._constants import NS_SEP, PUSH
 from langgraph.channels.binop import _get_overwrite
 from langgraph.channels.delta import DeltaChannel
-from langgraph.channels.log import MessagesLog
 from langgraph.constants import TAG_HIDDEN, TAG_NOSTREAM
 from langgraph.pregel.protocol import StreamChunk
 from langgraph.types import Command, Overwrite
@@ -538,13 +537,6 @@ def ensure_message_ids(
     """
     for i, (ch, value) in enumerate(writes):
         spec = channels.get(ch)
-        if isinstance(spec, MessagesLog):
-            # ids must be set before the write is saved, so the saved
-            # entries and the run's in-memory messages agree
-            new_value = _with_message_ids(value)
-            if new_value is not value:
-                cast(MutableSequence[tuple[str, Any]], writes)[i] = (ch, new_value)
-            continue
         if not isinstance(spec, DeltaChannel):
             continue
         if spec.reducer is _messages_delta_reducer:

libs/langgraph/langgraph/pregel/_retry.py

@@ -28,6 +28,7 @@ from langgraph._internal._constants import (
     CONFIG_KEY_CHECKPOINT_NS,
     CONFIG_KEY_RESUMING,
     CONFIG_KEY_RUNTIME,
+    CONFIG_KEY_SCRATCHPAD,
     CONFIG_KEY_SEND,
     CONFIG_KEY_STREAM,
     CONFIG_KEY_TASK_ID,
@@ -44,6 +45,7 @@ from langgraph.errors import (
     NodeTimeoutError,
     ParentCommand,
 )
+from langgraph.pregel._algo import LazyAtomicCounter
 from langgraph.pregel.protocol import StreamProtocol
 from langgraph.runtime import ExecutionInfo, Runtime
 from langgraph.types import Command, PregelExecutableTask, RetryPolicy, TimeoutPolicy
@@ -571,6 +573,23 @@ def _checkpoint_ns_for_parent_command(ns: str) -> str:
     return NS_SEP.join(parts)
 
 
+def _reset_interrupt_counter(config: RunnableConfig) -> RunnableConfig:
+    # A retry reruns the node from its first line, so its interrupt() calls count
+    # from the first again to reuse the answers its task already has, rather than
+    # asking again under an id the next resume can't match.
+    scratchpad = config[CONF].get(CONFIG_KEY_SCRATCHPAD)
+    if scratchpad is None:
+        return config
+    return patch_configurable(
+        config,
+        {
+            CONFIG_KEY_SCRATCHPAD: replace(
+                scratchpad, interrupt_counter=LazyAtomicCounter()
+            )
+        },
+    )
+
+
 def run_with_retry(
     task: PregelExecutableTask,
     retry_policy: Sequence[RetryPolicy] | None,
@@ -681,6 +700,7 @@ def run_with_retry(
             )
             # signal subgraphs to resume (if available)
             config = patch_configurable(config, {CONFIG_KEY_RESUMING: True})
+            config = _reset_interrupt_counter(config)
 
 
 async def arun_with_retry(
@@ -829,6 +849,7 @@ async def arun_with_retry(
             )
             # signal subgraphs to resume (if available)
             config = patch_configurable(config, {CONFIG_KEY_RESUMING: True})
+            config = _reset_interrupt_counter(config)
 
 
 def _return_value(task: PregelExecutableTask) -> Any:

libs/langgraph/langgraph/pregel/main.py

@@ -4,6 +4,7 @@ import asyncio
 import concurrent
 import concurrent.futures
 import contextlib
+import logging
 import queue
 import warnings
 import weakref
@@ -19,7 +20,7 @@ from collections.abc import (
 from dataclasses import is_dataclass, replace
 from datetime import timedelta
 from functools import partial
-from inspect import isclass
+from inspect import isawaitable, isclass
 from typing import (
     Any,
     Generic,
@@ -49,8 +50,6 @@ from langgraph.checkpoint.base import (
     ChannelVersions,
     Checkpoint,
     CheckpointTuple,
-    LogPage,
-    log_range,
 )
 from langgraph.store.base import BaseStore
 from pydantic import BaseModel, TypeAdapter
@@ -112,7 +111,6 @@ from langgraph.callbacks import (
 )
 from langgraph.channels.base import BaseChannel
 from langgraph.channels.delta import DeltaChannel
-from langgraph.channels.log import Log
 from langgraph.channels.topic import Topic
 from langgraph.config import get_config
 from langgraph.constants import END
@@ -121,6 +119,7 @@ from langgraph.errors import (
     GraphDrained,
     GraphRecursionError,
     InvalidUpdateError,
+    RunCancelled,
     create_error_message,
 )
 from langgraph.managed.base import ManagedValueSpec
@@ -209,6 +208,8 @@ from langgraph.warnings import LangGraphDeprecatedSinceV10
 
 __all__ = ("NodeBuilder", "Pregel")
 
+logger = logging.getLogger(__name__)
+
 _WriteValue = Callable[[Input], Output] | Any
 
 
@@ -764,6 +765,15 @@ class Pregel(
     trigger_to_nodes: Mapping[str, Sequence[str]]
     node_error_handler_map: Mapping[str, str]
 
+    cancel_handler: Callable[[Any, Runtime], Any] | None = None
+    """Called with the latest state and the run's `Runtime` when a top-level async
+    run with a checkpointer is cancelled with a `RunCancelled` message. A non-`None`
+    return is saved as a state update before the cancellation propagates."""
+
+    cancel_timeout: float = 5.0
+    """Seconds the cancel handler may take, including the wait for the cancelled
+    run to finish saving. A handler that runs over or raises is logged and skipped."""
+
     def __init__(
         self,
         *,
@@ -788,6 +798,8 @@ class Pregel(
         config: RunnableConfig | None = None,
         trigger_to_nodes: Mapping[str, Sequence[str]] | None = None,
         node_error_handler_map: Mapping[str, str] | None = None,
+        cancel_handler: Callable[[Any, Runtime], Any] | None = None,
+        cancel_timeout: float = 5.0,
         name: str = "LangGraph",
         stream_transformers: Sequence[Callable[[tuple[str, ...]], Any]] | None = None,
         **deprecated_kwargs: Unpack[DeprecatedKwargs],
@@ -836,6 +848,8 @@ class Pregel(
         self.config = config
         self.trigger_to_nodes = trigger_to_nodes or {}
         self.node_error_handler_map = node_error_handler_map or {}
+        self.cancel_handler = cancel_handler
+        self.cancel_timeout = cancel_timeout
         self.name = name
         self.stream_transformers: tuple[Callable[[tuple[str, ...]], Any], ...] = tuple(
             stream_transformers or ()
@@ -887,20 +901,38 @@ class Pregel(
         )
 
     def _subgraph_for_namespace(
-        self, config: RunnableConfig, checkpointer: BaseCheckpointSaver
+        self,
+        config: RunnableConfig,
+        checkpointer: BaseCheckpointSaver,
+        *,
+        for_update: bool = False,
     ) -> tuple[PregelProtocol, RunnableConfig] | None:
         """The subgraph a state method's namespaced config addresses, and the
         config to call it with, lending it `checkpointer`. `None` when the
-        config is for this graph."""
+        config is for this graph, or names no subgraph this graph declares or
+        detects (such as one a tool invokes), so a read uses this graph's
+        channels.
+
+        Raises:
+            ValueError: If `for_update` and the namespace names no such
+                subgraph: this graph's nodes and channels would write the wrong
+                state into it.
+        """
         checkpoint_ns = config[CONF].get(CONFIG_KEY_CHECKPOINT_NS, "")
         if not checkpoint_ns or CONFIG_KEY_CHECKPOINTER in config[CONF]:
             return None
         recast = recast_checkpoint_ns(checkpoint_ns)
-        for _, pregel in self.get_subgraphs(namespace=recast, recurse=True):
-            return pregel, patch_configurable(
-                config, {CONFIG_KEY_CHECKPOINTER: checkpointer}
-            )
-        raise ValueError(f"Subgraph {recast} not found")
+        # Walk every subgraph rather than filter by `namespace=`: that filter
+        # matches by prefix, so for `research_review` it can yield
+        # `research|review` and skip a declared `research_review`.
+        for name, pregel in self.get_subgraphs(recurse=True):
+            if name == recast:
+                return pregel, patch_configurable(
+                    config, {CONFIG_KEY_CHECKPOINTER: checkpointer}
+                )
+        if for_update:
+            raise ValueError(f"Subgraph {recast} not found")
+        return None
 
     def _apply_checkpointer_allowlist(
         self, checkpointer: BaseCheckpointSaver | None
@@ -1248,7 +1280,6 @@ class Pregel(
             saved.checkpoint,
             saver=saver,
             config=saved.config,
-            load_logs=False,
         )
         # tasks for this checkpoint
         next_tasks = prepare_next_tasks(
@@ -1374,7 +1405,6 @@ class Pregel(
             saved.checkpoint,
             saver=saver,
             config=saved.config,
-            load_logs=False,
         )
         # tasks for this checkpoint
         next_tasks = prepare_next_tasks(
@@ -1487,97 +1517,6 @@ class Pregel(
             live=CONFIG_KEY_CHECKPOINT_ID not in config[CONF],
         )
 
-    def read_log(
-        self,
-        config: RunnableConfig,
-        channel: str,
-        *,
-        after: int | None = None,
-        before: int | None = None,
-        limit: int | None = None,
-    ) -> LogPage:
-        """Read a log channel as of a checkpoint (prototype).
-
-        The same operation as `BaseCheckpointSaver.read_log`, with entries
-        decoded by the channel (messages for a `MessagesLog`).
-        """
-        checkpointer = self._state_checkpointer(config)
-        if subgraph := self._subgraph_for_namespace(config, checkpointer):
-            pregel, subgraph_config = subgraph
-            return pregel.read_log(  # type: ignore[attr-defined]
-                subgraph_config, channel, after=after, before=before, limit=limit
-            )
-        config = merge_configs(self.config, config) if self.config else config
-        config = self._own_checkpoint_config(config)
-        page = checkpointer.read_log(
-            config, channel, after=after, before=before, limit=limit
-        )
-        if page.length == 0 and (tup := checkpointer.get_tuple(config)) is not None:
-            if (
-                pre := self._pre_log_page(channel, tup, after, before, limit)
-            ) is not None:
-                return pre
-        return self._decode_log_page(channel, page)
-
-    async def aread_log(
-        self,
-        config: RunnableConfig,
-        channel: str,
-        *,
-        after: int | None = None,
-        before: int | None = None,
-        limit: int | None = None,
-    ) -> LogPage:
-        """Async version of `read_log`."""
-        checkpointer = self._state_checkpointer(config)
-        if subgraph := self._subgraph_for_namespace(config, checkpointer):
-            pregel, subgraph_config = subgraph
-            return await pregel.aread_log(  # type: ignore[attr-defined]
-                subgraph_config, channel, after=after, before=before, limit=limit
-            )
-        config = merge_configs(self.config, config) if self.config else config
-        config = self._own_checkpoint_config(config)
-        page = await checkpointer.aread_log(
-            config, channel, after=after, before=before, limit=limit
-        )
-        if (
-            page.length == 0
-            and (tup := await checkpointer.aget_tuple(config)) is not None
-        ):
-            if (
-                pre := self._pre_log_page(channel, tup, after, before, limit)
-            ) is not None:
-                return pre
-        return self._decode_log_page(channel, page)
-
-    def _pre_log_page(
-        self,
-        channel: str,
-        tup: CheckpointTuple,
-        after: int | None,
-        before: int | None,
-        limit: int | None,
-    ) -> LogPage | None:
-        """A page of the list a checkpoint stored before the field became a
-        log channel, or `None` if it stored none."""
-        spec = self.channels.get(channel)
-        stored = tup.checkpoint["channel_values"].get(channel)
-        if not isinstance(spec, Log) or not isinstance(stored, list):
-            return None
-        entries = spec.from_checkpoint(stored).entries
-        lo, hi = log_range(len(entries), after, before, limit)
-        return LogPage([(i, entries[i]) for i in range(lo, hi)], len(entries), [])
-
-    def _decode_log_page(self, channel: str, page: LogPage) -> LogPage:
-        spec = self.channels.get(channel)
-        if not isinstance(spec, Log):
-            raise ValueError(f"Channel {channel!r} is not a log channel")
-        return LogPage(
-            [(pos, spec.decode(e)) for pos, e in page.entries],
-            page.length,
-            [spec.decode(e) for e in page.pending],
-        )
-
     async def aget_state(
         self, config: RunnableConfig, *, subgraphs: bool = False
     ) -> StateSnapshot:
@@ -1737,7 +1676,9 @@ class Pregel(
         if any(len(u) == 0 for u in supersteps):
             raise ValueError("No updates provided")
 
-        if subgraph := self._subgraph_for_namespace(config, checkpointer):
+        if subgraph := self._subgraph_for_namespace(
+            config, checkpointer, for_update=True
+        ):
             pregel, subgraph_config = subgraph
             return pregel.bulk_update_state(subgraph_config, supersteps)
 
@@ -2238,7 +2179,9 @@ class Pregel(
         if any(len(u) == 0 for u in supersteps):
             raise ValueError("No updates provided")
 
-        if subgraph := self._subgraph_for_namespace(config, checkpointer):
+        if subgraph := self._subgraph_for_namespace(
+            config, checkpointer, for_update=True
+        ):
             pregel, subgraph_config = subgraph
             return await pregel.abulk_update_state(subgraph_config, supersteps)
 
@@ -3351,6 +3294,7 @@ class Pregel(
 
         config = ensure_config(self.config, config)
         run_manager = None
+        checkpointer = None
         try:
             # assign defaults
             (
@@ -3683,8 +3627,68 @@ class Pregel(
         except BaseException as e:
             if run_manager is not None:
                 await asyncio.shield(run_manager.on_chain_error(e))
+            if isinstance(e, asyncio.CancelledError):
+                await self._arun_cancel_handler(e, config, checkpointer)
             raise
 
+    async def _arun_cancel_handler(
+        self,
+        exc: asyncio.CancelledError,
+        config: RunnableConfig,
+        checkpointer: BaseCheckpointSaver | None,
+    ) -> None:
+        """Give the graph one bounded state update after its run is cancelled."""
+        handler = self.cancel_handler
+        reason = exc.args[0] if exc.args else None
+        # A nested graph's parent owns the cancel; without a checkpointer nothing was saved.
+        if (
+            handler is None
+            or checkpointer is None
+            or CONFIG_KEY_TASK_ID in config[CONF]
+            or not isinstance(reason, RunCancelled)
+            or not reason.run_cancel_handler
+        ):
+            return
+        runtime = config[CONF].get(CONFIG_KEY_RUNTIME, DEFAULT_RUNTIME)
+        latest = {
+            **config,
+            CONF: {
+                k: v for k, v in config[CONF].items() if k != CONFIG_KEY_CHECKPOINT_ID
+            },
+        }
+
+        async def run() -> None:
+            # The cancel can cut short the loop's exit, which saves the last checkpoint.
+            for arg in exc.args:
+                if isinstance(arg, asyncio.Task):
+                    with contextlib.suppress(BaseException):
+                        await arg
+            state = await self.aget_state(latest)
+            update = handler(state.values, runtime)
+            if isawaitable(update):
+                update = await update
+            if update is not None:
+                # Save the update as the cancelled task's result.
+                unfinished = [t for t in state.tasks if t.result is None]
+                if len({t.name for t in unfinished}) == 1:
+                    await self.aupdate_state(
+                        state.config, update, unfinished[0].name, unfinished[0].id
+                    )
+                else:
+                    await self.aupdate_state(state.config, update)
+
+        task = asyncio.create_task(run())
+        try:
+            done, _ = await asyncio.wait({task}, timeout=self.cancel_timeout)
+        except asyncio.CancelledError:
+            task.cancel()
+            raise
+        if not done:
+            task.cancel()
+            logger.warning("Cancel handler timed out after %ss", self.cancel_timeout)
+        elif (err := task.exception()) is not None:
+            logger.error("Cancel handler failed", exc_info=err)
+
     @beta(message="The v3 streaming protocol on Pregel is experimental.")
     def _pregel_stream_v3(
         self,

libs/langgraph/langgraph/pregel/remote.py

@@ -50,6 +50,7 @@ from langgraph._internal._constants import (
     CONFIG_KEY_CHECKPOINT_MAP,
     CONFIG_KEY_CHECKPOINT_NS,
     CONFIG_KEY_STREAM,
+    CONFIG_KEY_STRICT_RESUME,
     CONFIG_KEY_TASK_ID,
     INTERRUPT,
     NS_SEP,
@@ -81,6 +82,7 @@ _CONF_DROPLIST = frozenset(
         CONFIG_KEY_CHECKPOINT_ID,
         CONFIG_KEY_CHECKPOINT_NS,
         CONFIG_KEY_TASK_ID,
+        CONFIG_KEY_STRICT_RESUME,
     ),
 )
 

libs/langgraph/langgraph/types.py

@@ -33,6 +33,7 @@ from xxhash import xxh3_128_hexdigest
 
 from langgraph._internal._cache import default_cache_key
 from langgraph._internal._constants import INTERRUPT as _INTERRUPT_KEY
+from langgraph._internal._constants import NS_SEP
 from langgraph._internal._fields import get_cached_annotated_keys, get_update_as_tuples
 from langgraph._internal._retry import default_retry_on
 from langgraph._internal._typing import MISSING, DeprecatedKwargs
@@ -579,6 +580,15 @@ def omit_payload(_value: Any) -> dict[str, Any]:
 _DEFAULT_INTERRUPT_ID = "placeholder-id"
 
 
+def _interrupt_id(ns: str, answered: int) -> str:
+    # Keyed by how many answers the task already has, the slot this interrupt's
+    # answer fills; call order isn't stable across parallel calls in one task.
+    # With none it's the bare namespace hash older versions gave every
+    # interrupt, so saved ids still match. The suffix can't form another task's
+    # namespace, whose segments all contain ":".
+    return xxh3_128_hexdigest((f"{ns}{NS_SEP}{answered}" if answered else ns).encode())
+
+
 @final
 @dataclass(init=False, slots=True)
 class Interrupt(Generic[ResponseT]):
@@ -641,7 +651,7 @@ class Interrupt(Generic[ResponseT]):
     ) -> Interrupt[ResponseT]:
         return cls(
             value=value,
-            id=xxh3_128_hexdigest(ns.encode()),
+            id=_interrupt_id(ns, 0),
             response_schema=response_schema,
         )
 
@@ -1037,9 +1047,11 @@ def interrupt(
     # no resume value found
     raise GraphInterrupt(
         (
-            Interrupt.from_ns(
+            Interrupt(
                 value=value,
-                ns=conf[CONFIG_KEY_CHECKPOINT_NS],
+                id=_interrupt_id(
+                    conf[CONFIG_KEY_CHECKPOINT_NS], len(scratchpad.resume)
+                ),
                 response_schema=adapter.json_schema() if adapter else response_schema,
             ),
         )

libs/langgraph/langgraph/warnings.py

@@ -7,7 +7,6 @@ __all__ = (
     "LangGraphDeprecatedSinceV05",
     "LangGraphDeprecatedSinceV10",
     "LangGraphDeprecatedSinceV11",
-    "LangGraphDeprecatedSinceV13",
 )
 
 
@@ -68,10 +67,3 @@ class LangGraphDeprecatedSinceV11(LangGraphDeprecationWarning):
 
     def __init__(self, message: str, *args: object) -> None:
         super().__init__(message, *args, since=(1, 1), expected_removal=(3, 0))
-
-
-class LangGraphDeprecatedSinceV13(LangGraphDeprecationWarning):
-    """A specific `LangGraphDeprecationWarning` subclass defining functionality deprecated since LangGraph v1.3.0"""
-
-    def __init__(self, message: str, *args: object) -> None:
-        super().__init__(message, *args, since=(1, 3), expected_removal=(2, 0))

libs/langgraph/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "langgraph"
-version = "1.2.19"
+version = "1.2.20"
 description = "Building stateful, multi-actor applications with LLMs"
 authors = []
 requires-python = ">=3.10"

libs/langgraph/tests/test_cancel_handler.py

@@ -0,0 +1,246 @@
+import asyncio
+import logging
+import operator
+import sys
+from typing import Annotated, Any
+
+import pytest
+from langgraph.checkpoint.memory import InMemorySaver
+from typing_extensions import TypedDict
+
+from langgraph.errors import RunCancelled
+from langgraph.graph import START, StateGraph
+from langgraph.runtime import Runtime
+
+pytestmark = [
+    pytest.mark.anyio,
+    pytest.mark.skipif(
+        sys.version_info < (3, 11), reason="cancel messages propagate from Python 3.11"
+    ),
+]
+
+
+class State(TypedDict):
+    log: Annotated[list[str], operator.add]
+
+
+async def _call(state: State) -> dict[str, Any]:
+    return {"log": ["call"]}
+
+
+async def _slow_tool(state: State) -> dict[str, Any]:
+    await asyncio.sleep(10)
+    return {"log": ["result"]}
+
+
+def _builder() -> StateGraph:
+    return (
+        StateGraph(State)
+        .add_node("call", _call)
+        .add_node("tool", _slow_tool)
+        .add_edge(START, "call")
+        .add_edge("call", "tool")
+    )
+
+
+class Rollback(RunCancelled):
+    run_cancel_handler = False
+
+
+async def _cancel_mid_tool(
+    graph: Any,
+    config: dict,
+    value: list[str],
+    durability: Any = None,
+    msg: Any = RunCancelled("user stop"),
+) -> None:
+    run = asyncio.create_task(
+        graph.ainvoke({"log": value}, config, durability=durability)
+    )
+    await asyncio.sleep(0.1)
+    run.cancel(msg)
+    with pytest.raises(asyncio.CancelledError):
+        await run
+
+
+def _appends_cancelled(state: State, runtime: Runtime) -> dict[str, Any]:
+    return {"log": ["cancelled"]}
+
+
+@pytest.mark.parametrize("msg", [None, "stop", Rollback("rollback")])
+async def test_cancel_handler_skipped_without_run_cancelled(msg: Any) -> None:
+    graph = (
+        _builder()
+        .set_cancel_handler(_appends_cancelled)
+        .compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    await _cancel_mid_tool(graph, config, ["h0"], msg=msg)
+
+    state = await graph.aget_state(config)
+    assert state.values["log"] == ["h0", "call"]
+
+
+async def test_cancel_handler_skipped_on_wait_for_timeout() -> None:
+    graph = (
+        _builder()
+        .set_cancel_handler(_appends_cancelled)
+        .compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    with pytest.raises(asyncio.TimeoutError):
+        await asyncio.wait_for(graph.ainvoke({"log": ["h0"]}, config), timeout=0.1)
+
+    state = await graph.aget_state(config)
+    assert state.values["log"] == ["h0", "call"]
+
+
+@pytest.mark.parametrize("durability", ["sync", "async", "exit"])
+async def test_cancel_handler_saves_update_after_cancel(durability: str) -> None:
+    seen: list[Any] = []
+
+    def on_cancel(state: State, runtime: Runtime) -> dict[str, Any]:
+        seen.append((list(state["log"]), runtime.context))
+        return {"log": ["cancelled"]}
+
+    graph = (
+        _builder().set_cancel_handler(on_cancel).compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    await _cancel_mid_tool(graph, config, ["h0"], durability)
+
+    assert seen == [(["h0", "call"], None)]
+    state = await graph.aget_state(config)
+    assert state.values["log"] == ["h0", "call", "cancelled"]
+
+
+async def test_async_cancel_handler_and_next_run() -> None:
+    async def on_cancel(state: State, runtime: Runtime) -> dict[str, Any]:
+        await asyncio.sleep(0)
+        return {"log": ["cancelled"]}
+
+    graph = (
+        _builder().set_cancel_handler(on_cancel).compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    await _cancel_mid_tool(graph, config, ["h0"])
+    await _cancel_mid_tool(graph, config, ["h1"])
+
+    state = await graph.aget_state(config)
+    assert state.values["log"] == [
+        "h0",
+        "call",
+        "cancelled",
+        "h1",
+        "call",
+        "cancelled",
+    ]
+
+
+async def test_cancel_handler_returning_none_saves_nothing() -> None:
+    graph = (
+        _builder()
+        .set_cancel_handler(lambda state, runtime: None)
+        .compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    await _cancel_mid_tool(graph, config, ["h0"])
+
+    state = await graph.aget_state(config)
+    assert state.values["log"] == ["h0", "call"]
+
+
+async def test_cancel_handler_skipped_without_checkpointer() -> None:
+    calls: list[State] = []
+    graph = _builder().set_cancel_handler(lambda s, r: calls.append(s)).compile()
+
+    await _cancel_mid_tool(graph, {}, ["h0"])
+
+    assert calls == []
+
+
+async def test_cancel_handler_timeout_is_logged_and_skipped(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    async def on_cancel(state: State, runtime: Runtime) -> dict[str, Any]:
+        await asyncio.sleep(10)
+        return {"log": ["cancelled"]}
+
+    graph = (
+        _builder()
+        .set_cancel_handler(on_cancel, timeout=0.1)
+        .compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    with caplog.at_level(logging.WARNING):
+        await asyncio.wait_for(_cancel_mid_tool(graph, config, ["h0"]), timeout=2)
+
+    assert "Cancel handler timed out" in caplog.text
+    state = await graph.aget_state(config)
+    assert state.values["log"] == ["h0", "call"]
+
+
+async def test_cancel_handler_error_is_logged_and_cancel_propagates(
+    caplog: pytest.LogCaptureFixture,
+) -> None:
+    def on_cancel(state: State, runtime: Runtime) -> dict[str, Any]:
+        raise ValueError("boom")
+
+    graph = (
+        _builder().set_cancel_handler(on_cancel).compile(checkpointer=InMemorySaver())
+    )
+    config = {"configurable": {"thread_id": "1"}}
+
+    with caplog.at_level(logging.ERROR):
+        await _cancel_mid_tool(graph, config, ["h0"])
+
+    assert "Cancel handler failed" in caplog.text
+    state = await graph.aget_state(config)
+    assert state.values["log"] == ["h0", "call"]
+
+
+async def test_cancel_handler_not_called_on_success_or_error() -> None:
+    calls: list[State] = []
+
+    async def fails(state: State) -> dict[str, Any]:
+        raise ValueError("boom")
+
+    graph = (
+        StateGraph(State)
+        .add_node("call", _call)
+        .add_node("fails", fails)
+        .add_edge(START, "call")
+        .add_edge("call", "fails")
+        .set_cancel_handler(lambda s, r: calls.append(s))
+        .compile(checkpointer=InMemorySaver())
+    )
+
+    with pytest.raises(ValueError, match="boom"):
+        await graph.ainvoke({"log": []}, {"configurable": {"thread_id": "1"}})
+
+    assert calls == []
+
+
+async def test_subgraph_cancel_handler_defers_to_parent() -> None:
+    calls: list[str] = []
+
+    subgraph = (
+        _builder().set_cancel_handler(lambda s, r: calls.append("child")).compile()
+    )
+    graph = (
+        StateGraph(State)
+        .add_node("child", subgraph)
+        .add_edge(START, "child")
+        .set_cancel_handler(lambda s, r: calls.append("parent"))
+        .compile(checkpointer=InMemorySaver())
+    )
+
+    await _cancel_mid_tool(graph, {"configurable": {"thread_id": "1"}}, ["h0"])
+
+    assert calls == ["parent"]

libs/langgraph/tests/test_log_channel.py

@@ -1,718 +0,0 @@
-"""Transcript log prototype: append-only `Log` / `MessagesLog` channels.
-
-Every scenario runs against `InMemorySaver` (native log storage: segments,
-step rows, range reads) and `SqliteSaver` (no native support: the default
-`read_log` walks the parent chain), and both must read the same log.
-"""
-
-import operator
-import sqlite3
-import warnings
-from collections.abc import Iterator
-from typing import Annotated, Any
-
-import pytest
-from langchain_core.messages import AIMessage, HumanMessage, RemoveMessage
-from langchain_core.tools import tool
-from langgraph.checkpoint.base import BaseCheckpointSaver, LogPage
-from langgraph.checkpoint.memory import InMemorySaver
-from langgraph.checkpoint.sqlite import SqliteSaver
-from langgraph.checkpoint.sqlite.aio import AsyncSqliteSaver
-from langgraph.prebuilt import ToolNode, tools_condition
-from typing_extensions import TypedDict
-
-from langgraph.channels import Log, LogRef, MessagesLog
-from langgraph.errors import InvalidUpdateError
-from langgraph.graph import END, START, StateGraph
-from langgraph.graph.message import REMOVE_ALL_MESSAGES, add_messages
-from langgraph.types import Command, Overwrite, Send, interrupt
-from langgraph.warnings import LangGraphDeprecatedSinceV13
-
-pytestmark = pytest.mark.anyio
-
-
-@pytest.fixture(params=["memory", "sqlite"])
-def saver(request: pytest.FixtureRequest) -> Iterator[BaseCheckpointSaver]:
-    if request.param == "memory":
-        yield InMemorySaver()
-    else:
-        conn = sqlite3.connect(":memory:", check_same_thread=False)
-        yield SqliteSaver(conn)
-        conn.close()
-
-
-def contents(page: LogPage) -> list[Any]:
-    return [e.content if hasattr(e, "content") else e for _, e in page.entries]
-
-
-class ChatState(TypedDict):
-    messages: Annotated[list, MessagesLog()]
-
-
-def chat_graph(saver: BaseCheckpointSaver, **compile_kw: Any):
-    def model(state: ChatState) -> dict:
-        return {"messages": [AIMessage(f"reply to {state['messages'][-1].content}")]}
-
-    builder = StateGraph(ChatState)
-    builder.add_node("model", model)
-    builder.add_edge(START, "model")
-    builder.add_edge("model", END)
-    return builder.compile(checkpointer=saver, **compile_kw)
-
-
-def test_appends_reads_and_state_marker(saver: BaseCheckpointSaver) -> None:
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config)
-    out = graph.invoke({"messages": [HumanMessage("b")]}, config)
-
-    # nodes and invoke() see the list
-    assert [m.content for m in out["messages"]] == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-    # state reads return the marker, not the transcript
-    assert graph.get_state(config).values == {"messages": LogRef(4)}
-    # one read operation, same arguments everywhere
-    page = graph.read_log(config, "messages")
-    assert page.length == 4
-    assert contents(page) == ["a", "reply to a", "b", "reply to b"]
-    assert [p for p, _ in page.entries] == [0, 1, 2, 3]
-    assert contents(graph.read_log(config, "messages", limit=2)) == ["b", "reply to b"]
-    assert contents(graph.read_log(config, "messages", before=2, limit=1)) == [
-        "reply to a"
-    ]
-    assert contents(graph.read_log(config, "messages", after=1, limit=1)) == ["b"]
-    # the saver-level read returns JSON
-    raw = saver.read_log(config, "messages")
-    assert raw.entries[0][1]["type"] == "human"
-    # every checkpoint points at its own leaf
-    lengths = [
-        (s.metadata["source"], graph.read_log(s.config, "messages").length)
-        for s in graph.get_state_history(config)
-    ]
-    assert lengths == [
-        ("loop", 4),
-        ("loop", 3),
-        ("input", 2),
-        ("loop", 2),
-        ("loop", 1),
-        ("input", 0),
-    ]
-
-
-async def test_async_appends_and_reads() -> None:
-    async with AsyncSqliteSaver.from_conn_string(":memory:") as fallback:
-        for saver in (InMemorySaver(), fallback):
-            graph = chat_graph(saver)
-            config = {"configurable": {"thread_id": "1"}}
-            await graph.ainvoke({"messages": [HumanMessage("a")]}, config)
-            await graph.ainvoke({"messages": [HumanMessage("b")]}, config)
-            state = await graph.aget_state(config)
-            assert state.values == {"messages": LogRef(4)}
-            page = await graph.aread_log(config, "messages")
-            assert contents(page) == ["a", "reply to a", "b", "reply to b"]
-
-
-def test_log_entries_are_not_stored_in_checkpoints() -> None:
-    saver = InMemorySaver()
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    for i in range(20):
-        graph.invoke({"messages": [HumanMessage(f"m{i}")]}, config)
-    assert not [k for k in saver.blobs if k[2] == "messages"]
-    log = saver.log.logs[("1", "", "messages")]
-    stored = sum(len(rows) for rows in log.entries.values())
-    # each entry stored once: linear in the transcript
-    assert stored == 40 == graph.read_log(config, "messages").length
-    assert len(log.segments) == 1
-
-
-def test_parallel_tasks_keep_one_order(saver: BaseCheckpointSaver) -> None:
-    class State(TypedDict):
-        events: Annotated[list, Log()]
-        seen: Annotated[list, operator.add]
-
-    def fan_out(state: State) -> list[Send]:
-        return [Send("worker", {"i": i}) for i in range(5)]
-
-    def worker(arg: dict) -> dict:
-        return {"events": [{"worker": arg["i"]}, {"worker": arg["i"], "n": 2}]}
-
-    def after(state: State) -> dict:
-        return {"seen": [list(state["events"])]}
-
-    builder = StateGraph(State)
-    builder.add_node("worker", worker)
-    builder.add_node("after", after)
-    builder.add_conditional_edges(START, fan_out, ["worker"])
-    builder.add_edge("worker", "after")
-    builder.add_edge("after", END)
-    graph = builder.compile(checkpointer=saver)
-    config = {"configurable": {"thread_id": "1"}}
-    out = graph.invoke({"events": [], "seen": []}, config)
-    in_run = out["seen"][-1]
-    assert len(in_run) == 10
-    # read back after the run: the same order the run's nodes saw
-    assert contents(graph.read_log(config, "events")) == in_run
-
-
-def test_interrupt_and_resume_reuse_finished_writes(
-    saver: BaseCheckpointSaver,
-) -> None:
-    calls: list[str] = []
-
-    class State(TypedDict):
-        events: Annotated[list, Log()]
-
-    def fast(state: State) -> dict:
-        calls.append("fast")
-        return {"events": [{"from": "fast"}]}
-
-    def asks(state: State) -> dict:
-        answer = interrupt("question")
-        calls.append("asks")
-        return {"events": [{"from": "asks", "answer": answer}]}
-
-    builder = StateGraph(State)
-    builder.add_node("fast", fast)
-    builder.add_node("asks", asks)
-    builder.add_edge(START, "fast")
-    builder.add_edge(START, "asks")
-    builder.add_edge(["fast", "asks"], END)
-    graph = builder.compile(checkpointer=saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"events": [{"from": "input"}]}, config)
-    # fast finished; its entry is pending at the head, not committed
-    page = saver.read_log(config, "events")
-    assert page.length == 1
-    assert page.pending == [{"from": "fast"}]
-
-    out = graph.invoke(Command(resume="yes"), config)
-    assert calls == ["fast", "asks"]  # fast was not re-run
-    # the reused write and the new one commit as one step, in path order,
-    # and the log reads back exactly what the run's state held
-    assert out["events"] == [
-        {"from": "input"},
-        {"from": "asks", "answer": "yes"},
-        {"from": "fast"},
-    ]
-    assert contents(graph.read_log(config, "events")) == out["events"]
-    assert graph.read_log(config, "events").pending == []
-
-
-def test_time_travel_forks_without_touching_the_original(
-    saver: BaseCheckpointSaver,
-) -> None:
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config)
-    graph.invoke({"messages": [HumanMessage("b")]}, config)
-    original = graph.get_state(config).config
-    # the checkpoint before the second reply ("b" added, model not run)
-    before_reply = next(
-        s
-        for s in graph.get_state_history(config)
-        if s.next == ("model",) and graph.read_log(s.config, "messages").length == 3
-    )
-    graph.invoke(None, before_reply.config)  # replay: a new branch
-    head = graph.get_state(config).config
-    assert (
-        head["configurable"]["checkpoint_id"]
-        != original["configurable"]["checkpoint_id"]
-    )
-    assert contents(graph.read_log(head, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-    assert contents(graph.read_log(original, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-    a = graph.read_log(head, "messages").entries
-    b = graph.read_log(original, "messages").entries
-    # same prefix, different last message (a new run of the model node)
-    assert [m.id for _, m in a[:3]] == [m.id for _, m in b[:3]]
-    assert a[3][1].id != b[3][1].id
-    if isinstance(saver, InMemorySaver):
-        assert len(saver.log.logs[("1", "", "messages")].segments) == 2
-
-
-def test_update_state_fork_starts_a_branch(saver: BaseCheckpointSaver) -> None:
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config)
-    graph.invoke({"messages": [HumanMessage("b")]}, config)
-    original = graph.get_state(config).config
-    first_turn = next(
-        s
-        for s in graph.get_state_history(config)
-        if graph.read_log(s.config, "messages").length == 2
-        and s.metadata["source"] == "loop"
-    )
-    # edit: fork from the end of the first turn with a different question
-    forked = graph.update_state(
-        first_turn.config, {"messages": [HumanMessage("c")]}, as_node="model"
-    )
-    assert contents(graph.read_log(forked, "messages")) == ["a", "reply to a", "c"]
-    graph.invoke(Command(goto="model"), forked)
-    head = graph.get_state(config).config
-    assert contents(graph.read_log(head, "messages")) == [
-        "a",
-        "reply to a",
-        "c",
-        "reply to c",
-    ]
-    assert contents(graph.read_log(original, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-
-
-def test_subgraph_has_its_own_log(saver: BaseCheckpointSaver) -> None:
-    class Sub(TypedDict):
-        notes: Annotated[list, Log()]
-
-    def note(state: Sub) -> dict:
-        return {"notes": [{"n": len(state.get("notes", []))}]}
-
-    sub_builder = StateGraph(Sub)
-    sub_builder.add_node("note", note)
-    sub_builder.add_edge(START, "note")
-    sub = sub_builder.compile(checkpointer=True)
-
-    class Parent(TypedDict):
-        messages: Annotated[list, MessagesLog()]
-
-    def call_sub(state: Parent) -> dict:
-        sub.invoke({"notes": [{"from": "parent"}]})
-        return {"messages": [AIMessage("done")]}
-
-    builder = StateGraph(Parent)
-    builder.add_node("call_sub", call_sub)
-    builder.add_edge(START, "call_sub")
-    graph = builder.compile(checkpointer=saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("go")]}, config)
-    graph.invoke({"messages": [HumanMessage("again")]}, config)
-    assert contents(graph.read_log(config, "messages")) == [
-        "go",
-        "done",
-        "again",
-        "done",
-    ]
-    sub_config = {"configurable": {"thread_id": "1", "checkpoint_ns": "call_sub"}}
-    assert contents(saver.read_log(sub_config, "notes")) == [
-        {"from": "parent"},
-        {"n": 1},
-        {"from": "parent"},
-        {"n": 3},
-    ]
-
-
-def test_exit_durability_commits_inline(saver: BaseCheckpointSaver) -> None:
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config, durability="exit")
-    graph.invoke({"messages": [HumanMessage("b")]}, config, durability="exit")
-    assert contents(graph.read_log(config, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-
-
-def test_prune_keeps_the_heads_transcript() -> None:
-    saver = InMemorySaver()
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config)
-    graph.invoke({"messages": [HumanMessage("b")]}, config)
-    original = graph.get_state(config).config
-    before_reply = next(
-        s
-        for s in graph.get_state_history(config)
-        if s.next == ("model",) and graph.read_log(s.config, "messages").length == 3
-    )
-    graph.invoke(None, before_reply.config)
-    log = saver.log.logs[("1", "", "messages")]
-    assert len(log.segments) == 2
-
-    saver.prune(["1"], strategy="keep_latest")
-    assert len(saver.storage["1"][""]) == 1
-    # the head's full transcript survives without its ancestors' checkpoints
-    assert contents(graph.read_log(config, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-    # the abandoned branch is collected
-    log = saver.log.logs[("1", "", "messages")]
-    assert sum(len(r) for r in log.entries.values()) == 4
-    assert len(log.steps) == 4
-    assert graph.read_log(original, "messages").length == 0  # its checkpoint is gone
-
-    # the thread keeps working after prune
-    graph.invoke({"messages": [HumanMessage("c")]}, config)
-    assert graph.read_log(config, "messages").length == 6
-
-    saver.prune(["1"], strategy="delete")
-    assert ("1", "", "messages") not in saver.log.logs
-
-
-def test_rollback_collects_the_runs_entries() -> None:
-    saver = InMemorySaver()
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke(
-        {"messages": [HumanMessage("a")]}, {**config, "metadata": {"run_id": "r1"}}
-    )
-    graph.invoke(
-        {"messages": [HumanMessage("b")]}, {**config, "metadata": {"run_id": "r2"}}
-    )
-    saver.delete_for_runs(["r2"])
-    assert contents(graph.read_log(config, "messages")) == ["a", "reply to a"]
-    log = saver.log.logs[("1", "", "messages")]
-    assert sum(len(r) for r in log.entries.values()) == 2
-    # the tip moved back: the next run continues the same segment
-    graph.invoke({"messages": [HumanMessage("c")]}, config)
-    assert contents(graph.read_log(config, "messages")) == [
-        "a",
-        "reply to a",
-        "c",
-        "reply to c",
-    ]
-    assert len(saver.log.logs[("1", "", "messages")].segments) == 1
-
-
-def test_copy_and_delete_thread() -> None:
-    saver = InMemorySaver()
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config)
-    saver.copy_thread("1", "2")
-    copy_config = {"configurable": {"thread_id": "2"}}
-    graph.invoke({"messages": [HumanMessage("b")]}, copy_config)
-    assert contents(graph.read_log(config, "messages")) == ["a", "reply to a"]
-    assert contents(graph.read_log(copy_config, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-    saver.delete_thread("1")
-    assert ("1", "", "messages") not in saver.log.logs
-    assert graph.read_log(copy_config, "messages").length == 4
-
-
-def test_log_takes_only_json(saver: BaseCheckpointSaver) -> None:
-    class State(TypedDict):
-        events: Annotated[list, Log()]
-
-    def bad(state: State) -> dict:
-        return {"events": [{"when": object()}]}
-
-    builder = StateGraph(State)
-    builder.add_node("bad", bad)
-    builder.add_edge(START, "bad")
-    graph = builder.compile(checkpointer=saver)
-    with pytest.raises(InvalidUpdateError, match="not JSON"):
-        graph.invoke({"events": [{"ok": 1}]}, {"configurable": {"thread_id": "1"}})
-    with pytest.raises(InvalidUpdateError, match="not JSON"):
-        graph.invoke({"events": [float("nan")]}, {"configurable": {"thread_id": "2"}})
-
-
-@pytest.mark.parametrize(
-    "write",
-    [
-        pytest.param(lambda s: [RemoveMessage(id=s["messages"][0].id)], id="remove"),
-        pytest.param(lambda s: Overwrite([AIMessage("x")]), id="overwrite"),
-        pytest.param(lambda s: [s["messages"][0]], id="replace-by-id"),
-        pytest.param(lambda s: s["messages"] + [AIMessage("x")], id="whole-list"),
-    ],
-)
-def test_messages_log_rejects_edits(saver: BaseCheckpointSaver, write: Any) -> None:
-    def edits(state: ChatState) -> dict:
-        return {"messages": write(state)}
-
-    builder = StateGraph(ChatState)
-    builder.add_node("edits", edits)
-    builder.add_edge(START, "edits")
-    graph = builder.compile(checkpointer=saver)
-    with pytest.raises(InvalidUpdateError):
-        graph.invoke(
-            {"messages": [HumanMessage("a")]}, {"configurable": {"thread_id": "1"}}
-        )
-
-
-def test_fallback_and_native_read_the_same_log() -> None:
-    def run(saver: BaseCheckpointSaver) -> list[list[Any]]:
-        graph = chat_graph(saver)
-        config = {"configurable": {"thread_id": "1"}}
-        for q in "abc":
-            graph.invoke({"messages": [HumanMessage(q)]}, config)
-        return [
-            contents(graph.read_log(s.config, "messages"))
-            for s in graph.get_state_history(config)
-        ]
-
-    conn = sqlite3.connect(":memory:", check_same_thread=False)
-    try:
-        assert run(InMemorySaver()) == run(SqliteSaver(conn))
-    finally:
-        conn.close()
-
-
-def test_resume_at_a_superseded_checkpoint_branches(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """A resume at a checkpoint the thread moved past re-runs finished tasks on
-    that same checkpoint, without a fork checkpoint. The log puts the re-run
-    in a new segment and leaves the original branch alone."""
-    calls: list[str] = []
-
-    class State(TypedDict):
-        events: Annotated[list, Log()]
-
-    def fast(state: State) -> dict:
-        calls.append("fast")
-        return {"events": [{"from": "fast", "run": len(calls)}]}
-
-    def asks(state: State) -> dict:
-        answer = interrupt("question")
-        return {"events": [{"from": "asks", "answer": answer}]}
-
-    builder = StateGraph(State)
-    builder.add_node("fast", fast)
-    builder.add_node("asks", asks)
-    builder.add_edge(START, "fast")
-    builder.add_edge(START, "asks")
-    builder.add_edge(["fast", "asks"], END)
-    graph = builder.compile(checkpointer=saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"events": [{"from": "input"}]}, config)
-    interrupted = graph.get_state(config).config
-    first = graph.invoke(Command(resume="yes"), config)["events"]
-    original_head = graph.get_state(config).config
-
-    second = graph.invoke(Command(resume="no"), interrupted)["events"]
-    assert calls == ["fast", "fast"]  # the finished task re-ran
-    new_head = graph.get_state(config).config
-    assert contents(graph.read_log(new_head, "events")) == second
-    assert contents(graph.read_log(original_head, "events")) == first
-    assert first != second
-    if isinstance(saver, InMemorySaver):
-        assert len(saver.log.logs[("1", "", "events")].segments) == 2
-
-
-def test_tool_calling_agent_runs_on_a_messages_log(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """Prebuilt `ToolNode` and `tools_condition` work unchanged: they read the
-    list and append messages."""
-
-    @tool
-    def add(a: int, b: int) -> int:
-        """Add two numbers."""
-        return a + b
-
-    def model(state: ChatState) -> dict:
-        last = state["messages"][-1]
-        if isinstance(last, HumanMessage):
-            call = {
-                "name": "add",
-                "args": {"a": 2, "b": 3},
-                "id": f"call-{len(state['messages'])}",
-            }
-            return {"messages": [AIMessage("", tool_calls=[call])]}
-        return {"messages": [AIMessage(f"the answer is {last.content}")]}
-
-    builder = StateGraph(ChatState)
-    builder.add_node("model", model)
-    builder.add_node("tools", ToolNode([add]))
-    builder.add_edge(START, "model")
-    builder.add_conditional_edges("model", tools_condition)
-    builder.add_edge("tools", "model")
-    graph = builder.compile(checkpointer=saver)
-    config = {"configurable": {"thread_id": "1"}}
-    out = graph.invoke({"messages": [HumanMessage("2+3?")]}, config)
-    assert [type(m).__name__ for m in out["messages"]] == [
-        "HumanMessage",
-        "AIMessage",
-        "ToolMessage",
-        "AIMessage",
-    ]
-    page = graph.read_log(config, "messages")
-    assert [m.id for _, m in page.entries] == [m.id for m in out["messages"]]
-    assert page.entries[-1][1].content == "the answer is 5"
-
-
-def test_input_after_update_state_reads_the_inline_step(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """`update_state` commits its entries inline; the input checkpoint after
-    it keeps the version with a stripped marker, and reads must still find
-    the entries on the checkpoint that committed them."""
-    graph = chat_graph(saver)
-    config = {"configurable": {"thread_id": "1"}}
-    graph.invoke({"messages": [HumanMessage("a")]}, config)
-    graph.update_state(config, {"messages": [HumanMessage("note")]})
-    graph.invoke({"messages": [HumanMessage("b")]}, config)
-    assert contents(graph.read_log(config, "messages")) == [
-        "a",
-        "reply to a",
-        "note",
-        "b",
-        "reply to b",
-    ]
-
-
-# -- existing `add_messages` threads ------------------------------------------
-
-
-class OldChatState(TypedDict):
-    messages: Annotated[list, add_messages]
-
-
-def _reply(state: dict) -> dict:
-    return {"messages": [AIMessage(f"reply to {state['messages'][-1].content}")]}
-
-
-def _chat(schema: type, saver: BaseCheckpointSaver, **nodes: Any):
-    builder = StateGraph(schema)
-    builder.add_node("model", nodes.get("model", _reply))
-    builder.add_edge(START, "model")
-    if "review" in nodes:
-        builder.add_node("review", nodes["review"])
-        builder.add_edge("model", "review")
-        builder.add_edge("review", END)
-    else:
-        builder.add_edge("model", END)
-    return builder.compile(checkpointer=saver)
-
-
-def test_add_messages_thread_switches_to_messages_log(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """A thread written with `add_messages` keeps working on `MessagesLog`:
-    the stored list is the log's first entries."""
-    config = {"configurable": {"thread_id": "1"}}
-    old = _chat(OldChatState, saver)
-    old.invoke({"messages": [HumanMessage("a", id="h1")]}, config)
-    old.invoke({"messages": [HumanMessage("b", id="h2")]}, config)
-    before_switch = old.get_state(config).config
-
-    new = _chat(ChatState, saver)
-    out = new.invoke({"messages": [HumanMessage("c", id="h3")]}, config)
-    assert [m.content for m in out["messages"]] == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-        "c",
-        "reply to c",
-    ]
-    assert new.get_state(config).values == {"messages": LogRef(6)}
-    page = new.read_log(config, "messages")
-    assert [p for p, _ in page.entries] == list(range(6))
-    assert contents(page) == [m.content for m in out["messages"]]
-    assert [m.id for _, m in page.entries][:1] == ["h1"]
-    # checkpoints from before the switch still read as the list they stored
-    assert contents(new.read_log(before_switch, "messages")) == [
-        "a",
-        "reply to a",
-        "b",
-        "reply to b",
-    ]
-    assert len(new.get_state(before_switch).values["messages"]) == 4
-    # the next turn appends after the seed
-    new.invoke({"messages": [HumanMessage("d")]}, config)
-    assert new.read_log(config, "messages").length == 8
-    if isinstance(saver, InMemorySaver):
-        log = saver.log.logs[("1", "", "messages")]
-        assert sum(len(rows) for rows in log.entries.values()) == 8
-
-
-def test_switch_with_an_interrupted_add_messages_run(
-    saver: BaseCheckpointSaver,
-) -> None:
-    """The first checkpoint after the switch can come from the loop (a
-    resume), not graph input; the seed is committed with it."""
-
-    def review(state: dict) -> dict:
-        answer = interrupt("approve?")
-        return {"messages": [AIMessage(f"review: {answer}")]}
-
-    config = {"configurable": {"thread_id": "1"}}
-    old = _chat(OldChatState, saver, review=review)
-    old.invoke({"messages": [HumanMessage("a")]}, config)
-    assert old.get_state(config).next == ("review",)
-
-    new = _chat(ChatState, saver, review=review)
-    out = new.invoke(Command(resume="ok"), config)
-    assert [m.content for m in out["messages"]] == ["a", "reply to a", "review: ok"]
-    assert contents(new.read_log(config, "messages")) == [
-        "a",
-        "reply to a",
-        "review: ok",
-    ]
-
-
-def test_switch_then_update_state(saver: BaseCheckpointSaver) -> None:
-    config = {"configurable": {"thread_id": "1"}}
-    old = _chat(OldChatState, saver)
-    old.invoke({"messages": [HumanMessage("a")]}, config)
-    new = _chat(ChatState, saver)
-    new.update_state(config, {"messages": [HumanMessage("note")]})
-    assert contents(new.read_log(config, "messages")) == ["a", "reply to a", "note"]
-    out = new.invoke({"messages": [HumanMessage("b")]}, config)
-    assert [m.content for m in out["messages"]][-2:] == ["b", "reply to b"]
-    assert new.read_log(config, "messages").length == 5
-
-
-# -- deprecation of message edit ops on `add_messages` -------------------------
-
-
-@pytest.mark.parametrize(
-    "edit",
-    [
-        pytest.param(lambda s: [RemoveMessage(id=s["messages"][0].id)], id="remove"),
-        pytest.param(
-            lambda s: [RemoveMessage(id=REMOVE_ALL_MESSAGES), AIMessage("x")],
-            id="remove-all",
-        ),
-        pytest.param(
-            lambda s: [HumanMessage("edited", id=s["messages"][0].id)],
-            id="replace-by-id",
-        ),
-        pytest.param(lambda s: Overwrite([AIMessage("x")]), id="overwrite"),
-    ],
-)
-def test_add_messages_edit_ops_are_deprecated(edit: Any) -> None:
-    def node(state: dict) -> dict:
-        return {"messages": edit(state)}
-
-    graph = _chat(OldChatState, InMemorySaver(), model=node)
-    with pytest.warns(LangGraphDeprecatedSinceV13, match="MessagesLog"):
-        graph.invoke(
-            {"messages": [HumanMessage("a")]}, {"configurable": {"thread_id": "1"}}
-        )
-
-
-def test_add_messages_appends_are_not_deprecated() -> None:
-    graph = _chat(OldChatState, InMemorySaver())
-    with warnings.catch_warnings():
-        warnings.simplefilter("error", LangGraphDeprecatedSinceV13)
-        graph.invoke(
-            {"messages": [HumanMessage("a")]}, {"configurable": {"thread_id": "1"}}
-        )

libs/langgraph/tests/test_remote_graph.py

@@ -16,7 +16,7 @@ from langgraph_sdk.schema import StreamPart
 from pydantic import BaseModel
 from typing_extensions import TypedDict
 
-from langgraph._internal._constants import CONFIG_KEY_STREAM
+from langgraph._internal._constants import CONFIG_KEY_STREAM, CONFIG_KEY_STRICT_RESUME
 from langgraph.errors import GraphInterrupt
 from langgraph.graph import END, START, MessagesState, StateGraph, add_messages
 from langgraph.pregel import Pregel
@@ -1360,6 +1360,7 @@ def test_sanitize_config():
             "checkpoint_map": {"key": "value"},  # Should be dropped
             "checkpoint_id": "123",  # Should be dropped
             "checkpoint_ns": "ns",  # Should be dropped
+            CONFIG_KEY_STRICT_RESUME: True,  # Should be dropped
         }
     }
     sanitized = remote._sanitize_config(config_with_drops)

libs/langgraph/tests/test_strict_resume.py

@@ -0,0 +1,423 @@
+import operator
+import sys
+import uuid
+from typing import Annotated
+
+import pytest
+from langchain_core.runnables import RunnableConfig
+from langchain_core.runnables.config import get_executor_for_config
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from typing_extensions import TypedDict
+from xxhash import xxh3_128_hexdigest
+
+from langgraph._internal._constants import CONFIG_KEY_STRICT_RESUME, INTERRUPT
+from langgraph.errors import UnknownInterruptError
+from langgraph.graph import START, StateGraph
+from langgraph.graph.state import CompiledStateGraph
+from langgraph.types import Command, Durability, Interrupt, RetryPolicy, interrupt
+
+pytestmark = pytest.mark.anyio
+NEEDS_CONTEXTVARS = pytest.mark.skipif(
+    sys.version_info < (3, 11),
+    reason="Python 3.11+ is required for async contextvars support",
+)
+
+UNKNOWN_ID = "0" * 32
+
+
+class State(TypedDict, total=False):
+    log: Annotated[list[str], operator.add]
+
+
+def _config(*, strict: bool = True) -> RunnableConfig:
+    return {
+        "configurable": {
+            "thread_id": str(uuid.uuid4()),
+            CONFIG_KEY_STRICT_RESUME: strict,
+        }
+    }
+
+
+def _parallel(checkpointer: BaseCheckpointSaver) -> CompiledStateGraph:
+    def a(state: State):
+        return {"log": [f"a:{interrupt('a?')}"]}
+
+    def b(state: State):
+        return {"log": [f"b:{interrupt('b?')}"]}
+
+    return (
+        StateGraph(State)
+        .add_node("a", a)
+        .add_node("b", b)
+        .add_edge(START, "a")
+        .add_edge(START, "b")
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _ask_twice(checkpointer: BaseCheckpointSaver) -> CompiledStateGraph:
+    def ask_twice(state: State):
+        first = interrupt("first?")
+        second = interrupt("second?")
+        return {"log": [f"{first},{second}"]}
+
+    return (
+        StateGraph(State)
+        .add_node("ask", ask_twice)
+        .add_edge(START, "ask")
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _ask_then_fail_once(checkpointer: BaseCheckpointSaver) -> CompiledStateGraph:
+    failures = [ConnectionError("flaky api")]
+
+    def ask(state: State):
+        answer = interrupt("delete a.txt?")
+        if failures:
+            raise failures.pop()
+        return {"log": [answer]}
+
+    return (
+        StateGraph(State)
+        .add_node(
+            "ask", ask, retry_policy=RetryPolicy(initial_interval=0, jitter=False)
+        )
+        .add_edge(START, "ask")
+        .compile(checkpointer=checkpointer)
+    )
+
+
+def _pending_ids(graph: CompiledStateGraph, config: RunnableConfig) -> dict[str, str]:
+    return {i.value: i.id for i in graph.get_state(config).interrupts}
+
+
+def test_unknown_id_is_refused_before_anything_is_written(
+    sync_checkpointer: BaseCheckpointSaver, durability: Durability
+) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config, durability=durability)
+    before = graph.get_state(config)
+    checkpoints = len(list(sync_checkpointer.list(config)))
+    ids = _pending_ids(graph, config)
+
+    with pytest.raises(
+        UnknownInterruptError,
+        match=f"Unknown or already-consumed interrupt: {UNKNOWN_ID}",
+    ) as refused:
+        graph.invoke(Command(resume={UNKNOWN_ID: "x"}), config, durability=durability)
+
+    assert (
+        refused.value.reason,
+        refused.value.interrupt_ids,
+        refused.value.pending_ids,
+    ) == ("not_pending", (UNKNOWN_ID,), tuple(sorted(ids.values())))
+    after = graph.get_state(config)
+    assert len(list(sync_checkpointer.list(config))) == checkpoints
+    assert (after.values, after.next, after.interrupts) == (
+        before.values,
+        before.next,
+        before.interrupts,
+    )
+    result = graph.invoke(
+        Command(resume={ids["a?"]: "yes", ids["b?"]: "no"}),
+        config,
+        durability=durability,
+    )
+    assert sorted(result["log"]) == ["a:yes", "b:no"]
+
+
+def test_an_answered_id_is_refused(sync_checkpointer: BaseCheckpointSaver) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    ids = _pending_ids(graph, config)
+    graph.invoke(Command(resume={ids["a?"]: "yes"}), config)
+
+    with pytest.raises(UnknownInterruptError, match=ids["a?"]) as refused:
+        graph.invoke(Command(resume={ids["a?"]: "again"}), config)
+
+    assert (
+        refused.value.reason,
+        refused.value.interrupt_ids,
+        refused.value.pending_ids,
+    ) == ("not_pending", (ids["a?"],), (ids["b?"],))
+
+    result = graph.invoke(Command(resume={ids["b?"]: "no"}), config)
+    assert sorted(result["log"]) == ["a:yes", "b:no"]
+
+
+def test_an_empty_map_is_refused(sync_checkpointer: BaseCheckpointSaver) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+
+    with pytest.raises(UnknownInterruptError, match="names no interrupt") as refused:
+        graph.invoke(Command(resume={}), config)
+
+    assert (
+        refused.value.reason,
+        refused.value.interrupt_ids,
+        refused.value.pending_ids,
+    ) == ("empty_map", (), tuple(sorted(_pending_ids(graph, config).values())))
+
+
+def test_one_value_is_refused_while_several_are_pending(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+
+    with pytest.raises(
+        UnknownInterruptError, match="multiple pending interrupts"
+    ) as refused:
+        graph.invoke(Command(resume="yes"), config)
+
+    ids = _pending_ids(graph, config)
+    assert (refused.value.reason, refused.value.pending_ids) == (
+        "ambiguous",
+        tuple(sorted(ids.values())),
+    )
+    graph.invoke(Command(resume={ids["a?"]: "yes"}), config)
+    result = graph.invoke(Command(resume="no"), config)
+    assert sorted(result["log"]) == ["a:yes", "b:no"]
+
+
+def test_one_value_resumes_a_static_breakpoint(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = (
+        StateGraph(State)
+        .add_node("a", lambda state: {"log": ["a"]})
+        .add_edge(START, "a")
+        .compile(checkpointer=sync_checkpointer, interrupt_before=["a"])
+    )
+    config = _config()
+    graph.invoke({"log": []}, config)
+
+    with pytest.raises(UnknownInterruptError, match=UNKNOWN_ID):
+        graph.invoke(Command(resume={UNKNOWN_ID: "x"}), config)
+
+    assert graph.invoke(Command(resume="go"), config) == {"log": ["a"]}
+
+
+def test_without_strict_mode_nothing_changes(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config(strict=False)
+    graph.invoke({"log": []}, config)
+
+    graph.invoke(Command(resume={UNKNOWN_ID: "x"}), config)
+    assert set(_pending_ids(graph, config)) == {"a?", "b?"}
+    with pytest.raises(RuntimeError, match="multiple pending interrupts"):
+        graph.invoke(Command(resume="yes"), config)
+
+
+def test_a_subgraph_interrupt_is_answered_by_its_id(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    def ask(state: State):
+        return {"log": [f"asked:{interrupt('sub?')}"]}
+
+    subgraph = StateGraph(State).add_node("ask", ask).add_edge(START, "ask").compile()
+    graph = (
+        StateGraph(State)
+        .add_node("sub", subgraph)
+        .add_edge(START, "sub")
+        .compile(checkpointer=sync_checkpointer)
+    )
+    config = _config()
+    graph.invoke({"log": []}, config)
+
+    result = graph.invoke(
+        Command(resume={_pending_ids(graph, config)["sub?"]: "yes"}), config
+    )
+    assert result["log"] == ["asked:yes"]
+
+
+def test_a_second_interrupt_in_one_node_gets_its_own_id(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _ask_twice(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    state = graph.get_state(config)
+    (card,) = state.interrupts
+    assert card.id == xxh3_128_hexdigest(f"ask:{state.tasks[0].id}".encode())
+    graph.invoke(Command(resume={card.id: "1"}), config)
+    (second,) = graph.get_state(config).interrupts
+    assert second.id != card.id
+
+    result = graph.invoke(Command(resume={second.id: "2"}), config)
+    assert result["log"] == ["1,2"]
+
+
+def test_a_retried_answer_in_one_node_is_refused(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _ask_twice(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    (card,) = graph.get_state(config).interrupts
+    graph.invoke(Command(resume={card.id: "yes"}), config)
+    (second,) = graph.get_state(config).interrupts
+
+    with pytest.raises(UnknownInterruptError) as refused:
+        graph.invoke(Command(resume={card.id: "yes"}), config)
+
+    assert (
+        refused.value.reason,
+        refused.value.interrupt_ids,
+        refused.value.pending_ids,
+    ) == ("not_pending", (card.id,), (second.id,))
+    result = graph.invoke(Command(resume={second.id: "no"}), config)
+    assert result["log"] == ["yes,no"]
+
+
+def test_parallel_interrupts_in_one_node_each_take_an_answer(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    def ask(name: str) -> str:
+        return interrupt(f"{name}?")
+
+    def ask_in_parallel(state: State, config: RunnableConfig):
+        with get_executor_for_config(config) as pool:
+            b = pool.submit(ask, "b")
+            b.exception()
+            a = pool.submit(ask, "a")
+            return {"log": [f"{a.result()},{b.result()}"]}
+
+    graph = (
+        StateGraph(State)
+        .add_node("ask", ask_in_parallel)
+        .add_edge(START, "ask")
+        .compile(checkpointer=sync_checkpointer)
+    )
+    config = _config()
+    graph.invoke({"log": []}, config)
+    for answer in ("1", "2"):
+        (card,) = graph.get_state(config).interrupts
+        graph.invoke(Command(resume={card.id: answer}), config)
+
+    assert graph.get_state(config).next == ()
+
+
+def test_a_later_interrupt_saved_with_the_first_id_is_still_answered(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _ask_twice(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    (card,) = graph.get_state(config).interrupts
+    graph.invoke(Command(resume={card.id: "1"}), config)
+    state = graph.get_state(config)
+    sync_checkpointer.put_writes(
+        state.config,
+        [(INTERRUPT, (Interrupt(value="second?", id=card.id),))],
+        state.tasks[0].id,
+    )
+
+    result = graph.invoke(Command(resume={card.id: "2"}), config)
+    assert result["log"] == ["1,2"]
+
+
+def test_a_retried_node_reuses_its_answer(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _ask_then_fail_once(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    (card,) = graph.get_state(config).interrupts
+
+    result = graph.invoke(Command(resume={card.id: "yes"}), config)
+    assert result["log"] == ["yes"]
+
+
+def test_a_card_whose_resumed_task_raised_is_not_refused(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    failures = ["once"]
+
+    def ask_then_fail_once(state: State):
+        answer = interrupt("approve?")
+        if failures:
+            failures.pop()
+            raise ValueError("failed after the answer")
+        return {"log": [f"answered:{answer}"]}
+
+    graph = (
+        StateGraph(State)
+        .add_node("ask", ask_then_fail_once)
+        .add_edge(START, "ask")
+        .compile(checkpointer=sync_checkpointer)
+    )
+    config = _config()
+    graph.invoke({"log": []}, config)
+    (card,) = graph.get_state(config).interrupts
+    with pytest.raises(ValueError, match="failed after the answer"):
+        graph.invoke(Command(resume={card.id: "first"}), config)
+
+    graph.invoke(Command(resume={card.id: "second"}), config)
+    assert graph.get_state(config).next == ()
+
+
+def test_a_pinned_head_checkpoint_is_checked(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    head = graph.get_state(config).config
+    pinned = {"configurable": {**config["configurable"], **head["configurable"]}}
+
+    with pytest.raises(UnknownInterruptError):
+        graph.invoke(Command(resume={UNKNOWN_ID: "x"}), pinned)
+
+    ids = _pending_ids(graph, config)
+    result = graph.invoke(Command(resume={ids["a?"]: "yes", ids["b?"]: "no"}), pinned)
+    assert sorted(result["log"]) == ["a:yes", "b:no"]
+
+
+def test_a_superseded_checkpoint_is_not_checked(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _parallel(sync_checkpointer)
+    config = _config()
+    graph.invoke({"log": []}, config)
+    paused = graph.get_state(config).config
+    ids = _pending_ids(graph, config)
+    graph.invoke(Command(resume={ids["a?"]: "yes", ids["b?"]: "no"}), config)
+
+    pinned = {"configurable": {**config["configurable"], **paused["configurable"]}}
+    graph.invoke(Command(resume={ids["a?"]: "again", ids["b?"]: "again"}), pinned)
+
+
+@NEEDS_CONTEXTVARS
+async def test_unknown_id_is_refused_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _parallel(async_checkpointer)
+    config = _config()
+    await graph.ainvoke({"log": []}, config)
+
+    with pytest.raises(UnknownInterruptError, match=UNKNOWN_ID):
+        await graph.ainvoke(Command(resume={UNKNOWN_ID: "x"}), config)
+
+    state = await graph.aget_state(config)
+    assert {i.value for i in state.interrupts} == {"a?", "b?"}
+
+
+@NEEDS_CONTEXTVARS
+async def test_a_retried_node_reuses_its_answer_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    graph = _ask_then_fail_once(async_checkpointer)
+    config = _config()
+    await graph.ainvoke({"log": []}, config)
+    (card,) = (await graph.aget_state(config)).interrupts
+
+    result = await graph.ainvoke(Command(resume={card.id: "yes"}), config)
+    assert result["log"] == ["yes"]

libs/langgraph/tests/test_subgraph_persistence.py

@@ -6,16 +6,23 @@ Covers three checkpointer settings for subgraph state:
   interrupt support, but state resets each invocation. This is the common case
   when an agent is invoked from inside a tool used by another agent.
 - checkpointer=True: "stateful" — state accumulates across invocations on the same thread id
+
+Also covers reading a subgraph's namespace from the parent graph, including
+one where no subgraph is declared, such as a subagent a tool invokes.
 """
 
+from typing import Annotated, Any
 from uuid import uuid4
 
-from langchain_core.messages import AIMessage, HumanMessage
+import pytest
+from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
+from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from typing_extensions import TypedDict
 
+from langgraph.channels.delta import DeltaChannel
 from langgraph.graph import START, StateGraph
-from langgraph.graph.message import MessagesState
+from langgraph.graph.message import MessagesState, _messages_delta_reducer
 from langgraph.types import Command, Interrupt, interrupt
 from tests.any_str import AnyStr
 
@@ -685,3 +692,227 @@ def test_child_with_own_thread_id_keeps_namespace(
     parent.invoke({"result": ""}, config=parent_config)
     state2 = child.get_state(child_config)
     assert state2.values.get("count") == 2
+
+
+# -- reading a subgraph's namespace from the parent graph --
+
+
+class NotesState(MessagesState):
+    notes: str  # a key only the subgraphs have
+
+
+class DeltaMessagesState(TypedDict):
+    # Stores `messages` as deltas between snapshots, as deepagents' parent does.
+    messages: Annotated[list[AnyMessage], DeltaChannel(_messages_delta_reducer)]
+
+
+class DeltaNotesState(DeltaMessagesState):
+    notes: str
+
+
+def _notes_graph(label: str, state_schema: type = NotesState) -> Any:
+    # Typed `dict` so it fits either schema (see `_run_tool_subgraph`).
+    def work(state: dict) -> dict:
+        return {"messages": [AIMessage(content=f"{label} done")], "notes": label}
+
+    return (
+        StateGraph(state_schema)
+        .add_node("work", work)
+        .add_edge(START, "work")
+        .compile()
+    )
+
+
+def _namespace_configs(parent: Any) -> dict[str, RunnableConfig]:
+    """Run `parent` on a new thread. Returns a config for each subgraph
+    namespace it wrote, keyed by the node the namespace starts with."""
+    thread_id = str(uuid4())
+    return {
+        ns[0].split(":")[0]: {
+            "configurable": {"thread_id": thread_id, "checkpoint_ns": ns[0]}
+        }
+        for ns, _ in parent.stream(
+            {"messages": [HumanMessage(content="go")]},
+            {"configurable": {"thread_id": thread_id}},
+            subgraphs=True,
+        )
+        if ns
+    }
+
+
+def _run_tool_subgraph(
+    checkpointer: BaseCheckpointSaver,
+    *,
+    parent_schema: type = MessagesState,
+    subagent_schema: type = NotesState,
+) -> tuple[Any, RunnableConfig]:
+    """Run a parent whose `tools` node invokes a subgraph it doesn't declare,
+    as deepagents runs subagents. Returns the parent and a config for the
+    subgraph's `tools:<task_id>` namespace."""
+    # Subgraph detection doesn't follow a subscript, so `tools` declares none.
+    subagents = {"researcher": _notes_graph("researcher", subagent_schema)}
+
+    # Typed `dict`: a schema here would add its `messages` channel to the
+    # parent's, and a plain one clashes with a `DeltaChannel` one.
+    def tools(state: dict) -> dict:
+        subagents["researcher"].invoke(
+            {"messages": [HumanMessage(content="research apples")]}
+        )
+        return {"messages": [AIMessage(content="tool done")]}
+
+    parent = (
+        StateGraph(parent_schema)
+        .add_node("tools", tools)
+        .add_edge(START, "tools")
+        .compile(checkpointer=checkpointer)
+    )
+    return parent, _namespace_configs(parent)["tools"]
+
+
+def test_undeclared_subgraph_get_state(sync_checkpointer: BaseCheckpointSaver) -> None:
+    """A namespace with no declared subgraph is read with the parent graph."""
+    parent, ns_config = _run_tool_subgraph(sync_checkpointer)
+
+    state = parent.get_state(ns_config)
+
+    assert [m.text for m in state.values["messages"]] == [
+        "research apples",
+        "researcher done",
+    ]
+    assert state.config["configurable"]["checkpoint_ns"] == AnyStr("tools:")
+
+
+def test_undeclared_subgraph_get_state_history(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """History of a namespace with no declared subgraph is read with the parent
+    graph, and only holds that namespace's checkpoints."""
+    parent, ns_config = _run_tool_subgraph(sync_checkpointer)
+
+    history = list(parent.get_state_history(ns_config))
+
+    assert [[m.text for m in s.values.get("messages", [])] for s in history] == [
+        ["research apples", "researcher done"],
+        ["research apples"],
+        [],
+    ]
+    assert {s.config["configurable"]["checkpoint_ns"] for s in history} == {
+        ns_config["configurable"]["checkpoint_ns"]
+    }
+
+
+def test_undeclared_subgraph_update_state_raises(
+    sync_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Unlike a read, an update can't fall back to the parent graph: its nodes
+    and channels would write the wrong state into the subgraph's namespace."""
+    parent, ns_config = _run_tool_subgraph(sync_checkpointer)
+
+    with pytest.raises(ValueError, match="Subgraph tools not found"):
+        parent.update_state(ns_config, {"messages": [AIMessage(content="edit")]})
+
+    assert len(list(parent.get_state_history(ns_config))) == 3
+
+
+@pytest.mark.parametrize(
+    ("parent_schema", "subagent_schema"),
+    [(DeltaMessagesState, NotesState), (MessagesState, DeltaNotesState)],
+    ids=["delta_parent", "delta_subagent"],
+)
+def test_undeclared_subgraph_read_across_messages_channel_types(
+    sync_checkpointer: BaseCheckpointSaver,
+    parent_schema: type,
+    subagent_schema: type,
+) -> None:
+    """deepagents' parent stores `messages` in a `DeltaChannel`, and its
+    subagents in a plain `add_messages` channel. Reading a subagent's namespace
+    with the parent's channel restores its messages, either way round."""
+    parent, ns_config = _run_tool_subgraph(
+        sync_checkpointer,
+        parent_schema=parent_schema,
+        subagent_schema=subagent_schema,
+    )
+
+    state = parent.get_state(ns_config)
+    history = list(parent.get_state_history(ns_config))
+
+    assert [m.text for m in state.values["messages"]] == [
+        "research apples",
+        "researcher done",
+    ]
+    assert [[m.text for m in s.values.get("messages", [])] for s in history] == [
+        ["research apples", "researcher done"],
+        ["research apples"],
+        [],
+    ]
+
+
+@pytest.mark.parametrize("review_declared", [False, True])
+def test_prefix_named_namespaces_resolve_to_their_own_graph(
+    sync_checkpointer: BaseCheckpointSaver, review_declared: bool
+) -> None:
+    """`research_review` starts with `research`, whose subgraph has a `review`
+    node with its own subgraph. Each namespace still reads with its own graph:
+    a declared subgraph's channels, or the parent's when none is declared."""
+    research = (
+        StateGraph(NotesState)
+        .add_node("review", _notes_graph("research"))
+        .add_edge(START, "review")
+        .compile()
+    )
+
+    class ReviewState(NotesState):
+        verdict: str  # a key `research|review`'s graph doesn't have
+
+    def review(state: ReviewState) -> dict:
+        return {
+            "messages": [AIMessage(content="review done")],
+            "notes": "review",
+            "verdict": "approved",
+        }
+
+    # Subgraph detection doesn't follow a subscript, so `call_review` declares
+    # none.
+    subgraphs = {
+        "review": StateGraph(ReviewState)
+        .add_node("work", review)
+        .add_edge(START, "work")
+        .compile()
+    }
+
+    def call_review(state: MessagesState) -> dict:
+        subgraphs["review"].invoke({"messages": [HumanMessage(content="check it")]})
+        return {}
+
+    parent = (
+        StateGraph(MessagesState)
+        .add_node("research", research)
+        .add_node(
+            "research_review",
+            subgraphs["review"] if review_declared else call_review,
+        )
+        .add_edge(START, "research")
+        .add_edge("research", "research_review")
+        .compile(checkpointer=sync_checkpointer)
+    )
+    configs = _namespace_configs(parent)
+
+    def values(name: str) -> dict:
+        return {
+            k: [m.text for m in v] if k == "messages" else v
+            for k, v in parent.get_state(configs[name]).values.items()
+        }
+
+    assert values("research") == {
+        "messages": ["go", "research done"],
+        "notes": "research",
+    }
+    if review_declared:
+        assert values("research_review") == {
+            "messages": ["go", "research done", "review done"],
+            "notes": "review",
+            "verdict": "approved",
+        }
+    else:
+        # The parent's channels have no `notes` or `verdict`.
+        assert values("research_review") == {"messages": ["check it", "review done"]}

libs/langgraph/tests/test_subgraph_persistence_async.py

@@ -6,18 +6,24 @@ Covers three checkpointer settings for subgraph state:
   interrupt support, but state resets each invocation. This is the common case
   when an agent is invoked from inside a tool used by another agent.
 - checkpointer=True: "stateful" — state accumulates across invocations on the same thread id
+
+Also covers reading a subgraph's namespace from the parent graph, including
+one where no subgraph is declared, such as a subagent a tool invokes.
 """
 
 import sys
+from typing import Annotated, Any
 from uuid import uuid4
 
 import pytest
-from langchain_core.messages import AIMessage, HumanMessage
+from langchain_core.messages import AIMessage, AnyMessage, HumanMessage
+from langchain_core.runnables import RunnableConfig
 from langgraph.checkpoint.base import BaseCheckpointSaver
 from typing_extensions import TypedDict
 
+from langgraph.channels.delta import DeltaChannel
 from langgraph.graph import START, StateGraph
-from langgraph.graph.message import MessagesState
+from langgraph.graph.message import MessagesState, _messages_delta_reducer
 from langgraph.types import Command, Interrupt, interrupt
 from tests.any_str import AnyStr
 
@@ -707,3 +713,239 @@ async def test_child_with_own_thread_id_keeps_namespace_async(
     await parent.ainvoke({"result": ""}, config=parent_config)
     state2 = await child.aget_state(child_config)
     assert state2.values.get("count") == 2
+
+
+# -- reading a subgraph's namespace from the parent graph --
+
+
+class NotesState(MessagesState):
+    notes: str  # a key only the subgraphs have
+
+
+class DeltaMessagesState(TypedDict):
+    # Stores `messages` as deltas between snapshots, as deepagents' parent does.
+    messages: Annotated[list[AnyMessage], DeltaChannel(_messages_delta_reducer)]
+
+
+class DeltaNotesState(DeltaMessagesState):
+    notes: str
+
+
+def _notes_graph(label: str, state_schema: type = NotesState) -> Any:
+    # Typed `dict` so it fits either schema (see `_run_tool_subgraph`).
+    def work(state: dict) -> dict:
+        return {"messages": [AIMessage(content=f"{label} done")], "notes": label}
+
+    return (
+        StateGraph(state_schema)
+        .add_node("work", work)
+        .add_edge(START, "work")
+        .compile()
+    )
+
+
+async def _namespace_configs(parent: Any) -> dict[str, RunnableConfig]:
+    """Run `parent` on a new thread. Returns a config for each subgraph
+    namespace it wrote, keyed by the node the namespace starts with."""
+    thread_id = str(uuid4())
+    return {
+        ns[0].split(":")[0]: {
+            "configurable": {"thread_id": thread_id, "checkpoint_ns": ns[0]}
+        }
+        async for ns, _ in parent.astream(
+            {"messages": [HumanMessage(content="go")]},
+            {"configurable": {"thread_id": thread_id}},
+            subgraphs=True,
+        )
+        if ns
+    }
+
+
+async def _run_tool_subgraph(
+    checkpointer: BaseCheckpointSaver,
+    *,
+    parent_schema: type = MessagesState,
+    subagent_schema: type = NotesState,
+) -> tuple[Any, RunnableConfig]:
+    """Run a parent whose `tools` node invokes a subgraph it doesn't declare,
+    as deepagents runs subagents. Returns the parent and a config for the
+    subgraph's `tools:<task_id>` namespace."""
+    # Subgraph detection doesn't follow a subscript, so `tools` declares none.
+    subagents = {"researcher": _notes_graph("researcher", subagent_schema)}
+
+    # Typed `dict`: a schema here would add its `messages` channel to the
+    # parent's, and a plain one clashes with a `DeltaChannel` one.
+    async def tools(state: dict) -> dict:
+        await subagents["researcher"].ainvoke(
+            {"messages": [HumanMessage(content="research apples")]}
+        )
+        return {"messages": [AIMessage(content="tool done")]}
+
+    parent = (
+        StateGraph(parent_schema)
+        .add_node("tools", tools)
+        .add_edge(START, "tools")
+        .compile(checkpointer=checkpointer)
+    )
+    return parent, (await _namespace_configs(parent))["tools"]
+
+
+@NEEDS_CONTEXTVARS
+async def test_undeclared_subgraph_get_state_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """A namespace with no declared subgraph is read with the parent graph."""
+    parent, ns_config = await _run_tool_subgraph(async_checkpointer)
+
+    state = await parent.aget_state(ns_config)
+
+    assert [m.text for m in state.values["messages"]] == [
+        "research apples",
+        "researcher done",
+    ]
+    assert state.config["configurable"]["checkpoint_ns"] == AnyStr("tools:")
+
+
+@NEEDS_CONTEXTVARS
+async def test_undeclared_subgraph_get_state_history_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """History of a namespace with no declared subgraph is read with the parent
+    graph, and only holds that namespace's checkpoints."""
+    parent, ns_config = await _run_tool_subgraph(async_checkpointer)
+
+    history = [s async for s in parent.aget_state_history(ns_config)]
+
+    assert [[m.text for m in s.values.get("messages", [])] for s in history] == [
+        ["research apples", "researcher done"],
+        ["research apples"],
+        [],
+    ]
+    assert {s.config["configurable"]["checkpoint_ns"] for s in history} == {
+        ns_config["configurable"]["checkpoint_ns"]
+    }
+
+
+@NEEDS_CONTEXTVARS
+async def test_undeclared_subgraph_update_state_raises_async(
+    async_checkpointer: BaseCheckpointSaver,
+) -> None:
+    """Unlike a read, an update can't fall back to the parent graph: its nodes
+    and channels would write the wrong state into the subgraph's namespace."""
+    parent, ns_config = await _run_tool_subgraph(async_checkpointer)
+
+    with pytest.raises(ValueError, match="Subgraph tools not found"):
+        await parent.aupdate_state(ns_config, {"messages": [AIMessage(content="edit")]})
+
+    assert len([s async for s in parent.aget_state_history(ns_config)]) == 3
+
+
+@NEEDS_CONTEXTVARS
+@pytest.mark.parametrize(
+    ("parent_schema", "subagent_schema"),
+    [(DeltaMessagesState, NotesState), (MessagesState, DeltaNotesState)],
+    ids=["delta_parent", "delta_subagent"],
+)
+async def test_undeclared_subgraph_read_across_messages_channel_types_async(
+    async_checkpointer: BaseCheckpointSaver,
+    parent_schema: type,
+    subagent_schema: type,
+) -> None:
+    """deepagents' parent stores `messages` in a `DeltaChannel`, and its
+    subagents in a plain `add_messages` channel. Reading a subagent's namespace
+    with the parent's channel restores its messages, either way round."""
+    parent, ns_config = await _run_tool_subgraph(
+        async_checkpointer,
+        parent_schema=parent_schema,
+        subagent_schema=subagent_schema,
+    )
+
+    state = await parent.aget_state(ns_config)
+    history = [s async for s in parent.aget_state_history(ns_config)]
+
+    assert [m.text for m in state.values["messages"]] == [
+        "research apples",
+        "researcher done",
+    ]
+    assert [[m.text for m in s.values.get("messages", [])] for s in history] == [
+        ["research apples", "researcher done"],
+        ["research apples"],
+        [],
+    ]
+
+
+@NEEDS_CONTEXTVARS
+@pytest.mark.parametrize("review_declared", [False, True])
+async def test_prefix_named_namespaces_resolve_to_their_own_graph_async(
+    async_checkpointer: BaseCheckpointSaver, review_declared: bool
+) -> None:
+    """`research_review` starts with `research`, whose subgraph has a `review`
+    node with its own subgraph. Each namespace still reads with its own graph:
+    a declared subgraph's channels, or the parent's when none is declared."""
+    research = (
+        StateGraph(NotesState)
+        .add_node("review", _notes_graph("research"))
+        .add_edge(START, "review")
+        .compile()
+    )
+
+    class ReviewState(NotesState):
+        verdict: str  # a key `research|review`'s graph doesn't have
+
+    def review(state: ReviewState) -> dict:
+        return {
+            "messages": [AIMessage(content="review done")],
+            "notes": "review",
+            "verdict": "approved",
+        }
+
+    # Subgraph detection doesn't follow a subscript, so `call_review` declares
+    # none.
+    subgraphs = {
+        "review": StateGraph(ReviewState)
+        .add_node("work", review)
+        .add_edge(START, "work")
+        .compile()
+    }
+
+    async def call_review(state: MessagesState) -> dict:
+        await subgraphs["review"].ainvoke(
+            {"messages": [HumanMessage(content="check it")]}
+        )
+        return {}
+
+    parent = (
+        StateGraph(MessagesState)
+        .add_node("research", research)
+        .add_node(
+            "research_review",
+            subgraphs["review"] if review_declared else call_review,
+        )
+        .add_edge(START, "research")
+        .add_edge("research", "research_review")
+        .compile(checkpointer=async_checkpointer)
+    )
+    configs = await _namespace_configs(parent)
+
+    async def values(name: str) -> dict:
+        state = await parent.aget_state(configs[name])
+        return {
+            k: [m.text for m in v] if k == "messages" else v
+            for k, v in state.values.items()
+        }
+
+    assert await values("research") == {
+        "messages": ["go", "research done"],
+        "notes": "research",
+    }
+    if review_declared:
+        assert await values("research_review") == {
+            "messages": ["go", "research done", "review done"],
+            "notes": "review",
+            "verdict": "approved",
+        }
+    else:
+        # The parent's channels have no `notes` or `verdict`.
+        assert await values("research_review") == {
+            "messages": ["check it", "review done"]
+        }

libs/langgraph/uv.lock

@@ -706,139 +706,139 @@ wheels = [
 
 [[package]]
 name = "grpcio"
-version = "1.80.0"
+version = "1.81.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b7/48/af6173dbca4454f4637a4678b67f52ca7e0c1ed7d5894d89d434fecede05/grpcio-1.80.0.tar.gz", hash = "sha256:29aca15edd0688c22ba01d7cc01cb000d72b2033f4a3c72a81a19b56fd143257", size = 12978905, upload-time = "2026-03-30T08:49:10.502Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/b5/1ff353970a87eda4c98251e34d2dfd214abd4982dc89119c9252a2a482d2/grpcio-1.81.1.tar.gz", hash = "sha256:6fa10a767143a5e82e8eaab53918af0cd8909a57a27f8cb2288b80a613ac671b", size = 13026582, upload-time = "2026-06-11T12:46:51.673Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/9d/cd/bb7b7e54084a344c03d68144450da7ddd5564e51a298ae1662de65f48e2d/grpcio-1.80.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:886457a7768e408cdce226ad1ca67d2958917d306523a0e21e1a2fdaa75c9c9c", size = 6050363, upload-time = "2026-03-30T08:46:20.894Z" },
-    { url = "https://files.pythonhosted.org/packages/16/02/1417f5c3460dea65f7a2e3c14e8b31e77f7ffb730e9bfadd89eda7a9f477/grpcio-1.80.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:7b641fc3f1dc647bfd80bd713addc68f6d145956f64677e56d9ebafc0bd72388", size = 12026037, upload-time = "2026-03-30T08:46:25.144Z" },
-    { url = "https://files.pythonhosted.org/packages/43/98/c910254eedf2cae368d78336a2de0678e66a7317d27c02522392f949b5c6/grpcio-1.80.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:33eb763f18f006dc7fee1e69831d38d23f5eccd15b2e0f92a13ee1d9242e5e02", size = 6602306, upload-time = "2026-03-30T08:46:27.593Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/f8/88ca4e78c077b2b2113d95da1e1ab43efd43d723c9a0397d26529c2c1a56/grpcio-1.80.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:52d143637e3872633fc7dd7c3c6a1c84e396b359f3a72e215f8bf69fd82084fc", size = 7301535, upload-time = "2026-03-30T08:46:29.556Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/96/f28660fe2fe0f153288bf4a04e4910b7309d442395135c88ed4f5b3b8b40/grpcio-1.80.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:c51bf8ac4575af2e0678bccfb07e47321fc7acb5049b4482832c5c195e04e13a", size = 6808669, upload-time = "2026-03-30T08:46:31.984Z" },
-    { url = "https://files.pythonhosted.org/packages/47/eb/3f68a5e955779c00aeef23850e019c1c1d0e032d90633ba49c01ad5a96e0/grpcio-1.80.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:50a9871536d71c4fba24ee856abc03a87764570f0c457dd8db0b4018f379fed9", size = 7409489, upload-time = "2026-03-30T08:46:34.684Z" },
-    { url = "https://files.pythonhosted.org/packages/5b/a7/d2f681a4bfb881be40659a309771f3bdfbfdb1190619442816c3f0ffc079/grpcio-1.80.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a72d84ad0514db063e21887fbacd1fd7acb4d494a564cae22227cd45c7fbf199", size = 8423167, upload-time = "2026-03-30T08:46:36.833Z" },
-    { url = "https://files.pythonhosted.org/packages/97/8a/29b4589c204959aa35ce5708400a05bba72181807c45c47b3ec000c39333/grpcio-1.80.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f7691a6788ad9196872f95716df5bc643ebba13c97140b7a5ee5c8e75d1dea81", size = 7846761, upload-time = "2026-03-30T08:46:40.091Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/d2/ed143e097230ee121ac5848f6ff14372dba91289b10b536d54fb1b7cbae7/grpcio-1.80.0-cp310-cp310-win32.whl", hash = "sha256:46c2390b59d67f84e882694d489f5b45707c657832d7934859ceb8c33f467069", size = 4156534, upload-time = "2026-03-30T08:46:42.026Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/c9/df8279bb49b29409995e95efa85b72973d62f8aeff89abee58c91f393710/grpcio-1.80.0-cp310-cp310-win_amd64.whl", hash = "sha256:dc053420fc75749c961e2a4c906398d7c15725d36ccc04ae6d16093167223b58", size = 4889869, upload-time = "2026-03-30T08:46:44.219Z" },
-    { url = "https://files.pythonhosted.org/packages/5d/db/1d56e5f5823257b291962d6c0ce106146c6447f405b60b234c4f222a7cde/grpcio-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:dfab85db094068ff42e2a3563f60ab3dddcc9d6488a35abf0132daec13209c8a", size = 6055009, upload-time = "2026-03-30T08:46:46.265Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/18/c83f3cad64c5ca63bca7e91e5e46b0d026afc5af9d0a9972472ceba294b3/grpcio-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:5c07e82e822e1161354e32da2662f741a4944ea955f9f580ec8fb409dd6f6060", size = 12035295, upload-time = "2026-03-30T08:46:49.099Z" },
-    { url = "https://files.pythonhosted.org/packages/0f/8e/e14966b435be2dda99fbe89db9525ea436edc79780431a1c2875a3582644/grpcio-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba0915d51fd4ced2db5ff719f84e270afe0e2d4c45a7bdb1e8d036e4502928c2", size = 6610297, upload-time = "2026-03-30T08:46:52.123Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/26/d5eb38f42ce0e3fdc8174ea4d52036ef8d58cc4426cb800f2610f625dd75/grpcio-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3cb8130ba457d2aa09fa6b7c3ed6b6e4e6a2685fce63cb803d479576c4d80e21", size = 7300208, upload-time = "2026-03-30T08:46:54.859Z" },
-    { url = "https://files.pythonhosted.org/packages/25/51/bd267c989f85a17a5b3eea65a6feb4ff672af41ca614e5a0279cc0ea381c/grpcio-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:09e5e478b3d14afd23f12e49e8b44c8684ac3c5f08561c43a5b9691c54d136ab", size = 6813442, upload-time = "2026-03-30T08:46:57.056Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/d9/d80eef735b19e9169e30164bbf889b46f9df9127598a83d174eb13a48b26/grpcio-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:00168469238b022500e486c1c33916acf2f2a9b2c022202cf8a1885d2e3073c1", size = 7414743, upload-time = "2026-03-30T08:46:59.682Z" },
-    { url = "https://files.pythonhosted.org/packages/de/f2/567f5bd5054398ed6b0509b9a30900376dcf2786bd936812098808b49d8d/grpcio-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:8502122a3cc1714038e39a0b071acb1207ca7844208d5ea0d091317555ee7106", size = 8426046, upload-time = "2026-03-30T08:47:02.474Z" },
-    { url = "https://files.pythonhosted.org/packages/62/29/73ef0141b4732ff5eacd68430ff2512a65c004696997f70476a83e548e7e/grpcio-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:ce1794f4ea6cc3ca29463f42d665c32ba1b964b48958a66497917fe9069f26e6", size = 7851641, upload-time = "2026-03-30T08:47:05.462Z" },
-    { url = "https://files.pythonhosted.org/packages/46/69/abbfa360eb229a8623bab5f5a4f8105e445bd38ce81a89514ba55d281ad0/grpcio-1.80.0-cp311-cp311-win32.whl", hash = "sha256:51b4a7189b0bef2aa30adce3c78f09c83526cf3dddb24c6a96555e3b97340440", size = 4154368, upload-time = "2026-03-30T08:47:08.027Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/d4/ae92206d01183b08613e846076115f5ac5991bae358d2a749fa864da5699/grpcio-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:02e64bb0bb2da14d947a49e6f120a75e947250aebe65f9629b62bb1f5c14e6e9", size = 4894235, upload-time = "2026-03-30T08:47:10.839Z" },
-    { url = "https://files.pythonhosted.org/packages/5c/e8/a2b749265eb3415abc94f2e619bbd9e9707bebdda787e61c593004ec927a/grpcio-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:c624cc9f1008361014378c9d776de7182b11fe8b2e5a81bc69f23a295f2a1ad0", size = 6015616, upload-time = "2026-03-30T08:47:13.428Z" },
-    { url = "https://files.pythonhosted.org/packages/3e/97/b1282161a15d699d1e90c360df18d19165a045ce1c343c7f313f5e8a0b77/grpcio-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:f49eddcac43c3bf350c0385366a58f36bed8cc2c0ec35ef7b74b49e56552c0c2", size = 12014204, upload-time = "2026-03-30T08:47:15.873Z" },
-    { url = "https://files.pythonhosted.org/packages/6e/5e/d319c6e997b50c155ac5a8cb12f5173d5b42677510e886d250d50264949d/grpcio-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d334591df610ab94714048e0d5b4f3dd5ad1bee74dfec11eee344220077a79de", size = 6563866, upload-time = "2026-03-30T08:47:18.588Z" },
-    { url = "https://files.pythonhosted.org/packages/ae/f6/fdd975a2cb4d78eb67769a7b3b3830970bfa2e919f1decf724ae4445f42c/grpcio-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0cb517eb1d0d0aaf1d87af7cc5b801d686557c1d88b2619f5e31fab3c2315921", size = 7273060, upload-time = "2026-03-30T08:47:21.113Z" },
-    { url = "https://files.pythonhosted.org/packages/db/f0/a3deb5feba60d9538a962913e37bd2e69a195f1c3376a3dd44fe0427e996/grpcio-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:4e78c4ac0d97dc2e569b2f4bcbbb447491167cb358d1a389fc4af71ab6f70411", size = 6782121, upload-time = "2026-03-30T08:47:23.827Z" },
-    { url = "https://files.pythonhosted.org/packages/ca/84/36c6dcfddc093e108141f757c407902a05085e0c328007cb090d56646cdf/grpcio-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:2ed770b4c06984f3b47eb0517b1c69ad0b84ef3f40128f51448433be904634cd", size = 7383811, upload-time = "2026-03-30T08:47:26.517Z" },
-    { url = "https://files.pythonhosted.org/packages/7c/ef/f3a77e3dc5b471a0ec86c564c98d6adfa3510d38f8ee99010410858d591e/grpcio-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:256507e2f524092f1473071a05e65a5b10d84b82e3ff24c5b571513cfaa61e2f", size = 8393860, upload-time = "2026-03-30T08:47:29.439Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/8d/9d4d27ed7f33d109c50d6b5ce578a9914aa68edab75d65869a17e630a8d1/grpcio-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9a6284a5d907c37db53350645567c522be314bac859a64a7a5ca63b77bb7958f", size = 7830132, upload-time = "2026-03-30T08:47:33.254Z" },
-    { url = "https://files.pythonhosted.org/packages/14/e4/9990b41c6d7a44e1e9dee8ac11d7a9802ba1378b40d77468a7761d1ad288/grpcio-1.80.0-cp312-cp312-win32.whl", hash = "sha256:c71309cfce2f22be26aa4a847357c502db6c621f1a49825ae98aa0907595b193", size = 4140904, upload-time = "2026-03-30T08:47:35.319Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/2c/296f6138caca1f4b92a31ace4ae1b87dab692fc16a7a3417af3bb3c805bf/grpcio-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:9fe648599c0e37594c4809d81a9e77bd138cc82eb8baa71b6a86af65426723ff", size = 4880944, upload-time = "2026-03-30T08:47:37.831Z" },
-    { url = "https://files.pythonhosted.org/packages/2f/3a/7c3c25789e3f069e581dc342e03613c5b1cb012c4e8c7d9d5cf960a75856/grpcio-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e9e408fc016dffd20661f0126c53d8a31c2821b5c13c5d67a0f5ed5de93319ad", size = 6017243, upload-time = "2026-03-30T08:47:40.075Z" },
-    { url = "https://files.pythonhosted.org/packages/04/19/21a9806eb8240e174fd1ab0cd5b9aa948bb0e05c2f2f55f9d5d7405e6d08/grpcio-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:92d787312e613754d4d8b9ca6d3297e69994a7912a32fa38c4c4e01c272974b0", size = 12010840, upload-time = "2026-03-30T08:47:43.11Z" },
-    { url = "https://files.pythonhosted.org/packages/18/3a/23347d35f76f639e807fb7a36fad3068aed100996849a33809591f26eca6/grpcio-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8ac393b58aa16991a2f1144ec578084d544038c12242da3a215966b512904d0f", size = 6567644, upload-time = "2026-03-30T08:47:46.806Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/40/96e07ecb604a6a67ae6ab151e3e35b132875d98bc68ec65f3e5ab3e781d7/grpcio-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:68e5851ac4b9afe07e7f84483803ad167852570d65326b34d54ca560bfa53fb6", size = 7277830, upload-time = "2026-03-30T08:47:49.643Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/e2/da1506ecea1f34a5e365964644b35edef53803052b763ca214ba3870c856/grpcio-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:873ff5d17d68992ef6605330127425d2fc4e77e612fa3c3e0ed4e668685e3140", size = 6783216, upload-time = "2026-03-30T08:47:52.817Z" },
-    { url = "https://files.pythonhosted.org/packages/44/83/3b20ff58d0c3b7f6caaa3af9a4174d4023701df40a3f39f7f1c8e7c48f9d/grpcio-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2bea16af2750fd0a899bf1abd9022244418b55d1f37da2202249ba4ba673838d", size = 7385866, upload-time = "2026-03-30T08:47:55.687Z" },
-    { url = "https://files.pythonhosted.org/packages/47/45/55c507599c5520416de5eefecc927d6a0d7af55e91cfffb2e410607e5744/grpcio-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ba0db34f7e1d803a878284cd70e4c63cb6ae2510ba51937bf8f45ba997cefcf7", size = 8391602, upload-time = "2026-03-30T08:47:58.303Z" },
-    { url = "https://files.pythonhosted.org/packages/10/bb/dd06f4c24c01db9cf11341b547d0a016b2c90ed7dbbb086a5710df7dd1d7/grpcio-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:8eb613f02d34721f1acf3626dfdb3545bd3c8505b0e52bf8b5710a28d02e8aa7", size = 7826752, upload-time = "2026-03-30T08:48:01.311Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/1e/9d67992ba23371fd63d4527096eb8c6b76d74d52b500df992a3343fd7251/grpcio-1.80.0-cp313-cp313-win32.whl", hash = "sha256:93b6f823810720912fd131f561f91f5fed0fda372b6b7028a2681b8194d5d294", size = 4142310, upload-time = "2026-03-30T08:48:04.594Z" },
-    { url = "https://files.pythonhosted.org/packages/cf/e6/283326a27da9e2c3038bc93eeea36fb118ce0b2d03922a9cda6688f53c5b/grpcio-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:e172cf795a3ba5246d3529e4d34c53db70e888fa582a8ffebd2e6e48bc0cba50", size = 4882833, upload-time = "2026-03-30T08:48:07.363Z" },
-    { url = "https://files.pythonhosted.org/packages/c5/6d/e65307ce20f5a09244ba9e9d8476e99fb039de7154f37fb85f26978b59c3/grpcio-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:3d4147a97c8344d065d01bbf8b6acec2cf86fb0400d40696c8bdad34a64ffc0e", size = 6017376, upload-time = "2026-03-30T08:48:10.005Z" },
-    { url = "https://files.pythonhosted.org/packages/69/10/9cef5d9650c72625a699c549940f0abb3c4bfdb5ed45a5ce431f92f31806/grpcio-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d8e11f167935b3eb089ac9038e1a063e6d7dbe995c0bb4a661e614583352e76f", size = 12018133, upload-time = "2026-03-30T08:48:12.927Z" },
-    { url = "https://files.pythonhosted.org/packages/04/82/983aabaad82ba26113caceeb9091706a0696b25da004fe3defb5b346e15b/grpcio-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f14b618fc30de822681ee986cfdcc2d9327229dc4c98aed16896761cacd468b9", size = 6574748, upload-time = "2026-03-30T08:48:16.386Z" },
-    { url = "https://files.pythonhosted.org/packages/07/d7/031666ef155aa0bf399ed7e19439656c38bbd143779ae0861b038ce82abd/grpcio-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:4ed39fbdcf9b87370f6e8df4e39ca7b38b3e5e9d1b0013c7b6be9639d6578d14", size = 7277711, upload-time = "2026-03-30T08:48:19.627Z" },
-    { url = "https://files.pythonhosted.org/packages/e8/43/f437a78f7f4f1d311804189e8f11fb311a01049b2e08557c1068d470cb2e/grpcio-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:2dcc70e9f0ba987526e8e8603a610fb4f460e42899e74e7a518bf3c68fe1bf05", size = 6785372, upload-time = "2026-03-30T08:48:22.373Z" },
-    { url = "https://files.pythonhosted.org/packages/93/3d/f6558e9c6296cb4227faa5c43c54a34c68d32654b829f53288313d16a86e/grpcio-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:448c884b668b868562b1bda833c5fce6272d26e1926ec46747cda05741d302c1", size = 7395268, upload-time = "2026-03-30T08:48:25.638Z" },
-    { url = "https://files.pythonhosted.org/packages/06/21/0fdd77e84720b08843c371a2efa6f2e19dbebf56adc72df73d891f5506f0/grpcio-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a1dc80fe55685b4a543555e6eef975303b36c8db1023b1599b094b92aa77965f", size = 8392000, upload-time = "2026-03-30T08:48:28.974Z" },
-    { url = "https://files.pythonhosted.org/packages/f5/68/67f4947ed55d2e69f2cc199ab9fd85e0a0034d813bbeef84df6d2ba4d4b7/grpcio-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:31b9ac4ad1aa28ffee5503821fafd09e4da0a261ce1c1281c6c8da0423c83b6e", size = 7828477, upload-time = "2026-03-30T08:48:32.054Z" },
-    { url = "https://files.pythonhosted.org/packages/44/b6/8d4096691b2e385e8271911a0de4f35f0a6c7d05aff7098e296c3de86939/grpcio-1.80.0-cp314-cp314-win32.whl", hash = "sha256:367ce30ba67d05e0592470428f0ec1c31714cab9ef19b8f2e37be1f4c7d32fae", size = 4218563, upload-time = "2026-03-30T08:48:34.538Z" },
-    { url = "https://files.pythonhosted.org/packages/e5/8c/bbe6baf2557262834f2070cf668515fa308b2d38a4bbf771f8f7872a7036/grpcio-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:3b01e1f5464c583d2f567b2e46ff0d516ef979978f72091fd81f5ab7fa6e2e7f", size = 5019457, upload-time = "2026-03-30T08:48:37.308Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/d5/f2b159d8eec08be2a855ef698f5b6f7f9fdda022e4dd9e4f5d968affd678/grpcio-1.81.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:6f9a0c9c1cc15c112d1c053064fd032b64917062292c3d70aea280e02ae10b77", size = 6086868, upload-time = "2026-06-11T12:44:19.364Z" },
+    { url = "https://files.pythonhosted.org/packages/80/41/9c95232b94b219ed8b14029d9cd000e0381cafba869c451dda60af84f4ba/grpcio-1.81.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:69ef28e54fc85397f91b8c19592b8ef3d81952080366914823bd8572a2958120", size = 12062291, upload-time = "2026-06-11T12:44:27.142Z" },
+    { url = "https://files.pythonhosted.org/packages/83/8b/bd9284bdd665ddf877a3e8bc2930d1bcf6ebdbae7b0da5c783dc26bd6e33/grpcio-1.81.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:15641444eca4a29358107b3dceb74c1c6305c55c822fd199b458aaea4068a7fb", size = 6635242, upload-time = "2026-06-11T12:44:30.741Z" },
+    { url = "https://files.pythonhosted.org/packages/60/24/78fa025517a925f1a17da71c4ef9d5f1c6f9fa65af22dfb523c5c6317a21/grpcio-1.81.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:d4b2dddfc219f54f956ccd53cf76a1d338ffe68fc7f2849ec9c7feb9927ff692", size = 7332974, upload-time = "2026-06-11T12:44:33.72Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/11/402295b388dd35861007f8a26a37c2e2f284212d57bdf407c31f36043746/grpcio-1.81.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ca1cc11d82677b9662082e5478b7528e2b7db7beaa6bdff42bd62789d81be399", size = 6836597, upload-time = "2026-06-11T12:44:36.108Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/71/37b10fd4fd579ffade6e695c14e9df5e8cba9e2365b81c131da438b67c34/grpcio-1.81.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:aa2ba7d2ad6df4d80127cea65e5b8d5e2c3adbf153ff4804452836328aca7c54", size = 7440660, upload-time = "2026-06-11T12:44:38.664Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/d5/40203f828abc83d458b634666df6df13778032f178c03845ad5a93682388/grpcio-1.81.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:592b5fee597faa91cce2dd294dd7d9a1c83d76c4dbf877e33ec1adb866b2fbed", size = 8443171, upload-time = "2026-06-11T12:44:41.678Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/2c/0ed82ea35b5ec595e10444940c1db8c0e0ef57aa46bc8797d5ff838a219e/grpcio-1.81.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:62481553b1793a27e9b9c3cf9e5bd483ef045ca72462592074b46d42b0c4d9b9", size = 7868905, upload-time = "2026-06-11T12:44:44.854Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/1f/dcbdc1a68a07cc2b631c3098953794f17d75f93426a019240b90ce5423d6/grpcio-1.81.1-cp310-cp310-win32.whl", hash = "sha256:bb693b1e3d9a2f3fd228e2110daf4b5aeedb36761ca1e4282f74725f6d89f611", size = 4202215, upload-time = "2026-06-11T12:44:47.165Z" },
+    { url = "https://files.pythonhosted.org/packages/75/a1/d7ab9f1f42efcb7d9e6111d38be6b367737a72ea2c534e1f55c81e1b6436/grpcio-1.81.1-cp310-cp310-win_amd64.whl", hash = "sha256:88268ca418cacea64cecb0d1d600d3c6b3a8038fcba02e1e205178c5b1f47661", size = 4936582, upload-time = "2026-06-11T12:44:49.479Z" },
+    { url = "https://files.pythonhosted.org/packages/52/ea/1c2fa386b718ff493225e61cfc052ef400b4d6ffc54cbe261026432624b5/grpcio-1.81.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:d71d30f2d92f67d944631c523713934fee37292469e182ebcd2c1dd8a64ce53f", size = 6093112, upload-time = "2026-06-11T12:44:52.131Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/18/acf45fa8bd1bc5d7b0c2fd3dc4c209379fbd5bb396b440b68a83342226b7/grpcio-1.81.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:b137f4bf3ada9dc44d411478decc6ff09a79ed30b306cd2abaa98408c3588137", size = 12074277, upload-time = "2026-06-11T12:44:55.354Z" },
+    { url = "https://files.pythonhosted.org/packages/48/d7/ee86a60699b7db039f772a2c4a7e4facc7138984ff42c0130933a0063884/grpcio-1.81.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a3acb384427816dd5d470f47e62137b87f74da694faa8a50147012cf40df276a", size = 6640348, upload-time = "2026-06-11T12:44:59.223Z" },
+    { url = "https://files.pythonhosted.org/packages/26/ee/d2de5e47378ffc207d476c230fea3be4d2601edbce9995f4fe45535d4896/grpcio-1.81.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f9a0ebbe45c29b5e5866593c12b78bd9035f0f0f0d4bc8361680cd580d99db49", size = 7331842, upload-time = "2026-06-11T12:45:02.001Z" },
+    { url = "https://files.pythonhosted.org/packages/23/d6/abeda5c2b896a0b341584fe5ac411bbf72e197a9a374c355fb90965e08d2/grpcio-1.81.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0a37165cc80b1a368384b383e63a4c38116a10467ae44c904d2d7468c4470ec2", size = 6842229, upload-time = "2026-06-11T12:45:04.76Z" },
+    { url = "https://files.pythonhosted.org/packages/10/1c/1f0da7d590b4aeee006826ba568d0e419ca14b23e18f901a3da3e9fba613/grpcio-1.81.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6282caffb41ec326d4cb67ca9cf53b739d1b2f975a2acb498c7418e9f7d9a416", size = 7446096, upload-time = "2026-06-11T12:45:07.499Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/81/5c505d508f7c887aa7982d21443a4126597c80d34b0bcf40f9cec576d7f3/grpcio-1.81.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:a35009284d0d3d5c2c9601c164a911b8b4331608d98a9a66d47d97bb2f522b70", size = 8445238, upload-time = "2026-06-11T12:45:10.243Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/b2/524847365122ee509ca17bcc4e092198b700e94af7bfd5bb5e6dd9f3ee66/grpcio-1.81.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:1b22c80559854b789a01fd89e8929b3798a156c0829b5282a8939f33ad4115ad", size = 7873989, upload-time = "2026-06-11T12:45:13.102Z" },
+    { url = "https://files.pythonhosted.org/packages/18/fa/07c037c50b006909d1d13a5848774f8aa7b242f70dc03a035c64eea0e6db/grpcio-1.81.1-cp311-cp311-win32.whl", hash = "sha256:428bec0161b48d8cf583c068591bc0016d0d9cfff52462b72b3884861ea768c5", size = 4202223, upload-time = "2026-06-11T12:45:16.166Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ed/6bff15376920942fac6b95b9802752b837437172c9e8fc2d3170546b89cc/grpcio-1.81.1-cp311-cp311-win_amd64.whl", hash = "sha256:30e825f6848d9f18bba350ed6c75c1b02a0b5184474a31db9a32b1fa66fd8c79", size = 4941303, upload-time = "2026-06-11T12:45:18.724Z" },
+    { url = "https://files.pythonhosted.org/packages/85/07/9a979c81738863a738dc23d65177056e71fbb2db817740ed870b33434e7a/grpcio-1.81.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:8b39472beafc0bdcafc4c8c73ad082ebfdb449d566897a61e7acb4fa88089115", size = 6053264, upload-time = "2026-06-11T12:45:21.017Z" },
+    { url = "https://files.pythonhosted.org/packages/75/95/539706ca0d3bd40dbad583dc56fd883da941f37556b629132da5762781b9/grpcio-1.81.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:12b7524c88d4026d3dcb7b0ebe16b6714f3b4af402ddd0f0639ab064a00c87c3", size = 12052560, upload-time = "2026-06-11T12:45:23.652Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/44/f257b7e0bd69c93b06c6cb8ac8d1b901ccb42bedabd83c1a4c77a71f8810/grpcio-1.81.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1e123f9b37edb8375fd74130d1f69c944bbf0a7b06761ae7211154b8759e94d2", size = 6595983, upload-time = "2026-06-11T12:45:26.963Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/f3/19782aa04c960968bef8c5539329d8e3bbc3364e2e46d19eb5e5cc5e43b7/grpcio-1.81.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:2c2e2ae6867c2966b8daccc836d54a13218e0007e9a490aeb81dd05be64d22d7", size = 7303455, upload-time = "2026-06-11T12:45:29.707Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/8c/dea020b6d91508cd84463917a63149ec196ee7db505d032ae43fcb3303b9/grpcio-1.81.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:766bc7c9a9c340342f4c864ccbda8e78111e4751f13b895812b9c148fb79e9d0", size = 6809167, upload-time = "2026-06-11T12:45:32.52Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/c7/3030dd940408083bd32cd95d634777a71605ade4887154d93e8a89244946/grpcio-1.81.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b259a04a737cb3496be0901328eb8b7552ed8df4865d8c8f1cf1bffcfc0776a3", size = 7412536, upload-time = "2026-06-11T12:45:35.403Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/dd/1172a9e42b168edcafefad6115346ef619a3fc02158bb170e66ced24bcdd/grpcio-1.81.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:85b10a45b8993d195c4f3ff57025b8d1e11834909ee475c403bfa60cb4caefaf", size = 8408276, upload-time = "2026-06-11T12:45:37.78Z" },
+    { url = "https://files.pythonhosted.org/packages/25/7a/71437c7f3596e5246155c515852795a85a1a8d228190212432b13b97a95d/grpcio-1.81.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:8ea1936c26b99999b27479853039a7f34713f56c49375ad52b38535ec93a796c", size = 7849660, upload-time = "2026-06-11T12:45:40.627Z" },
+    { url = "https://files.pythonhosted.org/packages/65/40/7debc0da45d2efebafb82da75644be347497fe4ee250514b8cd3b86ae8bf/grpcio-1.81.1-cp312-cp312-win32.whl", hash = "sha256:a185a04039df6cae8648bc8ab6d6fde7bf94f7188ecf7828e76ac52eef1e41d6", size = 4185819, upload-time = "2026-06-11T12:45:43.027Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/b9/8fe3ba5ed462067774ebc1f9c7f26aa7ebcc280ddd476be107153de1339e/grpcio-1.81.1-cp312-cp312-win_amd64.whl", hash = "sha256:3ad74f8bb1a18963914c5452d289422830b39459e8776ebbcd207be1fbfb1d94", size = 4930461, upload-time = "2026-06-11T12:45:45.775Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/42/dcc2e4b600538ef18327c0839d56b7d3c3812337c5d710df5877dbb39b1e/grpcio-1.81.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:b10e1ff4756ed27d5a29d7fc79cfce7ef1ff56ad20025b89bac7cf79e09abbbe", size = 6054466, upload-time = "2026-06-11T12:45:48.43Z" },
+    { url = "https://files.pythonhosted.org/packages/7b/4a/a36e03210183a8a7d4c80c3936acee679f4bd77d5861f369db47b2cc5f05/grpcio-1.81.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:819edbdcb42ab8598b494bcf0222684bbb7a3c772bd1b1f0be7e029a6063c28e", size = 12048795, upload-time = "2026-06-11T12:45:54.011Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/d5/d68e30b29098f63beab6fe501100fe82674ff142b32c672532da86a99b3a/grpcio-1.81.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:c5bf2dc311127d91230cc79b92188c082634a06cf66c5234db49a43b910183b0", size = 6599094, upload-time = "2026-06-11T12:45:57.799Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/b3/e837954d279754f638a11cca5dcf6b24a005efb398984cefaf7735945a54/grpcio-1.81.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:e8ca6a1fcdb2943c9cbc1804a1baf3acb6071d72a471591678ded84218006e14", size = 7307182, upload-time = "2026-06-11T12:46:00.568Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/1e/b47957057e729adc6cdf519a47f8be2562b7140e280f1418443eb4022192/grpcio-1.81.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e64dd101d380a115cc5a0c7856788adb535f1a4e21fc543775602f8be95180ae", size = 6810962, upload-time = "2026-06-11T12:46:03.312Z" },
+    { url = "https://files.pythonhosted.org/packages/40/26/569868e364e05b19ec8f969da53d230bcd89c962cd198f7c29943155c4d3/grpcio-1.81.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:98a07f9bf591e3a8919797bee1c53f026ba4acd587e5a4404c8e57c9ec36b2a5", size = 7415698, upload-time = "2026-06-11T12:46:06.005Z" },
+    { url = "https://files.pythonhosted.org/packages/36/0c/5440a0582cb5653fc42a6e262eeb22700943313f8076f9dc927491b20a59/grpcio-1.81.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:c261d74b1a945cf895a9d6eccd1685a8e837531beaab782da4d630a8d12deffb", size = 8407779, upload-time = "2026-06-11T12:46:08.84Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/aa/66fe9f39871d766987d869a03ee0842a026f499c7b1e62decb9e78a8088e/grpcio-1.81.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:58ad1131c300d3c9b933802b3cc4dc69d380822935ba50b28703156ea826fbf7", size = 7844521, upload-time = "2026-06-11T12:46:12.171Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/9e/69bb7194861bcd28fb3193261d4f9c3831b4446993f002cf59068943e7ab/grpcio-1.81.1-cp313-cp313-win32.whl", hash = "sha256:78e29211f26da2fdd0e9c6d2b79f489476140cf7029b6a64808ade7ca4156a42", size = 4182786, upload-time = "2026-06-11T12:46:15.192Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/20/3da8bb0d637feccdc3e1e419bb511ce93651ce7d54164f95de22cc0b8b34/grpcio-1.81.1-cp313-cp313-win_amd64.whl", hash = "sha256:edb59506291b647a30884b1d51a599d605f40b20af4a7dc3d33786a47a31de60", size = 4928648, upload-time = "2026-06-11T12:46:17.823Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/58/19414622b1bf6981bc9c05a365bd548e71876c89000083b3af489251e9c0/grpcio-1.81.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:506f48f2f9c29b143fca3dad7b0d518c188b6c9648c75a2ae6e2d9f2c13a060b", size = 6055336, upload-time = "2026-06-11T12:46:20.557Z" },
+    { url = "https://files.pythonhosted.org/packages/32/f1/2ec88adb92b0eba970dd0e0e7dd086341daa3c75eba4f735f9e44bf684b0/grpcio-1.81.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d865db4a6318e1c1bea83292e0ed231090538fc4ca45425b0f0480eb338bbc6e", size = 12056279, upload-time = "2026-06-11T12:46:24.255Z" },
+    { url = "https://files.pythonhosted.org/packages/41/36/e8c5f8c6ec71de73733695ebc809e98b178b534ec6d8eaa31a7ebab4ad4c/grpcio-1.81.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:e2aa72e3ce1770317ef534f63d397b55e130725f5149bd36077c3b539019db27", size = 6608225, upload-time = "2026-06-11T12:46:27.601Z" },
+    { url = "https://files.pythonhosted.org/packages/30/22/96fc577a845ab093326d9ab1adb874bd4936c8cf98ac8ed2f3db13a0a2fb/grpcio-1.81.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:0490c30c261eded63f3f354979f9dc4502a9fb944cccb60cd9dc85f5a7349854", size = 7306576, upload-time = "2026-06-11T12:46:30.514Z" },
+    { url = "https://files.pythonhosted.org/packages/76/7b/61dab5d5969f28d97fb1009cead1df0a5cd987d3315e1b37f18a4449f8bc/grpcio-1.81.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:410482da976329fe5f4067270401b12cf2bd552ff8020f054ecfaddb5475f9d6", size = 6812165, upload-time = "2026-06-11T12:46:33.699Z" },
+    { url = "https://files.pythonhosted.org/packages/82/78/6e501929d4f5f96462fd82fd9f0f06e5f9612207582b862868d68757b27d/grpcio-1.81.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:e3657301562ac3cb8018d30d0d3ebfa39932239f7b5703422057ef14b69949f5", size = 7422962, upload-time = "2026-06-11T12:46:36.511Z" },
+    { url = "https://files.pythonhosted.org/packages/2a/7e/f2157589e66daa78ebb3165942d05a08bdea93b9d11c2bc1e172aef89685/grpcio-1.81.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:24c8e57504c8f45b237e40b99262d181071e5099a07053695b75d97bb53053a0", size = 8408176, upload-time = "2026-06-11T12:46:39.803Z" },
+    { url = "https://files.pythonhosted.org/packages/da/df/c6717fef716e00d235ffb96123baf6dce76d6004f6233fa767c502861460/grpcio-1.81.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:b427c19380991a4eaab2f6144b64b99b412043314c6bf4ab544f97bb31ee4190", size = 7846681, upload-time = "2026-06-11T12:46:43.013Z" },
+    { url = "https://files.pythonhosted.org/packages/36/84/3502e9f210a6a5c4438c8aca3f88edd2e04f6a27f3d41b26cf0a0024b096/grpcio-1.81.1-cp314-cp314-win32.whl", hash = "sha256:61233fe8951e5c85dff81c2458b6528624760166946b5b47ea150a589168411f", size = 4264615, upload-time = "2026-06-11T12:46:45.741Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/b0/4af731ff7492c68a96e4c71bfd0f4590acde92b31c6fe4894e6465c10ff6/grpcio-1.81.1-cp314-cp314-win_amd64.whl", hash = "sha256:3768a5ff1b2125e6f552e561b6b2dca0e64982d8949689b4df145cf8b98d7821", size = 5070275, upload-time = "2026-06-11T12:46:48.486Z" },
 ]
 
 [[package]]
 name = "grpcio-health-checking"
-version = "1.80.0"
+version = "1.81.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "grpcio" },
     { name = "protobuf" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d1/a2/aa3cc47f19c03f8e5287b987317059753141a3af8f66b96d5a64b3be10b8/grpcio_health_checking-1.80.0.tar.gz", hash = "sha256:2cc5f08bc8b816b8655ab6f59c71450063ba20766d31e21a493e912e3560c8b1", size = 17117, upload-time = "2026-03-30T08:54:41.899Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/65/46/6b6678b5a922765ae7637205bb6d0618a4da8b35f2ce6116f8bcff262370/grpcio_health_checking-1.81.1.tar.gz", hash = "sha256:ecc61480e25058a4a04e11e4ab6900ad7439b32e60a8ce4ece7d9f219221c85d", size = 17107, upload-time = "2026-06-11T12:58:49.632Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/d1/d97eb30386feff6ac2a662620e2ed68be352e9a182d62e06213db694906a/grpcio_health_checking-1.80.0-py3-none-any.whl", hash = "sha256:d804d4549cbb71e90ca2c7bf0c501060135dfd220aca8e2c54f96d3e79e210e5", size = 19125, upload-time = "2026-03-30T08:53:44.835Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/87/174bbfb5613794862c45b5cdf567fcfb478ad5a3a7b594e11d998656b2f9/grpcio_health_checking-1.81.1-py3-none-any.whl", hash = "sha256:cbc6a4171825ec64389de2f062d296ba129a5c27eefd0dd55fa837909184bdf9", size = 19120, upload-time = "2026-06-11T12:58:38.008Z" },
 ]
 
 [[package]]
 name = "grpcio-tools"
-version = "1.80.0"
+version = "1.81.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "grpcio" },
     { name = "protobuf" },
     { name = "setuptools" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/94/c8/1223f29c84a143ae9a56c084fc96894de0ba84b6e8d60a26241abd81d278/grpcio_tools-1.80.0.tar.gz", hash = "sha256:26052b19c6ce0dcf52d1024496aea3e2bdfa864159f06dc7b97b22d041a94b26", size = 6133212, upload-time = "2026-03-30T08:52:39.077Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/83/b3/1c5951352d6777fd7f99a0ccee04617fdfd8a5dbf2918a1f58c8b2b280b8/grpcio_tools-1.81.1.tar.gz", hash = "sha256:a22a3870180927fdd84e2b27d079ef5b7f5f8c6110181b6736afc17a463481f1", size = 6236155, upload-time = "2026-06-11T12:51:21.235Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7a/54/1de67f5080da305a258758a8deb33f85666fa759f56785042a80b114a53f/grpcio_tools-1.80.0-cp310-cp310-linux_armv7l.whl", hash = "sha256:727477b9afa4b53f5ec70cafb41c3965d893835e0d4ea9b542fe3d0d005602bf", size = 2549601, upload-time = "2026-03-30T08:50:09.498Z" },
-    { url = "https://files.pythonhosted.org/packages/9a/b4/6d57ea199c5b880d182a2234aafa9a686f9c54c708ea7be75bd19d5aa825/grpcio_tools-1.80.0-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:85fe8d15f146c62cb76f38d963e256392d287442b9232717d30ae9e3bbda9bc3", size = 5712717, upload-time = "2026-03-30T08:50:15.028Z" },
-    { url = "https://files.pythonhosted.org/packages/6a/1a/5505ee2277d368b409c796c78f22ea34a2a517b7d16755247efd663dc7af/grpcio_tools-1.80.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:95f0fffb5ca00519f3b602f938169b4dfa04b165e03258323965a9dfe8cc4d80", size = 2595941, upload-time = "2026-03-30T08:50:17.299Z" },
-    { url = "https://files.pythonhosted.org/packages/4e/39/7fc1d16d8b767805079d76365d73e82c88dfaf179034473dbc9fbccedb77/grpcio_tools-1.80.0-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:7a0106af212748823a6ebd8ffbd9043414216f47cae3835f3187de0a62c415d3", size = 2909304, upload-time = "2026-03-30T08:50:19.485Z" },
-    { url = "https://files.pythonhosted.org/packages/97/d8/276ee759755d8f34f2ca5e9d2debd1a59f29f66059fb790bc369f2236c26/grpcio_tools-1.80.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:31fd01a4038b5dfc4ec79504a17061344f670f851833411717fef66920f13cd7", size = 2660269, upload-time = "2026-03-30T08:50:21.266Z" },
-    { url = "https://files.pythonhosted.org/packages/51/04/a6bb47942ad52901d777a649324d3203cf19d487f1d446263637f7a5bf12/grpcio_tools-1.80.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:57da9e19607fac4a01c48ead333c0dd15d91ed38794dce1194eda308f73e2038", size = 3109798, upload-time = "2026-03-30T08:50:23.267Z" },
-    { url = "https://files.pythonhosted.org/packages/be/50/7ee69b2919916739787d725f205b878e8d1619dd30422b8278e324664669/grpcio_tools-1.80.0-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:90968f751851abb8b145593609800fa70c837e1c93ba0792c480b1c8d8bc29ef", size = 3658930, upload-time = "2026-03-30T08:50:25.458Z" },
-    { url = "https://files.pythonhosted.org/packages/92/61/6d50783092b0e8bbcb04152d5388bf50ecf3ea2f783d95288ff6c3bb00fa/grpcio_tools-1.80.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:b69dc5d6376ab43406304d1e2fc61ccf960b287d4325d77c3d45448c37a9d2da", size = 3326562, upload-time = "2026-03-30T08:50:27.809Z" },
-    { url = "https://files.pythonhosted.org/packages/ea/58/d272ba549f6b1f0d8504f5fc4cd0a296f2c495a64d6e987fe871c4151557/grpcio_tools-1.80.0-cp310-cp310-win32.whl", hash = "sha256:3e8dcfebe34cb54df095de3d5871a4562a85a29f26d0f8bb41ee2c3dcfb11c3c", size = 997620, upload-time = "2026-03-30T08:50:29.959Z" },
-    { url = "https://files.pythonhosted.org/packages/70/5f/9f45a9946a0298711c72ca48b2c1f46a7d0c207a44cd3e4bb59d04556ba3/grpcio_tools-1.80.0-cp310-cp310-win_amd64.whl", hash = "sha256:fc622ed4ca400695f41c9eae3266276c6ba007e4c28164ce53b44e7ccc5e492b", size = 1162466, upload-time = "2026-03-30T08:50:32.242Z" },
-    { url = "https://files.pythonhosted.org/packages/8a/d7/225dc91e6cb4f8d4830f16a478a468e9c6f342dcdf8cacc3772cc1d1f607/grpcio_tools-1.80.0-cp311-cp311-linux_armv7l.whl", hash = "sha256:1c43e5c768578fe0c6de3dbfaabe64af642951e1aa05c487cacedda63fa6c6c4", size = 2549937, upload-time = "2026-03-30T08:50:34.651Z" },
-    { url = "https://files.pythonhosted.org/packages/97/3d/a3684cb7677f3bea8db434eae02a9ce30135d7a268cd473b1bc8041c4722/grpcio_tools-1.80.0-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:a225348456575f3ac7851d8e23163195e76d2a905ee340cf73f33da62fba08aa", size = 5713099, upload-time = "2026-03-30T08:50:37.158Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/81/5665c697173ec346076358bfbfed0f7386825852494593ca14386478dfee/grpcio_tools-1.80.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a9396f02820d3f51c368c2c9dee15c55c77636c91be48a4d5c702e98d6fe0fdc", size = 2595776, upload-time = "2026-03-30T08:50:39.087Z" },
-    { url = "https://files.pythonhosted.org/packages/03/4f/fb81384f08a8226fa079972ba88272ac6277581fc72e8ab234d74c7e065b/grpcio_tools-1.80.0-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:797c08460cae16b402326eac329aec720dccf45c9f9279b95a352792eb53cf0f", size = 2909144, upload-time = "2026-03-30T08:50:40.922Z" },
-    { url = "https://files.pythonhosted.org/packages/4d/9c/c957618f1c2a3195ecf5e83b03edcb364c2c1391f74183cb76e5763fa536/grpcio_tools-1.80.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1872a867eb6217de19edb70a4ce4a374ced9d94293533dfd42fa649713f55bf4", size = 2660477, upload-time = "2026-03-30T08:50:42.766Z" },
-    { url = "https://files.pythonhosted.org/packages/42/c7/23913da184febfd4eaf04de256a26bc5ff0411a5feb753e2adcff10fa86a/grpcio_tools-1.80.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:db122ba5ee357e3bb14e8944d69bbebcbdae91d5eace29ed4df3edc53cbc6528", size = 3110164, upload-time = "2026-03-30T08:50:44.761Z" },
-    { url = "https://files.pythonhosted.org/packages/af/fa/b25ed85ebdb0396910eaa250b1346d75527d22fca586265416bd4330dcd5/grpcio_tools-1.80.0-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ddefd48c227e6f4d640fe576fac5fb2c4a8898196f513604c8ec7671b3b3d421", size = 3658988, upload-time = "2026-03-30T08:50:47.546Z" },
-    { url = "https://files.pythonhosted.org/packages/60/85/2a55147cc9645e2ed777d1afcd2dc68cb34ba6f6c726bd4378ddb001a5ea/grpcio_tools-1.80.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:970ec058fa469dd6dae6ebc687501c5da670d95dead75f62f5b0933dce2c9794", size = 3326662, upload-time = "2026-03-30T08:50:49.59Z" },
-    { url = "https://files.pythonhosted.org/packages/68/ed/b05bee2a992e6f9bda81909692ea920d0896cfa05c5c9dd77ba03f2d22fb/grpcio_tools-1.80.0-cp311-cp311-win32.whl", hash = "sha256:526b4402d47a0e9b31cd6087e42b7674784617916cc73c764e0bc35ed41b4ee5", size = 997969, upload-time = "2026-03-30T08:50:51.539Z" },
-    { url = "https://files.pythonhosted.org/packages/b6/9a/cb50c8270e2f6285ff2761130ae257ac4e51789ded4b9d9710ce0381814d/grpcio_tools-1.80.0-cp311-cp311-win_amd64.whl", hash = "sha256:ee101ecda7231770f6a5da1024a9a6ed587a7785f8fe23ab8283f4a1acb3ffe6", size = 1162742, upload-time = "2026-03-30T08:50:54.232Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/b9/65929df8c9614792db900a8e45d4997fadbd1734c827da3f0eb1f2fe4866/grpcio_tools-1.80.0-cp312-cp312-linux_armv7l.whl", hash = "sha256:d19d5a8244311947b96f749c417b32d144641c6953f1164824579e1f0a51d040", size = 2550856, upload-time = "2026-03-30T08:50:57.3Z" },
-    { url = "https://files.pythonhosted.org/packages/28/17/af1557544d68d1aeca9d9ea53ed16524022d521fec6ba334ab3530e9c1a6/grpcio_tools-1.80.0-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:fb599a3dc89ed1bb24489a2724b2f6dd4cddbbf0f7bdd69c073477bab0dc7554", size = 5710883, upload-time = "2026-03-30T08:51:00.077Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/48/aa9b4f7519ca972bc40d315d5c28f05ca28fa08de13d4e8b69f551b798ab/grpcio_tools-1.80.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:623ee31fc2ff7df9a987b4f3d139c30af17ce46a861ae0e25fb8c112daa32dd8", size = 2598004, upload-time = "2026-03-30T08:51:02.102Z" },
-    { url = "https://files.pythonhosted.org/packages/b4/b8/b01371c119924b3beca1fe3f047b1bc2cdc66b3d37f0f3acc9d10c567a43/grpcio_tools-1.80.0-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:b46570a68378539ee2b75a5a43202561f8d753c832798b1047099e3c551cf5d6", size = 2909568, upload-time = "2026-03-30T08:51:04.159Z" },
-    { url = "https://files.pythonhosted.org/packages/4f/7c/1108f7bdb58475a7e701ec89b55eb494538b6e76acd211ba0d4cc5fd28e8/grpcio_tools-1.80.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:51caf99c28999e7e0f97e9cea190c1405b7681a57bb2e0631205accd92b43fa4", size = 2660938, upload-time = "2026-03-30T08:51:06.126Z" },
-    { url = "https://files.pythonhosted.org/packages/67/59/d1c0063d4cd3b85363c7044ff3e5159d6d5df96e2692a9a5312d9c8cb290/grpcio_tools-1.80.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:cdaa1c9aa8d3a87891a96700cadd29beec214711d6522818d207277f6452567c", size = 3113814, upload-time = "2026-03-30T08:51:08.834Z" },
-    { url = "https://files.pythonhosted.org/packages/76/21/18d34a4efe524c903cf66b0cfa5260d81f277b6ae668b647edf795df9ce5/grpcio_tools-1.80.0-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3399b5fd7b59bcffd59c6b9975a969d9f37a3c87f3e3d63c3a09c147907acb0d", size = 3662793, upload-time = "2026-03-30T08:51:11.094Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/40/cf2d9295a6bd593244ea703858f8fc2efd315046ca3ef7c6f9ebc5b810fa/grpcio_tools-1.80.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9c6abc08d3485b2aac99bb58afcd31dc6cd4316ce36cf263ff09cb6df15f287f", size = 3329149, upload-time = "2026-03-30T08:51:13.066Z" },
-    { url = "https://files.pythonhosted.org/packages/0d/1d/fc34b32167966df20d69429b71dfca83c48434b047a5ac4fd6cd91ca4eed/grpcio_tools-1.80.0-cp312-cp312-win32.whl", hash = "sha256:18c51e07652ac7386fcdbd11866f8d55a795de073337c12447b5805575339f74", size = 997519, upload-time = "2026-03-30T08:51:14.87Z" },
-    { url = "https://files.pythonhosted.org/packages/91/98/6d6563cdf51085b75f8ec24605c6f2ce84197571878ca8ab4af949c6be2d/grpcio_tools-1.80.0-cp312-cp312-win_amd64.whl", hash = "sha256:ac6fdd42d5bb18f0d903a067e2825be172deff70cf197164b6f65676cb506c9b", size = 1162407, upload-time = "2026-03-30T08:51:16.793Z" },
-    { url = "https://files.pythonhosted.org/packages/44/d9/f7887a4805939e9a85d03744b66fc02575dc1df3c3e8b4d9ec000ee7a33d/grpcio_tools-1.80.0-cp313-cp313-linux_armv7l.whl", hash = "sha256:e7046837859bbfd10b01786056145480155c16b222c9e209215b68d3be13060e", size = 2550319, upload-time = "2026-03-30T08:51:19.117Z" },
-    { url = "https://files.pythonhosted.org/packages/57/5a/c8a05b32bd7203f1b9f4c0151090a2d6179d6c97692d32f2066dc29c67a6/grpcio_tools-1.80.0-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:a447f28958a8fe84ff0d9d3d9473868feb27ee4a9c9c805e66f5b670121cec59", size = 5709681, upload-time = "2026-03-30T08:51:21.991Z" },
-    { url = "https://files.pythonhosted.org/packages/82/6b/794350ed645c12c310008f97068f6a6fd927150b0d0d08aad1d909e880b1/grpcio_tools-1.80.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:75f00450e08fe648ad8a1eeb25bc52219679d54cdd02f04dfdddc747309d83f6", size = 2596820, upload-time = "2026-03-30T08:51:24.323Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/b2/b39e7b79f7c878135e0784a53cd7260ee77260c8c7f2c9e46bca8e05d017/grpcio_tools-1.80.0-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:3db830eaff1f2c2797328f2fa86c9dcdbd7d81af573a68db81e27afa2182a611", size = 2909193, upload-time = "2026-03-30T08:51:27.025Z" },
-    { url = "https://files.pythonhosted.org/packages/10/f3/abe089b058f87f9910c9a458409505cbeb0b3e1c2d993a79721d02ee6a32/grpcio_tools-1.80.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7982b5fe42f012686b667dda12916884de95c4b1c65ff64371fb7232a1474b23", size = 2660197, upload-time = "2026-03-30T08:51:29.392Z" },
-    { url = "https://files.pythonhosted.org/packages/09/c3/3f7806ad8b731d8a89fe3c6ed496473abd1ef4c9c42c9e9a8836ce96e377/grpcio_tools-1.80.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:6451b3f4eb52d12c7f32d04bf8e0185f80521f3f088ad04b8d222b3a4819c71e", size = 3113144, upload-time = "2026-03-30T08:51:31.671Z" },
-    { url = "https://files.pythonhosted.org/packages/fe/f5/415ef205e0b7e75d2a2005df6120145c4f02fda28d7b3715b55d924fe1a4/grpcio_tools-1.80.0-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:258bc30654a9a2236be4ca8e2ad443e2ac6db7c8cc20454d34cce60265922726", size = 3661897, upload-time = "2026-03-30T08:51:34.849Z" },
-    { url = "https://files.pythonhosted.org/packages/e3/d3/2ad54764c2a9547080dd8518f4a4dc7899c7e6e747a1b1de542ce6a12066/grpcio_tools-1.80.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:865a2b8e6334c838976ab02a322cbd55c863d2eaf3c1e1a0255883c63996772a", size = 3328786, upload-time = "2026-03-30T08:51:37.265Z" },
-    { url = "https://files.pythonhosted.org/packages/eb/63/23ab7db01f9630ab4f3742a2fc9fbff38b0cfc30c976114f913950664a75/grpcio_tools-1.80.0-cp313-cp313-win32.whl", hash = "sha256:f760ac1722f33e774814c37b6aa0444143f612e85088ead7447a0e9cd306a1f1", size = 997087, upload-time = "2026-03-30T08:51:39.137Z" },
-    { url = "https://files.pythonhosted.org/packages/9b/af/b1c1c4423fb49cb7c8e9d2c02196b038c44160b7028b425466743c6c81fa/grpcio_tools-1.80.0-cp313-cp313-win_amd64.whl", hash = "sha256:7843b9ac6ff8ca508424d0dd968bd9a1a4559967e4a290f26be5bd6f04af2234", size = 1162167, upload-time = "2026-03-30T08:51:41.498Z" },
-    { url = "https://files.pythonhosted.org/packages/0e/44/7beeee2348f9f412804f5bf80b7d13b81d522bf926a338ae3da46b2213b7/grpcio_tools-1.80.0-cp314-cp314-linux_armv7l.whl", hash = "sha256:12f950470449dbeec78317dbc090add7a00eb6ca812af7b0538ab7441e0a42c3", size = 2550303, upload-time = "2026-03-30T08:51:44.373Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/aa/f77dd85409a1855f8c6319ffc69d81e8c3ffe122ee3a7136653e1991d8b6/grpcio_tools-1.80.0-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:d3f9a376a29c9adf62bb56f7ff5bc81eb4abeaf53d1e7dde5015564832901a51", size = 5709778, upload-time = "2026-03-30T08:51:47.112Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/7c/ab7af4883ebdfdc228b853de89fed409703955e8d47285b321a5794856bd/grpcio_tools-1.80.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1ba1ffbf2cff71533615e2c5a138ed5569611eec9ae7f9c67b8898e127b54ac0", size = 2597928, upload-time = "2026-03-30T08:51:49.494Z" },
-    { url = "https://files.pythonhosted.org/packages/22/e8/4381a963d472e3ab6690ba067ed2b1f1abf8518b10f402678bd2dcb79a54/grpcio_tools-1.80.0-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:13f60f8d9397c514c6745a967d22b5c8c698347e88deebca1ff2e1b94555e450", size = 2909333, upload-time = "2026-03-30T08:51:52.124Z" },
-    { url = "https://files.pythonhosted.org/packages/94/cb/356b5fdf79dd99455b425fb16302fe60995554ceb721afbf3cf770a19208/grpcio_tools-1.80.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:88d77bad5dd3cd5e6f952c4ecdd0ee33e0c02ecfc2e4b0cbee3391ac19e0a431", size = 2660217, upload-time = "2026-03-30T08:51:55.066Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/d7/1752018cc2c36b2c5612051379e2e5f59f2dbe612de23e817d2f066a9487/grpcio_tools-1.80.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:017945c3e98a4ed1c4e21399781b4137fc08dfc1f802c8ace2e64ef52d32b142", size = 3113896, upload-time = "2026-03-30T08:51:57.3Z" },
-    { url = "https://files.pythonhosted.org/packages/cc/17/695bbe454f70df35c03e22b48c5314683b913d3e6ed35ec90d065418c1ab/grpcio_tools-1.80.0-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:a33e265d4db803495007a6c623eafb0f6b9bb123ff4a0af89e44567dad809b88", size = 3661950, upload-time = "2026-03-30T08:51:59.867Z" },
-    { url = "https://files.pythonhosted.org/packages/9c/d0/533d87629ec823c02c9169ee20228f734c264b209dcdf55268b5a14cde0a/grpcio_tools-1.80.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:6c129da370c5f85f569be2e545317dda786a60dd51d7deea29b03b0c05f6aac3", size = 3328755, upload-time = "2026-03-30T08:52:02.942Z" },
-    { url = "https://files.pythonhosted.org/packages/08/a1/504d7838770c73a9761e8a8ff4869dba1146b44f297ff0ac6641481942d3/grpcio_tools-1.80.0-cp314-cp314-win32.whl", hash = "sha256:25742de5958ae4325249a37e724e7c0e5120f8e302a24a977ebd1737b48a5e97", size = 1019620, upload-time = "2026-03-30T08:52:05.342Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/75/8b7cd281c5cdfb4ca2c308f7e9b2799bab2be6e7a9e9212ea5a82e2aecd4/grpcio_tools-1.80.0-cp314-cp314-win_amd64.whl", hash = "sha256:bbf8eeef78fda1966f732f79c1c802fadd5cfd203d845d2af4d314d18569069c", size = 1194210, upload-time = "2026-03-30T08:52:08.105Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/e1/1fcf884902ae7255d8da224cfa638ea88a46d50f62a33d06d35c8960b029/grpcio_tools-1.81.1-cp310-cp310-linux_armv7l.whl", hash = "sha256:9b6ba8a72cfda576508701a7c0bbeebe6f6f9843320d4f12e74efd19ddccd965", size = 2586261, upload-time = "2026-06-11T12:49:21.447Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/d7/1815110b2d40ec99dbb0a7e6d7eafd591cd1f1e9bf9d3858cd9cf3ffacbd/grpcio_tools-1.81.1-cp310-cp310-macosx_11_0_universal2.whl", hash = "sha256:ac47a9ea1224df8b653072614e6f0207e9fbfe63fdabaa5918a60ca5fc931b88", size = 5817509, upload-time = "2026-06-11T12:49:25.958Z" },
+    { url = "https://files.pythonhosted.org/packages/23/e8/af99579842b5a555312fa782f32ce0f99bd35b2b7a1243294b2755468857/grpcio_tools-1.81.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:eac4bb645ceff0c147cc720a40ae68f97427eaafb4968e866dd8fcc20d3d4831", size = 2634112, upload-time = "2026-06-11T12:49:27.937Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/cd/235ad56ac728c49c17e9218c4daccd5831e6ec7af94236bec0cc66c71c68/grpcio_tools-1.81.1-cp310-cp310-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:cc410b621dd85193766c12dca2e238696199a27a65d2b31b6f0a4c6c0043ff26", size = 2957950, upload-time = "2026-06-11T12:49:29.619Z" },
+    { url = "https://files.pythonhosted.org/packages/77/3e/9103e8b4610597bf89db49eb112091c91bf5d63ddef2a951e11a4be05f2b/grpcio_tools-1.81.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b62d254c214faa3773eac709376ae25cf7abff1a76ba5fc4dbcd7b14fc4e4ae6", size = 2697765, upload-time = "2026-06-11T12:49:31.702Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/86/beb2a43fbb93570a2305696083f6736566301d957869f463308ec6839f95/grpcio_tools-1.81.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:bd0b68dc76b10b3384b9b6e9f59202b83dcaafd8098eb644759a69316686acf8", size = 3147588, upload-time = "2026-06-11T12:49:33.748Z" },
+    { url = "https://files.pythonhosted.org/packages/af/4d/b0182d9948631cd837a372b6625cf59d6e335d4aab0f425d4b7306619074/grpcio_tools-1.81.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:a28d231455ab6e3558299f7d831a73c8be8ee6b7ec614ecf39eb50c0ed15767f", size = 3708798, upload-time = "2026-06-11T12:49:35.979Z" },
+    { url = "https://files.pythonhosted.org/packages/23/9b/f452a189d399051d85cf82fe2f27a070efaa52512a2c5e3ae6ef1ae99a1f/grpcio_tools-1.81.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:82740248eb6f3b6a38988cb5e64adb7303af9ea5cb4197c8ed08c1fabc767440", size = 3366969, upload-time = "2026-06-11T12:49:37.911Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/48/0075cb4f6ae7db280f461de2dbba700b22ae62e351ae13e6e461cd6804de/grpcio_tools-1.81.1-cp310-cp310-win32.whl", hash = "sha256:801d9d8ab5cddf8f8e064225292f0713427011252a07828a6b54e2ed64d534de", size = 1008713, upload-time = "2026-06-11T12:49:39.791Z" },
+    { url = "https://files.pythonhosted.org/packages/17/bd/7692bc698259e5645b68720e77e7b176d376f6ae0c9db8b5b750a02f1958/grpcio_tools-1.81.1-cp310-cp310-win_amd64.whl", hash = "sha256:3c8611d6e4e859ac5373422ef27c4b7540cf98c9991c9abc6722613ef72b13aa", size = 1174752, upload-time = "2026-06-11T12:49:41.43Z" },
+    { url = "https://files.pythonhosted.org/packages/18/76/14ff87090199a36f914388299a1148d0734a20cea1b0ca8480bae1f373f1/grpcio_tools-1.81.1-cp311-cp311-linux_armv7l.whl", hash = "sha256:8161f398f957a376cae7385ea7c8684f439d460ef702b528912da3bcb31fc515", size = 2586251, upload-time = "2026-06-11T12:49:43.514Z" },
+    { url = "https://files.pythonhosted.org/packages/87/a8/d5aa99de9d8b2dd2a8192c1779796eda8b0d0f1dd915422e0a8a61b80391/grpcio_tools-1.81.1-cp311-cp311-macosx_11_0_universal2.whl", hash = "sha256:53ef76cc3b0493ff734a5e8c39d5b519e1822236fcccdfe7677c5e1efd767761", size = 5818063, upload-time = "2026-06-11T12:49:45.975Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/cb/2e9a6dbc6a514dd3cd264fb3bf9217937453a4d45dbc3ca6ca4ee34ba1a7/grpcio_tools-1.81.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:690e6dcaa8b8a7886ce206ba344e2127211597e1a1ddab73df9f3d80c8f6707e", size = 2634061, upload-time = "2026-06-11T12:49:48.13Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/2b/2ccd1a929e6c8ad84a0aa8d66ad9f615b4a8e79d9927373d86aa36b4ba2e/grpcio_tools-1.81.1-cp311-cp311-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:ad7a997c07bd345e84842e60561e7e2cc090ce6c4e1d2f0407e31b85b40fc49a", size = 2958029, upload-time = "2026-06-11T12:49:50.466Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/67/2da8cd312edc348f44f26f82096b25cdb7d2905cd786acc6bf777b169502/grpcio_tools-1.81.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b6bd163ece4535726e5292b845ed80ae9b2cae73ba091c7d6c66033c430e3857", size = 2698031, upload-time = "2026-06-11T12:49:52.292Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/ba/ad1680fbdf9317c4f1e54c37c96d1f422370df66ac9adbd175c7cb3531d7/grpcio_tools-1.81.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2baa7e735f35b2a648144c03348a126097b13e101d3c242d5edb6ac91437ccbe", size = 3147541, upload-time = "2026-06-11T12:49:54.43Z" },
+    { url = "https://files.pythonhosted.org/packages/57/c1/57cd08eef293d713cb8935295e4f08d8f0013480b2ba3aad1af0271eb7ba/grpcio_tools-1.81.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:1d602b410b2b2addc434cace9ce4fe2035974a3078228f98ffa049a5c90acc2f", size = 3708524, upload-time = "2026-06-11T12:49:56.544Z" },
+    { url = "https://files.pythonhosted.org/packages/52/31/01ea8ca9c82fe2c79b5b594c3ae427d56699bc106b2d91caca129add8b10/grpcio_tools-1.81.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f8cb64f87c45ccca8234fa47e6b21f09e43801ff11b556deecb461b3b3e9f292", size = 3367022, upload-time = "2026-06-11T12:49:59.608Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/35/8140cd175602df3d17215cfb28a7ea55b7a67e2b872be76e1ee4af5c4df9/grpcio_tools-1.81.1-cp311-cp311-win32.whl", hash = "sha256:87b25ca0e27373a4a32a629a4ba976f5764b9887dd50d6fe017d38009a0363e8", size = 1008980, upload-time = "2026-06-11T12:50:01.422Z" },
+    { url = "https://files.pythonhosted.org/packages/be/86/1bd29ab3c52457702b96536f1f208ab27695322d855f95c9666dfb713019/grpcio_tools-1.81.1-cp311-cp311-win_amd64.whl", hash = "sha256:204de03b539a4b08772c6553b92bcc112cbc965e0ac22f909f6d133b8ac33a8c", size = 1174840, upload-time = "2026-06-11T12:50:03.408Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/8a/824a9ca20bcdce8a568bb8c9f98bfeb7fad62129235e6d2ae7576fd1250a/grpcio_tools-1.81.1-cp312-cp312-linux_armv7l.whl", hash = "sha256:353b1fafcc739c31ed42271052709595b340d34f27c459beeb78a32938305bb5", size = 2585927, upload-time = "2026-06-11T12:50:05.671Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/35/e5f9f671378b1b89a896150d3e4fa2c6ec61a5e1e9e5107ce4c140ccc931/grpcio_tools-1.81.1-cp312-cp312-macosx_11_0_universal2.whl", hash = "sha256:768f584c2423cbeb6cb6867817a39365b987ff16b8259a3adbc6546b9e303a4e", size = 5815665, upload-time = "2026-06-11T12:50:08.178Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/02/631b628e4072e988c669bd8f1b2406ef3c9a4cfcb2625bbf2a308a07b71d/grpcio_tools-1.81.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:1680b35a84f4694401819ac4acac42dda6dbc7bb8fc74112fd1a60425a07adf4", size = 2635518, upload-time = "2026-06-11T12:50:10.391Z" },
+    { url = "https://files.pythonhosted.org/packages/de/7c/2e3537e3ea3d1c0ddd6766cf6a7c62b487d89fb005713df2781d5f21483a/grpcio_tools-1.81.1-cp312-cp312-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:f64e665c8ec639278ecf009beb92cbdcc5994f617c1af3d58036e1f70b1423ec", size = 2958252, upload-time = "2026-06-11T12:50:12.677Z" },
+    { url = "https://files.pythonhosted.org/packages/35/68/14013cb2942bdac354746b643b4c37dd91906da8dce00f41c616e88bf33d/grpcio_tools-1.81.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ba8f1ae82ad199f43448995715445cc623fb20d3882382e4be61f0da8ccb3f0e", size = 2698439, upload-time = "2026-06-11T12:50:15.017Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/45/000c14c0338a7ad36054b9f17ea41842deb7841c05c067dd36cc831bc0f4/grpcio_tools-1.81.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:b7b6d1e986d5923751bfe2b5cca9c4cb3d5653446e4fa4aacd438033e2dc360a", size = 3152160, upload-time = "2026-06-11T12:50:17.3Z" },
+    { url = "https://files.pythonhosted.org/packages/41/97/881930ca3967d2c8a95649bea8ebc991a7cf2331bc96679fd3600450dccc/grpcio_tools-1.81.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:7f208c207aca639dcb34648d3826c38d7cf3485118fb2065117e9fc4827406b3", size = 3710468, upload-time = "2026-06-11T12:50:19.479Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/b5/67baeba7366162652cdc1dbd962289accde07241bc8f42f6f02b305efcc6/grpcio_tools-1.81.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:724ecb69af63d2f6d4ccea3e6fa0ca110ed9c5824d48c2f887c631bbb03c1c3c", size = 3370797, upload-time = "2026-06-11T12:50:21.501Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/5d/34f2dce2125ccb107e32b57f5a9c1257edcc0793b0d2fef1e8b13a6bac3c/grpcio_tools-1.81.1-cp312-cp312-win32.whl", hash = "sha256:895a6782cec86beac71ccebb4b9848259c6f04a3028b8e42fa8d40cfe5146593", size = 1008453, upload-time = "2026-06-11T12:50:23.358Z" },
+    { url = "https://files.pythonhosted.org/packages/8a/be/09da8256ec8d2a5ce8a1acc51cbbc4ca52a462d78ed3412778440a56502e/grpcio_tools-1.81.1-cp312-cp312-win_amd64.whl", hash = "sha256:0265fd1386b7458302f79542558345880d484f8fa92ae196c0c0268242c5f23a", size = 1174857, upload-time = "2026-06-11T12:50:25.685Z" },
+    { url = "https://files.pythonhosted.org/packages/76/90/5faa8b26e03495e5117f93bef8293cbada4af136362745dad7d1813ef0b0/grpcio_tools-1.81.1-cp313-cp313-linux_armv7l.whl", hash = "sha256:3d604b4fd114b79ebb9f865bf3e04fd3ae93c704e1fad96f7fd03b0865c263b7", size = 2586071, upload-time = "2026-06-11T12:50:28.4Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/9a/85dc589fa6ae2439451eaa81a1578de31e29c676980d38bef7549b8a1f45/grpcio_tools-1.81.1-cp313-cp313-macosx_11_0_universal2.whl", hash = "sha256:3389e705460efa3f3758141ba5520e6743b131c9576197c944fb9cbe49048126", size = 5813299, upload-time = "2026-06-11T12:50:31.295Z" },
+    { url = "https://files.pythonhosted.org/packages/77/fd/c53994e58a837e6eefe48f53eb3492afc04f2b8af255df4adb37d14378f8/grpcio_tools-1.81.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8a17d8ceeb6a855fadf39f5171c80a382d97c4db98d5943eca553497fdebf84b", size = 2634668, upload-time = "2026-06-11T12:50:33.938Z" },
+    { url = "https://files.pythonhosted.org/packages/34/32/de988e86688686a2117e7ce6ce9eff4f638c929bb55b0afe60d6fbd2e45c/grpcio_tools-1.81.1-cp313-cp313-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:43baf71dc60fd653062da2e95e95c73b35dd130be8f9fa3d544c3af3f808a290", size = 2957930, upload-time = "2026-06-11T12:50:36.726Z" },
+    { url = "https://files.pythonhosted.org/packages/72/97/3f18a0ea32b5f809d21961dbd0bc382b589a4c3d501e3d67c345d5456ed3/grpcio_tools-1.81.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:136e90906af0df51ad929713244ba812d0dbb1844b4f467d5d86bdb054698f90", size = 2697760, upload-time = "2026-06-11T12:50:39.108Z" },
+    { url = "https://files.pythonhosted.org/packages/49/c0/dbf5cbc877290ff7504a59959a8af4fdcfdaa1e84237948405ccf1aa82a6/grpcio_tools-1.81.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:bd6c3bf3ea6a61eb58c54368d72ada591f2a270f3a31a32e8536e773337e76d9", size = 3151456, upload-time = "2026-06-11T12:50:41.983Z" },
+    { url = "https://files.pythonhosted.org/packages/de/ea/16fe2dc83140a59e5c0a0b9dc2693dd36bfaa6bd835724b4ec66a68eab7b/grpcio_tools-1.81.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c306c307f8f74cddc4056fdbb6f1da55de087a21120efbd02bd915daa5a52fd", size = 3710469, upload-time = "2026-06-11T12:50:44.596Z" },
+    { url = "https://files.pythonhosted.org/packages/22/7d/df987d7d81e7ad2f7516d9e9d56ff29c54dbc6d8587e425688dca9a28e49/grpcio_tools-1.81.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:bdbdc927be2e0ea13c32564a72ee31d712a716fb6f8c0d53d37a77d8277c272c", size = 3370488, upload-time = "2026-06-11T12:50:47.199Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/c5/5a63444d694ea47bf670138208f71830cc1759c402c8818092b28ab2dc5f/grpcio_tools-1.81.1-cp313-cp313-win32.whl", hash = "sha256:9d383724bcd67244b6def9e9164c640ee9380c0b7534ee7545a6fb0022a59afe", size = 1008229, upload-time = "2026-06-11T12:50:49.527Z" },
+    { url = "https://files.pythonhosted.org/packages/00/75/3945e26d5c94ae6ed9be5caef73d4d66c47dc8cfdd7b4995efaf942754e0/grpcio_tools-1.81.1-cp313-cp313-win_amd64.whl", hash = "sha256:f3eb15849979ca7bb864ce81a74d68b0f225a7f111ed3fe212bfc08cf9812b10", size = 1174523, upload-time = "2026-06-11T12:50:51.755Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/08/e581ad42ae517a61172285047e4d710e2ac75f2f1915f7c91f284254e6d5/grpcio_tools-1.81.1-cp314-cp314-linux_armv7l.whl", hash = "sha256:7d168ea26390717d0462c0d0408331dc98a60fc7f7e6118afac9b73f5a66d87c", size = 2585944, upload-time = "2026-06-11T12:50:54.528Z" },
+    { url = "https://files.pythonhosted.org/packages/78/c8/200d90ebad685af7eea5ff7e0360c504dd01ec053fe0f1f9c4abe3ea2d5a/grpcio_tools-1.81.1-cp314-cp314-macosx_11_0_universal2.whl", hash = "sha256:43c528655b226375013036692d8db4cd59060c1f41dd62c77f4d17b69f6ce828", size = 5813492, upload-time = "2026-06-11T12:50:57.291Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c0/60da2a1af37aa8eb47308cec24d9f7709a8976fdec3a53fd35b56b358326/grpcio_tools-1.81.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a9c6fcc68c9d5a208967bfe4fd3224d3c3be9a950c3e827e8f4b17e15c2dc555", size = 2634991, upload-time = "2026-06-11T12:50:59.767Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/7f/dede28b579ae9bf9079ba1aa913e8088d1dc0cdbe21c85caa22f0790cad2/grpcio_tools-1.81.1-cp314-cp314-manylinux2014_i686.manylinux_2_17_i686.whl", hash = "sha256:a987c85dcbe1b32066d7acd46266d1a428aecbd629331bf5b853e74c835bf876", size = 2957913, upload-time = "2026-06-11T12:51:02.31Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/38/4de2118adb58ec7ffba65ec623b5836db769665c192517cbf187db3f6145/grpcio_tools-1.81.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:a882382507bb5ec6d7edc9648053dfd3bc8f9285cde56a6fa9b9a83b4bd07f1c", size = 2697709, upload-time = "2026-06-11T12:51:05.016Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/e1/762ced51059e4f694fd337ecae491581d42a4e61dcb0415d8c5c60e6ddcb/grpcio_tools-1.81.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:7746e508d4239a02f7e93638be5bc0ebb0120ddb796f7506aaae9d47a4599d97", size = 3151884, upload-time = "2026-06-11T12:51:07.593Z" },
+    { url = "https://files.pythonhosted.org/packages/19/d8/9823090dc801e7229944874e7429c3b98e741ac778d8dc373f60240e1c43/grpcio_tools-1.81.1-cp314-cp314-musllinux_1_2_i686.whl", hash = "sha256:fc3d2a41a7a4467fa03b391394fffada9291fe8feebc8679b526f6bc36942b25", size = 3710404, upload-time = "2026-06-11T12:51:10.172Z" },
+    { url = "https://files.pythonhosted.org/packages/64/4e/4eae98d02148cb6f9f452f09942afba407afa6851e6c1fddc5ae9ec0b4ed/grpcio_tools-1.81.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:21bb3ba90e6d8df1ff663d4ee39a4e5b25a64e8ed4902476ca9ded0954d3917a", size = 3370525, upload-time = "2026-06-11T12:51:12.678Z" },
+    { url = "https://files.pythonhosted.org/packages/e0/3e/2206e597a128da6a03a6106d2eaf2c3e72c7d80843d4be933e3a3d10d02a/grpcio_tools-1.81.1-cp314-cp314-win32.whl", hash = "sha256:3dca56016d90a710c4d9861bae793dc089c1430a90c79ce672e948ddb65fa539", size = 1030582, upload-time = "2026-06-11T12:51:14.906Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/f2/bbeef86c687225b7bbc7c0acdfbd25c8bcaa3f5b1c941db053e5c3d9e859/grpcio_tools-1.81.1-cp314-cp314-win_amd64.whl", hash = "sha256:cb08172b7b629e75cb33866928d319a3196540a725eaab628ba721007140f1af", size = 1207490, upload-time = "2026-06-11T12:51:17.598Z" },
 ]
 
 [[package]]
@@ -1418,7 +1418,8 @@ dependencies = [
     { name = "pyyaml" },
     { name = "tenacity" },
     { name = "typing-extensions" },
-    { name = "uuid-utils" },
+    { name = "uuid-utils", version = "0.13.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or python_full_version >= '3.14'" },
+    { name = "uuid-utils", version = "0.19.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.14'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/ed/ed/ceecd3bfcfc77a94cf30a9f1506e907fdea447458825e01914a72d2d1a6f/langchain_core-1.6.5.tar.gz", hash = "sha256:bdb059fef65473fd444558dbb18f50901657402c43ceed9dc0fdc7b76a393c6b", size = 1007041, upload-time = "2026-09-24T18:11:06.487Z" }
 wheels = [
@@ -1439,7 +1440,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.19"
+version = "1.2.20"
 source = { editable = "." }
 dependencies = [
     { name = "langchain-core" },
@@ -1582,9 +1583,10 @@ test = [
 
 [[package]]
 name = "langgraph-api"
-version = "0.10.0"
+version = "0.17.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
+    { name = "anyio" },
     { name = "cloudpickle" },
     { name = "cryptography" },
     { name = "grpcio" },
@@ -1602,8 +1604,10 @@ dependencies = [
     { name = "langsmith", extra = ["otel"] },
     { name = "opentelemetry-api" },
     { name = "opentelemetry-exporter-otlp-proto-http" },
+    { name = "opentelemetry-exporter-prometheus" },
     { name = "opentelemetry-sdk" },
     { name = "orjson" },
+    { name = "prometheus-client" },
     { name = "protobuf" },
     { name = "pyjwt" },
     { name = "sse-starlette" },
@@ -1611,16 +1615,16 @@ dependencies = [
     { name = "structlog" },
     { name = "tenacity" },
     { name = "truststore" },
-    { name = "uuid-utils" },
+    { name = "uuid-utils", version = "0.19.0", source = { registry = "https://pypi.org/simple" } },
     { name = "uvicorn" },
     { name = "uvloop", marker = "sys_platform != 'win32'" },
     { name = "watchfiles" },
     { name = "websockets" },
     { name = "zstandard" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/7d/17/a23ecdad3de7e48209bc8d534312ba83e332126ec60da9e6487461b02597/langgraph_api-0.10.0.tar.gz", hash = "sha256:f594a160857e2cd7fb2352bba585111177a4a394625ad0cf5898814754fb7bc1", size = 713903, upload-time = "2026-06-11T14:36:50.469Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/33/c2/3a5baab0dd010dffdbf92fecd34f0fe25d4fac42281469ed8b494e4b3511/langgraph_api-0.17.1.tar.gz", hash = "sha256:08bf7df9cc2bd7e45fbf2f1cb97267264f149794032010e55dafb50d64cbded7", size = 886040, upload-time = "2026-11-03T21:27:09.883Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0e/38/6b0cdcaaed9b3105102b452a5a70fb08894a9511458cf00c061c4725347c/langgraph_api-0.10.0-py3-none-any.whl", hash = "sha256:f4b545bf1936c4e90bed1cc07a6852b1be37e1667007ab4736d800cc18e9f9b3", size = 577475, upload-time = "2026-06-11T14:36:48.838Z" },
+    { url = "https://files.pythonhosted.org/packages/89/84/a61803f1a2dd895718abbe4dbb076bb19ff04238c36d217697f5a485188e/langgraph_api-0.17.1-py3-none-any.whl", hash = "sha256:e070f5675713adf3322ba993992e618f5ec587ec0aec80441c563dfc404d14f2", size = 663034, upload-time = "2026-11-03T21:27:07.552Z" },
 ]
 
 [[package]]
@@ -1874,7 +1878,7 @@ test = [
 
 [[package]]
 name = "langgraph-runtime-inmem"
-version = "0.30.0"
+version = "0.37.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "blockbuster" },
@@ -1885,9 +1889,9 @@ dependencies = [
     { name = "starlette" },
     { name = "structlog" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/98/19/5d330e22e3ee2569742d3577b4ddfbb6b8e383f2edd9724b4a4b73735717/langgraph_runtime_inmem-0.30.0.tar.gz", hash = "sha256:31954e1de6cd43c284b425243d4faeae818f68b3daca4dbe4313e651b6f5e11d", size = 129940, upload-time = "2026-06-11T14:22:46.985Z" }
+sdist = { url = "https://files.pythonhosted.org/packages/a3/03/96d55a65eedf319da923a93e99d7a879364e0cd5b1159a15b7a58f2eaf9b/langgraph_runtime_inmem-0.37.1.tar.gz", hash = "sha256:c52a5105d0559994b3c9218a67eee3e746b65eb7b40d731ebb7d87247683395f", size = 142119, upload-time = "2026-11-03T21:20:31.19Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fe/df/cfb15c70fa4dcab9ea48f8fda9f4ed87d1767eea6e4d2901dc704da297ba/langgraph_runtime_inmem-0.30.0-py3-none-any.whl", hash = "sha256:08a36b83b5e32fe6e30cb25062a1e671a42e2a0206e4043cc95f41198dcbbb12", size = 51762, upload-time = "2026-06-11T14:22:46.012Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/bc/df823ed5cdf54cac16a85fb7f0bc4dde9a77a736b0ce1d38e9da97e620af/langgraph_runtime_inmem-0.37.1-py3-none-any.whl", hash = "sha256:b6504d50970e962947bd43a1dd2666b4f1f069d8fa08da6b7364b3f5a23b35a9", size = 62099, upload-time = "2026-11-03T21:20:29.734Z" },
 ]
 
 [[package]]
@@ -1947,7 +1951,8 @@ dependencies = [
     { name = "pydantic" },
     { name = "requests" },
     { name = "requests-toolbelt" },
-    { name = "uuid-utils" },
+    { name = "uuid-utils", version = "0.13.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.11' or python_full_version >= '3.14'" },
+    { name = "uuid-utils", version = "0.19.0", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.11' and python_full_version < '3.14'" },
     { name = "websockets" },
     { name = "xxhash" },
     { name = "zstandard" },
@@ -2248,6 +2253,20 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/1f/517eaa0187ba106a9da97160ce2add3a371812681dc440930b267f714e42/opentelemetry_exporter_otlp_proto_http-1.45.1-py3-none-any.whl", hash = "sha256:24a97cf3753c7fb52fad44a696e452ff371686339e2acf3309e2eda3d0230700", size = 22180, upload-time = "2026-10-06T17:32:43.946Z" },
 ]
 
+[[package]]
+name = "opentelemetry-exporter-prometheus"
+version = "0.66b1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "opentelemetry-api" },
+    { name = "opentelemetry-sdk" },
+    { name = "prometheus-client" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ed/58/e552853748c3a1478d3f0db31bb4e3bef2e45385f64d658148693183410e/opentelemetry_exporter_prometheus-0.66b1.tar.gz", hash = "sha256:1c702a0cc7a1b8c5e1f3f246aeb4273dbd707179af30dbb66182a75e16a06ed8", size = 16987, upload-time = "2026-10-06T17:33:06.358Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/8a/5e7262d970586a8d69dd159bebc68fbee7457088883b179599a562881a6f/opentelemetry_exporter_prometheus-0.66b1-py3-none-any.whl", hash = "sha256:a938e6af7295d5bacf82da9ca845cab9a9cb1c5f565abe39f54ef8bf511c05d9", size = 13222, upload-time = "2026-10-06T17:32:44.94Z" },
+]
+
 [[package]]
 name = "opentelemetry-proto"
 version = "1.45.1"
@@ -3730,6 +3749,11 @@ wheels = [
 name = "uuid-utils"
 version = "0.13.0"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.15'",
+    "python_full_version == '3.14.*'",
+    "python_full_version < '3.11'",
+]
 sdist = { url = "https://files.pythonhosted.org/packages/fe/8a/17b11768dcb473d3a255c02ffdd94fbd1b345c906efea0a39124dcbaed52/uuid_utils-0.13.0.tar.gz", hash = "sha256:4c17df6427a9e23a4cd7fb9ee1efb53b8abb078660b9bdb2524ca8595022dfe1", size = 21921, upload-time = "2026-01-08T15:48:10.841Z" }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/85/b8/d40848ca22781f206c60a1885fc737d2640392bd6b5792d455525accd89c/uuid_utils-0.13.0-cp39-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:83628283e977fb212e756bc055df8fdd2f9f589a2e539ba1abe755b8ce8df7a4", size = 602130, upload-time = "2026-01-08T15:47:34.877Z" },
@@ -3755,6 +3779,69 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/0a/20/a6929e98d9a461ca49e96194a82a1cc3fd5420f3a2f53cbb34fca438549e/uuid_utils-0.13.0-pp311-pypy311_pp73-manylinux_2_24_x86_64.whl", hash = "sha256:b7ccaa20e24c5f60f41a69ef571ed820737f9b0ade4cbeef56aaa8f80f5aa475", size = 333610, upload-time = "2026-01-08T15:48:09.375Z" },
 ]
 
+[[package]]
+name = "uuid-utils"
+version = "0.19.0"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version >= '3.11' and python_full_version < '3.14'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f1/0f/cd9b3e495e514441e9af3a42c5c63436aee620f61412cafcce67e259228b/uuid_utils-0.19.0.tar.gz", hash = "sha256:4b2996bb9d12da9b62f6f4c64a066b26926fa75dbe47b4f8e309e24e187abf1d", size = 43343, upload-time = "2026-10-26T10:55:23.821Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/fa/ce/78f9d79c820b8afc9b0498b0a5f5ef87ea970a19cc382127087f36cd4839/uuid_utils-0.19.0-cp310-abi3-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:84929d8c594381c6f1444afa2a25cce9ff7edac99d35e071ebc48275bae83730", size = 574701, upload-time = "2026-10-26T10:54:06.751Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/63/fe81dda73d651fb6bf8b0e21c4ea34209fc535ca109634c0d93f14ac21dc/uuid_utils-0.19.0-cp310-abi3-macosx_10_12_x86_64.whl", hash = "sha256:a416c78167b750186095a0ea950d95b8b4e157e3172fc6ccdc317b6ca2896580", size = 294226, upload-time = "2026-10-26T10:54:08.422Z" },
+    { url = "https://files.pythonhosted.org/packages/81/6c/118c7e11fb579b5631212bfbbb31542a1778936dfb7c55591aa9b52c7c99/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82573c0e5090732c0ae2e18626e06cb35fe7cfcf6fe9534d4c1638af41d25d36", size = 327869, upload-time = "2026-10-26T10:54:10.016Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/76/80e9bad735cbf92f127183ee5c44ee0d83604e56197bddcaaaed2c66f7e6/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:c78d527fddf5495e80032caeca2f140731ef394298ef4cbecaaf51aa2c257e1e", size = 334737, upload-time = "2026-10-26T10:54:11.434Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/7b/c8eb8e45569e8681f20e381859248d18635d823b8aedc70de8a0bd5faca6/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3c33b5c62cf82d509945c770201b1656448c2560e12931d1a8d698a683e9125d", size = 440438, upload-time = "2026-10-26T10:54:12.864Z" },
+    { url = "https://files.pythonhosted.org/packages/be/45/8238eac588b668e5c500cb187fd74a9f6d984c09f3f3f2fa4161d3c07eb7/uuid_utils-0.19.0-cp310-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b8060530a8fa27f11947489c79bc36e6ebb465b2d714945364dc397283309417", size = 330342, upload-time = "2026-10-26T10:54:14.309Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/45/8215129786e67842d479480a44066cac8a7086f345ac9707f629ed777cfe/uuid_utils-0.19.0-cp310-abi3-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:96429c78eab28ac71b2121fb47c66783bfe5d06632b5bd5200004707fdc0faad", size = 354275, upload-time = "2026-10-26T10:54:15.753Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/bc/a673bfd116eb26419dd82bffa9bc2bc1e915af02bf68ac8c09598dc678ec/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:80e0b37b3ddf60c50c51b869e1b02df61415941aa68bc903f61562fd8df04b18", size = 504446, upload-time = "2026-10-26T10:54:17.45Z" },
+    { url = "https://files.pythonhosted.org/packages/af/ff/61867210f202c603d4a5ca1c5b3c4c76e8d8724eeebd7cf1307d18b63a9a/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_armv7l.whl", hash = "sha256:f629f2a4f95e46d99ee673536ab9706899696cdc6686e93314ea756d3b394ce4", size = 609016, upload-time = "2026-10-26T10:54:18.914Z" },
+    { url = "https://files.pythonhosted.org/packages/42/81/6fb8a2ee8010a6a0c5cb29f5efed2604717613cc9888f9e5c999dc36b84b/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_i686.whl", hash = "sha256:ec330297c09e40b82d613326b57bb381d68535e8a341fa2e501b46791cbdfeec", size = 570293, upload-time = "2026-10-26T10:54:20.328Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/2f/e1c749b65c584ebd8bc5379cf18e26c67cdff8f2bd9f8f77111a47083408/uuid_utils-0.19.0-cp310-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:313de97d59dbbb09f4598cece2c799cc233d8673bb075ad7eff442cd485623c2", size = 535321, upload-time = "2026-10-26T10:54:21.735Z" },
+    { url = "https://files.pythonhosted.org/packages/87/ba/f423f68fd784124e68ab1b1afe27ab4591ffd5363b39eccfcbaf8f3b0ff3/uuid_utils-0.19.0-cp310-abi3-pyemscripten_2025_0_wasm32.whl", hash = "sha256:5c47c7fc35e91a801996477f0d746d506a2e5b47a13accbf41dc29844786c40c", size = 103141, upload-time = "2026-10-26T10:54:23.192Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/9a/7a0a0dad166db9f4437f3d259e47ce74d552ccc50d8aa63d05b2510e3096/uuid_utils-0.19.0-cp310-abi3-pyemscripten_2026_0_wasm32.whl", hash = "sha256:23868cdc4dfa71021fec6cf43fbb83797345362ac1c866b50dbf17f479587413", size = 103069, upload-time = "2026-10-26T10:54:24.709Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/3c/c5fef96cea027de66a035b4173951fc29c2e83ed49a5d5b3fa7b632f95b5/uuid_utils-0.19.0-cp310-abi3-win32.whl", hash = "sha256:0cff166cf6348e9a705740e6575ce7bc727554a71a6add60b9ceceaaf169002a", size = 175479, upload-time = "2026-10-26T10:54:25.949Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/16/edfb8edc8a4624cfaf1387a57bf37cd53e5d7f213ebeb8dd6fbd2f6b2c64/uuid_utils-0.19.0-cp310-abi3-win_amd64.whl", hash = "sha256:b763ae8f23334ccd95d0b81fb19ee418f38f9e80ebfb521f313a9745280bc07c", size = 182891, upload-time = "2026-10-26T10:54:27.527Z" },
+    { url = "https://files.pythonhosted.org/packages/63/17/258e5dd380bc594731b2b705082360fb4cef1e5cbaab46ef307439a6f415/uuid_utils-0.19.0-cp310-abi3-win_arm64.whl", hash = "sha256:b244ea25bfe1b34e40fabf8f079d59a9f153b22bd4095842065bb0a9dfaa477b", size = 180849, upload-time = "2026-10-26T10:54:28.86Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/64/b5554f686d5395db970bc07944b9c59c26ab0e192a27d7c8b555e5fc6332/uuid_utils-0.19.0-cp314-cp314t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:9adf8d69574f0018a25aed0cc194bffacc05fb91b922fdd8e794109c45ad80ed", size = 565592, upload-time = "2026-10-26T10:54:30.242Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/a3/d8d0b7bf4892c41dbbb0e81a356d20aad781cc28d3029669e167eb72d9a1/uuid_utils-0.19.0-cp314-cp314t-macosx_10_12_x86_64.whl", hash = "sha256:ac37f30acc7fe01266c73f19a686d0ea1fbd22495d81205cc3b572e2fb2293a6", size = 292083, upload-time = "2026-10-26T10:54:32.053Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c1/770ccb569b4c15ee81c36bc40e74f03c5e0a2ee71ecc534d3fe7cfa5696d/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:afc1dc05c83163ec58304350ee61d20f1f3285d0e8fb873e4d85a97988c284ad", size = 323275, upload-time = "2026-10-26T10:54:33.896Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/12/798e09469358bf59848534291aa62d16cc6fbd66767f469c5d8278d0bc4d/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:16e68b1a4b81301fa7ba52d500947094226d8b0c1521695746ec57ff0779ff6f", size = 328681, upload-time = "2026-10-26T10:54:35.506Z" },
+    { url = "https://files.pythonhosted.org/packages/42/16/71df642a7969381747de36d4e365e59683cdaa2c425da0530e9383e4de86/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:833edd2b38ef08a324e9f3aed4269d2ab955d4cb66417422eeb3af28a6237427", size = 434504, upload-time = "2026-10-26T10:54:36.96Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/18/35c86d901bbd6d3f088217f37a6ff01aae4ce8f8cdb3f9ddb5220887a122/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:21356ba99b82c813c1945054a09ff7ebc1bf55b858b41a6ae084e6ed2c8bb9a9", size = 325810, upload-time = "2026-10-26T10:54:38.492Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/51/25427eee1031946d5abe0d8985123f6fd4a1931c8a5a8660b1c76368ca12/uuid_utils-0.19.0-cp314-cp314t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:2477161656105e787a5f986adb63191b61f129c9d7399b2bce406f87a1407b4d", size = 346300, upload-time = "2026-10-26T10:54:39.864Z" },
+    { url = "https://files.pythonhosted.org/packages/26/4b/edbb0ebdc948549a0250363f441883c31fef42fb4e4bb607b9a083efaeba/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:ddf61d8443993d683c8d6fcd05cbb711c2655042952850fc0cf25af969e3a213", size = 501365, upload-time = "2026-10-26T10:54:41.268Z" },
+    { url = "https://files.pythonhosted.org/packages/68/e4/f5a788fae45e315d8d04d5889a0b0809543e27c8d08b9fe10b09d0766b9b/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_armv7l.whl", hash = "sha256:cb9ead0aeae67ad2de3f660f2e978ece77e14ad3f2a7082b768e2c75866664a2", size = 604290, upload-time = "2026-10-26T10:54:42.686Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/90/3800a0b2083d6c156a4d686e75f26c055a48fcf315b9310ba211b7e3659c/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_i686.whl", hash = "sha256:4e5155902b7779ae7b692ac69e6031f41481d62fa85a530d3725c270799940a0", size = 563566, upload-time = "2026-10-26T10:54:44.068Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/37/1b58a17a041bd560a1d652afccd57ecd5d0e0c4d6280deded663b783de43/uuid_utils-0.19.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:fd3bcc556e249bb70b1c7fd78e659a1ebfb5572e7ff2091d096aecbac62edb1c", size = 531143, upload-time = "2026-10-26T10:54:45.599Z" },
+    { url = "https://files.pythonhosted.org/packages/66/ac/f6286bcfad2f321be2acd04961934a58e4a6c15ba78070a13d193cbbb9f0/uuid_utils-0.19.0-cp314-cp314t-win32.whl", hash = "sha256:9b9064d96c6fe5e43ff4486722c5c891083a7fa91ee36311286cfd833b4b5562", size = 172229, upload-time = "2026-10-26T10:54:46.925Z" },
+    { url = "https://files.pythonhosted.org/packages/87/45/0df876abf12875ef82bcd8f034c0c7adc1507dd721a5942232120b6267e8/uuid_utils-0.19.0-cp314-cp314t-win_amd64.whl", hash = "sha256:eeaf6b77ed2ec9815988e10d043d1533a1ae8c6535e7fb5479fd7e2e6ad25dff", size = 178436, upload-time = "2026-10-26T10:54:48.249Z" },
+    { url = "https://files.pythonhosted.org/packages/d2/ae/c9b4aaa8ee95581b444a7be681dc0ceb57a465b50b28b2f2517f5fec1c51/uuid_utils-0.19.0-cp314-cp314t-win_arm64.whl", hash = "sha256:ebb011b9010ddbd8acd4650896e87db2715f2cfc70fb194c03ebcbf4150d3844", size = 175725, upload-time = "2026-10-26T10:54:49.562Z" },
+    { url = "https://files.pythonhosted.org/packages/41/6e/3a3fdaa9689b687f105ba885e61f6b2e8336ec4d209fd51d41923ad83479/uuid_utils-0.19.0-cp315-cp315t-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8c76f01a815a0ca8b698202f2f5e40098a4b3cd56305e1fc9ed3d959ac718ff0", size = 565325, upload-time = "2026-10-26T10:54:50.924Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/1a/23dacf86dfe52f4606694501a6072379156025a3c6988e16f477f627249c/uuid_utils-0.19.0-cp315-cp315t-macosx_10_12_x86_64.whl", hash = "sha256:f3828e1fc0831a9d539e702992e9fcfeb400e80f737467b8e557921cdc8ae067", size = 291930, upload-time = "2026-10-26T10:54:52.529Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/f2/adf223ded569b0d75e8ac10db14be8fc253da900a63e678436bc3ff3b72a/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b25ddec2775c2f500a36029ab93af09f39d5c417786df02a464464e030152014", size = 322729, upload-time = "2026-10-26T10:54:54.01Z" },
+    { url = "https://files.pythonhosted.org/packages/88/df/0f78e7f22c778d2e48ef092a3a1c44d5b8b487b7e178e1044e7a39195b17/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:1fc412a5ef2f1e6f96d132a6656af59bae2dba9fd04f8df2a2f6eb913fe6180a", size = 328838, upload-time = "2026-10-26T10:54:55.473Z" },
+    { url = "https://files.pythonhosted.org/packages/b3/96/9a9d6f7bef37b3545203eaf643e7f4d574f4ea3a6364af8865c071847df5/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:94cbef978d789b18014c477f51c8311800803cd2a0c7e1de6d2af85377210053", size = 433992, upload-time = "2026-10-26T10:54:56.911Z" },
+    { url = "https://files.pythonhosted.org/packages/07/92/62f67dc40a036ab890ac3f55eaab610999c713654bb3d0b56d5676ce3eaa/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:d4b012d2a2c5516e11ded4fb70cdd730f36e2d40b45018b9a40c6605dc5c0666", size = 326138, upload-time = "2026-10-26T10:54:58.533Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/b7/740525de1aa1a150eb7a80a667c997d54284f407b7f3b38ce8f90f948813/uuid_utils-0.19.0-cp315-cp315t-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:4062c0dfd6697ce7c91a504d8ff6eb8dcaf4e790fb6adec69c4c83fd89870d4a", size = 346714, upload-time = "2026-10-26T10:55:00.01Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/1a/c9d2be770a2061da608164d022becda3fc7ddabb34ec7a1950d29ae51ca0/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:361cfd0fba0a49f1c8b6df741a35f7d948f0fae3d3914f8622ba261dc4656a5a", size = 500974, upload-time = "2026-10-26T10:55:01.392Z" },
+    { url = "https://files.pythonhosted.org/packages/36/2e/ee7522207a7f9477c58757f040f05c4eedb68f362623d4e40da4983bdf5b/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_armv7l.whl", hash = "sha256:a15c8943e02ac59992eaad1ce69793720dc711ce66188d386be1cbf8f5b5a2e4", size = 604607, upload-time = "2026-10-26T10:55:03.141Z" },
+    { url = "https://files.pythonhosted.org/packages/07/b8/c9a1f21627238171a2021dd777177a211df20b12c0c5e45b828ee9bc3c84/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_i686.whl", hash = "sha256:4bd00a485e973cb3bcefe06f13a663cf4ee0c54caeacb2a656a5f901d1505a03", size = 563749, upload-time = "2026-10-26T10:55:04.809Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/9e/ed7d14d4d7bdb94159909e722337a557c855e8990a7fdff55ef6b016fb38/uuid_utils-0.19.0-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:9fe68c4b2e017fb13c5e460b76b76c5cfa717ddd653cea184c2664bc2a852011", size = 530994, upload-time = "2026-10-26T10:55:06.511Z" },
+    { url = "https://files.pythonhosted.org/packages/07/92/5b84a87dd4127a14337d42eb4a24a764583e4decc2675a9949d4568b16e1/uuid_utils-0.19.0-cp315-cp315t-win32.whl", hash = "sha256:5397581f40e268535cd48230e4f2f372dc5f3e70ce79e0aff9cb5ceb838163c8", size = 172512, upload-time = "2026-10-26T10:55:08.261Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/43/a11a33e39f64c50f17483842652933b8ef769ce7cac3399ed7d2a2b928c2/uuid_utils-0.19.0-cp315-cp315t-win_amd64.whl", hash = "sha256:225752e3c36b7c861eb1bbceb5c9197c134c806b210ed53dcacf6339a3d599e6", size = 178626, upload-time = "2026-10-26T10:55:09.658Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/78/4f9dc891db194ce8107c9704d7e2e51da558af457e64134da1b1a7c5db1f/uuid_utils-0.19.0-cp315-cp315t-win_arm64.whl", hash = "sha256:bfcda2352c1500230227da5475139ab177bb2516309254cd74ade19a28cb842d", size = 175582, upload-time = "2026-10-26T10:55:11.001Z" },
+    { url = "https://files.pythonhosted.org/packages/61/60/751fb8688322e107e4b4b66747f084ac0e3de599eec6f800b1661b1bbf7b/uuid_utils-0.19.0-pp311-pypy311_pp73-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:492e621a6aa0d8b4a47cad5e71b9fbbebf5e7af6d0f568daea65d38353f713c1", size = 569090, upload-time = "2026-10-26T10:55:12.449Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/0c/2971bf13e98e2cab194fb43a81c3ffc47d2eaf84d4669d1d5b96ed89d98f/uuid_utils-0.19.0-pp311-pypy311_pp73-macosx_10_12_x86_64.whl", hash = "sha256:68ab7e44d8be02c5d34e2501c465e32747b384c04cf7476de80c01729466a9dc", size = 290711, upload-time = "2026-10-26T10:55:13.836Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/18/a446ae37e9489a4dd905c738fcd98a4a49cd3c57ba36b300fc50372162b8/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0edba30609b6f1d6bc5eb9be5cc90759bf5d0c77f132d2b63fc7c62038b9304e", size = 325610, upload-time = "2026-10-26T10:55:15.237Z" },
+    { url = "https://files.pythonhosted.org/packages/41/ee/32ae97908244fdbed279b4c7215fe186891a9aa1fe9d25f6760b4fe415bc/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:6e137ad199860077c8cf732b71fc8350dbf4bc5e427c01fb82b27dbddd45e370", size = 333087, upload-time = "2026-10-26T10:55:16.728Z" },
+    { url = "https://files.pythonhosted.org/packages/25/f5/dc1ad3783eb0409a912d7c87f0f00143b450cb60cecbb9e1648aabc06f30/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:42f53089ba59a2d1777be98db285aa4948169d434421ee1474ce4615215326ea", size = 438894, upload-time = "2026-10-26T10:55:18.202Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/4c/07bbee76758ee4e425455477120899463eb8e05e5c533eb61c6314bf188c/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b10d689c0f2715502b7d42426947e3bb5c76ac5ba91ae9bd23afc34283189b82", size = 328432, upload-time = "2026-10-26T10:55:19.512Z" },
+    { url = "https://files.pythonhosted.org/packages/14/d6/1e70bbe1c3828fec80b060137f11db69d16b4f40f8ae32526d98b9e604ec/uuid_utils-0.19.0-pp311-pypy311_pp73-manylinux_2_5_i686.manylinux1_i686.whl", hash = "sha256:0da57ba80366ae75307b686376bf437bdc76b3710d52e6ffe012c99a5c800927", size = 351628, upload-time = "2026-10-26T10:55:20.922Z" },
+    { url = "https://files.pythonhosted.org/packages/79/df/75f58b9ee63449e8f81b1698e9e3cb76efada622e6b5590b329d26242a6b/uuid_utils-0.19.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bb0c63bfa8d9af4228353b5c1b06917acf76067674d4d741c31d2117a3db09c5", size = 181546, upload-time = "2026-10-26T10:55:22.522Z" },
+]
+
 [[package]]
 name = "uvicorn"
 version = "0.40.0"

libs/prebuilt/uv.lock

@@ -286,7 +286,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.19"
+version = "1.2.20"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },

libs/sdk-py/langgraph_sdk/__init__.py

@@ -5,7 +5,7 @@ from langgraph_sdk.encryption.types import DecryptResult, EncryptionContext
 from langgraph_sdk.priority import Priority
 from langgraph_sdk.priority.types import PriorityContext, PrioritySettings
 
-__version__ = "0.4.12"
+__version__ = "0.4.14"
 
 __all__ = [
     "Auth",

libs/sdk-py/langgraph_sdk/_async/runs.py

@@ -100,6 +100,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
         version: Literal["v1"] = "v1",
     ) -> AsyncIterator[StreamPart]: ...
 
@@ -133,6 +134,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
         version: Literal["v2"],
     ) -> AsyncIterator[StreamPartV2]: ...
 
@@ -228,6 +230,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
         version: StreamVersion = "v1",
     ) -> AsyncIterator[StreamPart | StreamPartV2]:
         """Create a run and stream the results.
@@ -272,6 +275,10 @@ class RunsClient:
                 "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
                 "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
                 "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            strict_resume: Refuse a resume that answers an interrupt that isn't waiting,
+                instead of ignoring the answer: the run fails with `UnknownInterruptError`
+                and the thread stays as it was. Takes effect on servers whose `/info`
+                reports `strict_resume`.
             version: Stream format version. "v1" (default) returns raw SSE StreamPart
                 NamedTuples. "v2" returns typed dicts with `type`, `ns`, and `data` keys.
 
@@ -305,7 +312,7 @@ class RunsClient:
             StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'})
             StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]})
             StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]})
-            StreamPart(event='end', data=None)
+            StreamPart(event='end', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2', 'status': 'success'})
             ```
 
         """
@@ -341,6 +348,7 @@ class RunsClient:
             "on_completion": on_completion,
             "after_seconds": after_seconds,
             "durability": durability,
+            "strict_resume": strict_resume,
             "langsmith_tracer": langsmith_tracing,
         }
         endpoint = (
@@ -422,6 +430,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> Run: ...
 
     async def create(
@@ -452,6 +461,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> Run:
         """Create a background run.
 
@@ -491,6 +501,10 @@ class RunsClient:
                 "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
                 "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
                 "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            strict_resume: Refuse a resume that answers an interrupt that isn't waiting,
+                instead of ignoring the answer: the run fails with `UnknownInterruptError`
+                and the thread stays as it was. Takes effect on servers whose `/info`
+                reports `strict_resume`.
 
         Returns:
             The created background run.
@@ -595,6 +609,7 @@ class RunsClient:
             "on_completion": on_completion,
             "after_seconds": after_seconds,
             "durability": durability,
+            "strict_resume": strict_resume,
             "langsmith_tracer": langsmith_tracing,
         }
         payload = {k: v for k, v in payload.items() if v is not None}
@@ -656,6 +671,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> builtins.list[dict] | dict[str, Any]: ...
 
     @overload
@@ -712,6 +728,7 @@ class RunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> builtins.list[dict] | dict[str, Any]:
         """Create a run, wait until it finishes and return the final state.
 
@@ -749,6 +766,10 @@ class RunsClient:
                 "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
                 "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
                 "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            strict_resume: Refuse a resume that answers an interrupt that isn't waiting,
+                instead of ignoring the answer: the run fails with `UnknownInterruptError`
+                and the thread stays as it was. Takes effect on servers whose `/info`
+                reports `strict_resume`.
 
         Returns:
             The output of the run.
@@ -829,6 +850,7 @@ class RunsClient:
             "on_completion": on_completion,
             "after_seconds": after_seconds,
             "durability": durability,
+            "strict_resume": strict_resume,
             "langsmith_tracer": langsmith_tracing,
         }
         endpoint = (

libs/sdk-py/langgraph_sdk/_sync/runs.py

@@ -100,6 +100,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
         version: Literal["v1"] = "v1",
     ) -> Iterator[StreamPart]: ...
 
@@ -133,6 +134,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
         version: Literal["v2"],
     ) -> Iterator[StreamPartV2]: ...
 
@@ -228,6 +230,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
         version: StreamVersion = "v1",
     ) -> Iterator[StreamPart | StreamPartV2]:
         """Create a run and stream the results.
@@ -271,6 +274,10 @@ class SyncRunsClient:
                 "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
                 "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
                 "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            strict_resume: Refuse a resume that answers an interrupt that isn't waiting,
+                instead of ignoring the answer: the run fails with `UnknownInterruptError`
+                and the thread stays as it was. Takes effect on servers whose `/info`
+                reports `strict_resume`.
             version: Stream format version. "v1" (default) returns raw SSE StreamPart
                 NamedTuples. "v2" returns typed dicts with `type`, `ns`, and `data` keys.
 
@@ -302,7 +309,7 @@ class SyncRunsClient:
             StreamPart(event='metadata', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2'})
             StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}]})
             StreamPart(event='values', data={'messages': [{'content': 'how are you?', 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'human', 'name': None, 'id': 'fe0a5778-cfe9-42ee-b807-0adaa1873c10', 'example': False}, {'content': "I'm doing well, thanks for asking! I'm an AI assistant created by Anthropic to be helpful, honest, and harmless.", 'additional_kwargs': {}, 'response_metadata': {}, 'type': 'ai', 'name': None, 'id': 'run-159b782c-b679-4830-83c6-cef87798fe8b', 'example': False, 'tool_calls': [], 'invalid_tool_calls': [], 'usage_metadata': None}]})
-            StreamPart(event='end', data=None)
+            StreamPart(event='end', data={'run_id': '1ef4a9b8-d7da-679a-a45a-872054341df2', 'status': 'success'})
             ```
         """
         if checkpoint_during is not None:
@@ -336,6 +343,7 @@ class SyncRunsClient:
             "on_completion": on_completion,
             "after_seconds": after_seconds,
             "durability": durability,
+            "strict_resume": strict_resume,
             "langsmith_tracer": langsmith_tracing,
         }
         endpoint = (
@@ -417,6 +425,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> Run: ...
 
     def create(
@@ -447,6 +456,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> Run:
         """Create a background run.
 
@@ -486,6 +496,10 @@ class SyncRunsClient:
                 "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
                 "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
                 "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            strict_resume: Refuse a resume that answers an interrupt that isn't waiting,
+                instead of ignoring the answer: the run fails with `UnknownInterruptError`
+                and the thread stays as it was. Takes effect on servers whose `/info`
+                reports `strict_resume`.
 
         Returns:
             The created background `Run`.
@@ -590,6 +604,7 @@ class SyncRunsClient:
             "on_completion": on_completion,
             "after_seconds": after_seconds,
             "durability": durability,
+            "strict_resume": strict_resume,
             "langsmith_tracer": langsmith_tracing,
         }
         payload = {k: v for k, v in payload.items() if v is not None}
@@ -651,6 +666,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> builtins.list[dict] | dict[str, Any]: ...
 
     @overload
@@ -707,6 +723,7 @@ class SyncRunsClient:
         params: QueryParamTypes | None = None,
         on_run_created: Callable[[RunCreateMetadata], None] | None = None,
         durability: Durability | None = None,
+        strict_resume: bool | None = None,
     ) -> builtins.list[dict] | dict[str, Any]:
         """Create a run, wait until it finishes and return the final state.
 
@@ -745,6 +762,10 @@ class SyncRunsClient:
                 "async" means checkpoints are persisted async while next graph step executes, replaces checkpoint_during=True
                 "sync" means checkpoints are persisted sync after graph step executes, replaces checkpoint_during=False
                 "exit" means checkpoints are only persisted when the run exits, does not save intermediate steps
+            strict_resume: Refuse a resume that answers an interrupt that isn't waiting,
+                instead of ignoring the answer: the run fails with `UnknownInterruptError`
+                and the thread stays as it was. Takes effect on servers whose `/info`
+                reports `strict_resume`.
 
         Returns:
             The output of the `Run`.
@@ -826,6 +847,7 @@ class SyncRunsClient:
             "on_completion": on_completion,
             "after_seconds": after_seconds,
             "durability": durability,
+            "strict_resume": strict_resume,
             "langsmith_tracer": langsmith_tracing,
         }
 

libs/sdk-py/langgraph_sdk/schema.py

@@ -58,6 +58,8 @@ StreamMode = Literal[
     "debug",
     "custom",
     "messages-tuple",
+    "tools",
+    "lifecycle",
 ]
 """
 Defines the mode of streaming:
@@ -69,6 +71,8 @@ Defines the mode of streaming:
 - "tasks": Stream task start and finish events.
 - "debug": Stream detailed debug information.
 - "custom": Stream custom events.
+- "tools": Stream tool events: `on_tool_start`, `on_tool_event`, `on_tool_end` and `on_tool_error`.
+- "lifecycle": Stream an event when each subgraph starts and ends, with the id of the tool call that started it.
 """
 
 DisconnectMode = Literal["cancel", "continue"]
@@ -380,6 +384,8 @@ class Run(TypedDict):
     """The run metadata."""
     multitask_strategy: MultitaskStrategy
     """Strategy to handle concurrent runs on the same thread."""
+    cancel_reason: NotRequired[str | None]
+    """Why the run was cancelled, if it was. Omitted by older servers."""
 
 
 class Cron(TypedDict):
@@ -505,6 +511,7 @@ RunSelectField = Literal[
     "metadata",
     "kwargs",
     "multitask_strategy",
+    "cancel_reason",
 ]
 
 CronSelectField = Literal[

libs/sdk-py/tests/test_api_parity.py

@@ -136,7 +136,7 @@ def test_sync_api_matches_async(async_cls, sync_cls):
 # and stateful ones (`thread_id: str`) leave out `on_completion`, which only
 # applies to stateless runs.
 _RUN_OVERLOAD_OMISSIONS = {
-    "None": {"checkpoint", "checkpoint_id", "multitask_strategy"},
+    "None": {"checkpoint", "checkpoint_id", "multitask_strategy", "strict_resume"},
     "str": {"on_completion"},
 }
 

libs/sdk-py/tests/test_runs_client.py

@@ -212,3 +212,55 @@ async def test_wait_returns_the_run_error_without_raise_error(asynchronous):
 
     assert result == run_error
     assert "raise_error" not in json.loads(requests[0].content)
+
+
+def _strict_resume_handler(requests: list[httpx.Request]):
+    def handler(request: httpx.Request) -> httpx.Response:
+        requests.append(request)
+        if request.url.path.endswith("/stream"):
+            return httpx.Response(
+                200,
+                headers={"Content-Type": "text/event-stream"},
+                content=b"event: end\ndata: null\n\n",
+            )
+        return httpx.Response(200, json={"run_id": "r1"})
+
+    return handler
+
+
+@pytest.mark.parametrize("method", ["create", "stream", "wait"])
+@pytest.mark.parametrize("asynchronous", [False, True])
+@pytest.mark.parametrize("strict_resume", [True, None], ids=["opted-in", "default"])
+async def test_runs_send_strict_resume_only_when_set(
+    method: str, asynchronous: bool, strict_resume: bool | None
+):
+    requests: list[httpx.Request] = []
+    transport = httpx.MockTransport(_strict_resume_handler(requests))
+    kwargs: dict[str, Any] = {
+        "command": {"resume": {"0" * 32: "yes"}},
+        "strict_resume": strict_resume,
+    }
+    if asynchronous:
+        async with httpx.AsyncClient(
+            transport=transport, base_url="https://example.com"
+        ) as client:
+            result = getattr(RunsClient(HttpClient(client)), method)(
+                "t1", "agent", **kwargs
+            )
+            if method == "stream":
+                async for _ in result:
+                    pass
+            else:
+                await result
+    else:
+        with httpx.Client(
+            transport=transport, base_url="https://example.com"
+        ) as client:
+            result = getattr(SyncRunsClient(SyncHttpClient(client)), method)(
+                "t1", "agent", **kwargs
+            )
+            if method == "stream":
+                for _ in result:
+                    pass
+
+    assert json.loads(requests[0].content).get("strict_resume") == strict_resume

libs/sdk-py/uv.lock

@@ -301,7 +301,7 @@ wheels = [
 
 [[package]]
 name = "langgraph"
-version = "1.2.19"
+version = "1.2.20"
 source = { editable = "../langgraph" }
 dependencies = [
     { name = "langchain-core" },