langgraph-api 0.18.0.dev3__py3-none-any.whl → 0.18.0.dev4__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.18.0.dev3"
+__version__ = "0.18.0.dev4"

langgraph_api/api/event_streaming.py

@@ -28,6 +28,7 @@ from uuid import uuid4
 
 import orjson
 import structlog
+from starlette.exceptions import HTTPException
 from starlette.responses import Response
 from starlette.websockets import WebSocketDisconnect
 
@@ -38,6 +39,7 @@ from langgraph_api.feature_flags import IS_POSTGRES_OR_GRPC_BACKEND
 from langgraph_api.route import ApiRoute, ApiWebSocketRoute
 from langgraph_api.serde import json_dumpb
 from langgraph_api.sse import EventSourceResponse
+from langgraph_api.utils import validate_uuid
 
 if TYPE_CHECKING:
     from collections.abc import Mapping
@@ -98,6 +100,7 @@ def _make_manager(
     send_event: Any = None,
     *,
     headers: Mapping[str, str] | None = None,
+    replay_buffer: bool = True,
 ) -> ThreadRunManager:
     # Auth context is propagated via ``ApiRoute``'s ``with_user`` wrapper
     # — ops reads it off the context var, so we don't thread it through
@@ -108,6 +111,7 @@ def _make_manager(
         threads=Threads,
         send_event=send_event,
         headers=headers,
+        replay_buffer=replay_buffer,
     )
 
 
@@ -143,8 +147,12 @@ async def _thread_events(request: Request) -> Response:
         If reading the thread's event stream fails, the server ends the
         stream with a final ``event: error`` frame carrying a protocol error
         (``"type": "error"``, ``"id": null``, ``"error": "unknown_error"``).
+
+        A thread the caller isn't allowed to read returns 403 or 404 before
+        the stream starts, and a malformed thread ID returns 422.
     """
     thread_id = request.path_params["thread_id"]
+    thread_uuid = validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
     try:
         body = orjson.loads(await request.body())
     except Exception:
@@ -217,6 +225,10 @@ async def _thread_events(request: Request) -> Response:
         else None
     )
 
+    # Checked here, before the 200, because clients retry a 200 that ends in
+    # an error instead of giving up.
+    auth_filters = await Threads.Stream.check_thread_stream_auth(thread_uuid)
+
     # Bounded LRU dedup: ``recent_eids`` is the eviction order, ``delivered``
     # is the O(1) membership view. When the deque hits its cap, the oldest
     # entry rolls off; we mirror that on ``delivered`` to keep them in sync.
@@ -241,7 +253,10 @@ async def _thread_events(request: Request) -> Response:
         pending_events.append(event)
         flush_pending.set()
 
-    manager = _make_manager(thread_id, send_event=on_event)
+    # SSE never replays from the session's buffer: it has no subscribe or
+    # reconnect commands, and ``start_thread_stream`` replays from the
+    # thread's event stream.
+    manager = _make_manager(thread_id, send_event=on_event, replay_buffer=False)
 
     filter_sub = Subscription(
         id=str(uuid4()),
@@ -264,7 +279,7 @@ async def _thread_events(request: Request) -> Response:
     # outbound events; the thread-level reader always replays from the
     # beginning so namespace-scoped projections see history. See
     # ``ThreadRunManager.start_thread_stream`` for the rationale.
-    manager.start_thread_stream()
+    manager.start_thread_stream(auth_filters=auth_filters)
 
     async def body_iter():
         try:
@@ -377,20 +392,51 @@ async def _thread_command(request: Request) -> Response:
 # ---------------------------------------------------------------------------
 
 
+async def _close_for_failed_access_check(websocket: WebSocket, exc: Exception) -> None:
+    if isinstance(exc, HTTPException) and exc.status_code < 500:
+        await websocket.close(code=4000 + exc.status_code)
+        return
+    logger.exception("Thread stream access check failed")
+    await websocket.send_text(_THREAD_STREAM_FAILED_DATA.decode())
+    await websocket.close(code=1011, reason="thread stream ended")
+
+
 async def _thread_websocket(websocket: WebSocket) -> None:
     """Full-duplex protocol connection scoped to a thread.
 
     Supports ``run.start``, ``input.respond``, ``subscription.subscribe``,
     ``subscription.unsubscribe``, ``agent.getTree``.
+
+    A 4xx from the thread's access check closes the socket with 4000 plus the
+    status (4403, 4422). A 404 can be a thread the client minted and has yet
+    to create, so the socket then waits for a ``run.start``, which checks
+    access like any run start, and closes with 4404 if another command comes
+    first. Any other failure of the check, a 5xx included, gets the stream
+    error frame and a 1011 close, as when the stream fails later.
     """
     thread_id = websocket.path_params["thread_id"]
+    # Browsers report a refused upgrade only as a 1006 close, so accept first
+    # to make the close code readable.
     await websocket.accept()
+    try:
+        thread_uuid = validate_uuid(thread_id, "Invalid thread ID: must be a UUID")
+    except HTTPException as exc:
+        await _close_for_failed_access_check(websocket, exc)
+        return
+    awaiting_thread = False
+    auth_filters: Any = None
+    try:
+        auth_filters = await Threads.Stream.check_thread_stream_auth(thread_uuid)
+    except Exception as exc:
+        if not (isinstance(exc, HTTPException) and exc.status_code == 404):
+            await _close_for_failed_access_check(websocket, exc)
+            return
+        awaiting_thread = True
 
     async def ws_send_event(event: dict[str, Any]) -> None:
         await websocket.send_text(orjson.dumps(event).decode("utf-8"))
 
     manager = _make_manager(thread_id, send_event=ws_send_event)
-    manager.start_thread_stream()
 
     # Watchdog: when the thread-stream consumer stops, send the error frame
     # (if it wasn't cancelled) and close the socket, instead of leaving the
@@ -405,7 +451,11 @@ async def _thread_websocket(websocket: WebSocket) -> None:
         with contextlib.suppress(Exception):
             await websocket.close(code=1011, reason="thread stream ended")
 
-    watchdog = asyncio.create_task(_stream_watchdog())
+    def start_stream(filters: Any) -> asyncio.Task[None]:
+        manager.start_thread_stream(auth_filters=filters)
+        return asyncio.create_task(_stream_watchdog())
+
+    watchdog = None if awaiting_thread else start_stream(auth_filters)
 
     try:
         while True:
@@ -438,16 +488,30 @@ async def _thread_websocket(websocket: WebSocket) -> None:
                 )
                 continue
 
+            if awaiting_thread and payload["method"] != "run.start":
+                await websocket.close(code=4404)
+                return
             response = await manager.handle_command(payload)
             await websocket.send_text(orjson.dumps(response).decode("utf-8"))
+            if awaiting_thread and response.get("type") == "success":
+                try:
+                    auth_filters = await Threads.Stream.check_thread_stream_auth(
+                        thread_uuid
+                    )
+                except Exception as exc:
+                    await _close_for_failed_access_check(websocket, exc)
+                    return
+                watchdog = start_stream(auth_filters)
+                awaiting_thread = False
     except WebSocketDisconnect:
         pass
     except Exception:
         logger.exception("Protocol WebSocket error")
     finally:
-        watchdog.cancel()
-        with contextlib.suppress(asyncio.CancelledError, Exception):
-            await watchdog
+        if watchdog is not None:
+            watchdog.cancel()
+            with contextlib.suppress(asyncio.CancelledError, Exception):
+                await watchdog
         await manager.close()
 
 

langgraph_api/config/__init__.py

@@ -507,7 +507,8 @@ FF_CRONS_ENABLED = env("FF_CRONS_ENABLED", cast=bool, default=True)
 FF_LOG_DROPPED_EVENTS = env("FF_LOG_DROPPED_EVENTS", cast=bool, default=False)
 FF_LOG_QUERY_AND_PARAMS = env("FF_LOG_QUERY_AND_PARAMS", cast=bool, default=False)
 # Opt-in handling of drained runs: the server's control signalling to the
-# graph and its handling of drained runs, together.
+# graph and its handling of drained runs, together. On, a Postgres-backed
+# replica that is shutting down also drains its in-flight runs.
 # Off: no control is created or seeded, and GraphDrained lands in the
 # catch-all error branch.
 FF_RESUME_DRAINED_RUNS = env("FF_RESUME_DRAINED_RUNS", cast=bool, default=False)
@@ -535,8 +536,6 @@ RESUME_DRAINED_RUNS = _resolve_resume_drained_runs(
     is_postgres=IS_POSTGRES_BACKEND,
     langgraph_supported=DRAIN_RESUME_SUPPORT,
 )
-# Not in public docs: internal feature flag
-FF_USE_REDIS_QUEUE = env("FF_USE_REDIS_QUEUE", cast=bool, default=True)
 
 
 # Internal flag intended for testing only
@@ -811,7 +810,6 @@ __all__ = [
     "FF_PYSPY_PROFILING_ENABLED",
     "FF_PYSPY_PROFILING_MAX_DURATION_SECS",
     "FF_RESUME_DRAINED_RUNS",
-    "FF_USE_REDIS_QUEUE",
     "GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE",
     "GRPC_CLIENT_MAX_RECV_MSG_BYTES",
     "GRPC_CLIENT_MAX_SEND_MSG_BYTES",

langgraph_api/drain.py

@@ -10,6 +10,7 @@ guarded and the placeholders below never match or instantiate anything.
 from __future__ import annotations
 
 import contextvars
+import threading
 from typing import Any
 
 # The control of the run whose top-level graph this context is executing. The
@@ -47,17 +48,35 @@ try:
         The request is visible only where this is provably the run's top-level
         loop: in a context the server marked for this control (see
         mark_top_level) and outside any graph node. So the run drains only at
-        a top-level step boundary, after that step's subgraphs have finished.
+        a top-level step boundary, after that step's subgraphs have finished,
+        and never before its first step.
         Graph code inside a node, and threads a node starts, see no drain
         (drain_requested False, drain_reason None).
         """
 
+        __slots__ = ("_first_check_done",)
+
+        def __init__(self) -> None:
+            super().__init__()
+            self._first_check_done = False
+
         def _visible(self) -> bool:
             return _TOP_LEVEL_CONTROL.get() is self and not _in_graph_node()
 
         @property
         def drain_requested(self) -> bool:
-            return self._visible() and RunControl.drain_requested.fget(self)
+            if not self._visible():
+                return False
+            # LangGraph checks once per top-level step boundary, before the
+            # step. Only a server drain can be pending at the first check. A
+            # run started with a Command has no checkpoint of its own until its
+            # first step ends, so if it drained there, its next claim would
+            # re-send the Command and LangGraph would apply it again. So a run
+            # always completes a step before it drains.
+            if not self._first_check_done:
+                self._first_check_done = True
+                return False
+            return RunControl.drain_requested.fget(self)
 
         @property
         def drain_reason(self) -> str | None:
@@ -79,6 +98,11 @@ except ImportError:
 
     DRAIN_SUPPORT = False
 
+# Reason the server passes to request_drain() when its pod is shutting down.
+# Graph code can pass any reason (request_drain() defaults to "shutdown"), so
+# this distinct value is what tells server drains from graph drains in logs.
+SERVER_SHUTDOWN_DRAIN_REASON = "server_shutdown"
+
 
 def mark_top_level(control: ServerRunControl | None) -> None:
     """Mark the current context as running ``control``'s top-level graph."""
@@ -92,10 +116,48 @@ def new_run_control() -> ServerRunControl | None:
     return None
 
 
+class RunControlRegistry:
+    """Controls of the runs a queue drains at shutdown, keyed by run ID.
+
+    Workers can finish on background threads (isolated loops), so every access
+    takes a lock and ``drain_all`` works on a snapshot. Controls are registered
+    before the run starts, and removed only by the claim that registered them,
+    so a fast-finishing or superseded claim can't leave or remove the wrong
+    entry.
+    """
+
+    def __init__(self) -> None:
+        self._lock = threading.Lock()
+        self._controls: dict[str, ServerRunControl] = {}
+
+    def add(self, run_id: Any, control: ServerRunControl) -> None:
+        """Register a run's control before the run starts."""
+        with self._lock:
+            self._controls[str(run_id)] = control
+
+    def release(self, run_id: Any, control: ServerRunControl | None) -> None:
+        """Remove a run's control if it is still the one this claim registered."""
+        if control is None:
+            return
+        with self._lock:
+            if self._controls.get(str(run_id)) is control:
+                del self._controls[str(run_id)]
+
+    def drain_all(self, reason: str) -> int:
+        """Request a drain from every registered run; return how many."""
+        with self._lock:
+            controls = list(self._controls.values())
+        for control in controls:
+            control.request_drain(reason)
+        return len(controls)
+
+
 __all__ = [
     "DRAIN_SUPPORT",
+    "SERVER_SHUTDOWN_DRAIN_REASON",
     "GraphDrained",
     "RunControl",
+    "RunControlRegistry",
     "ServerRunControl",
     "mark_top_level",
     "new_run_control",

langgraph_api/event_streaming/service.py

@@ -22,7 +22,6 @@ import asyncio
 import contextlib
 import inspect
 import re
-import time
 from collections.abc import Awaitable, Callable, Mapping
 from typing import Any, cast, get_args
 from uuid import UUID, uuid4
@@ -46,6 +45,7 @@ from langgraph_api.event_streaming.session import (
 from langgraph_api.event_streaming.types import Subscription
 from langgraph_api.feature_flags import FF_V2_EVENT_STREAMING, PREFER_GRPC_CHECKPOINTER
 from langgraph_api.schema import MultitaskStrategy
+from langgraph_api.validation import sanitize_reserved_keys
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -145,10 +145,7 @@ def _multitask_strategy_from_run_start(params: dict[str, Any]) -> str:
 EventSink = Callable[[dict[str, Any]], Awaitable[None] | None]
 
 
-# ``set_joint_status`` commits interrupts after the stream event; gRPC can lag.
 _IN_FLIGHT_THREAD_STATUS = "busy"
-_INTERRUPT_SETTLE_TIMEOUT_SECONDS = 5.0
-_INTERRUPT_SETTLE_POLL_INTERVAL_SECONDS = 0.05
 # langgraph resumes interrupts by id only when every key of the resume map has
 # this shape; any other key turns the whole map into one value for whichever
 # interrupt is pending.
@@ -192,6 +189,9 @@ class ThreadRunManager:
     One ``ThreadRunManager`` is created per connection (HTTP SSE stream or
     WebSocket). It is not shared across connections — each observer owns
     its own view of the thread's run stream.
+
+    ``replay_buffer=False`` keeps no per-run replay buffer, for connections
+    that never replay from it.
     """
 
     def __init__(
@@ -202,12 +202,14 @@ class ThreadRunManager:
         threads: Any,
         send_event: EventSink | None = None,
         headers: Mapping[str, str] | None = None,
+        replay_buffer: bool = True,
     ) -> None:
         self._thread_id = thread_id
         self._runs = runs
         self._threads = threads
         self._send_event = send_event
         self._headers = headers if headers is not None else {}
+        self._replay_buffer = replay_buffer
         self._session: EventStreamingSession | None = None
         self._current_run_id: str | None = None
         self._queued_events: list[dict[str, Any]] = []
@@ -291,7 +293,7 @@ class ThreadRunManager:
                 active=True,
             )
 
-    def start_thread_stream(self) -> None:
+    def start_thread_stream(self, *, auth_filters: Any = None) -> None:
         """Start consuming the thread-level stream for this connection.
 
         Always start from the beginning of the thread's event stream
@@ -306,14 +308,19 @@ class ThreadRunManager:
         produce output…". The SSE/WS sink applies the caller's ``since``
         as a seq filter on outbound events, and the SDK dedups by
         ``event_id``, so repeat observers don't see duplicates.
+
+        ``auth_filters`` is what the route's ``check_thread_stream_auth``
+        returned, passed on so the stream doesn't run the read handler again.
         """
         if self._thread_source_task is not None:
             return
         self._thread_source_task = asyncio.create_task(
-            self._consume_thread_stream(last_event_id="-")
+            self._consume_thread_stream(last_event_id="-", auth_filters=auth_filters)
         )
 
-    async def _consume_thread_stream(self, *, last_event_id: str | None) -> None:
+    async def _consume_thread_stream(
+        self, *, last_event_id: str | None, auth_filters: Any
+    ) -> None:
         try:
             async for (
                 event,
@@ -324,6 +331,7 @@ class ThreadRunManager:
                 self._thread_id,
                 stream_modes=["run_modes", "lifecycle"],
                 last_event_id=last_event_id,
+                auth_filters=auth_filters,
             ):
                 if not run_id or run_id == "*":
                     continue
@@ -781,40 +789,15 @@ class ThreadRunManager:
         if not capabilities.ok:
             raise ProtocolV2UnsupportedError(capabilities)
 
+        # Drop server-owned configurable and metadata keys before the run
+        # config is built, as the REST request parser does for its bodies.
+        sanitize_reserved_keys(params)
         config = params.get("config") if _is_record(params.get("config")) else {}
 
-        # ``input.respond`` checked its interrupts already and always resumes;
-        # the lookups below can wait seconds on a busy thread.
-        force_resume = params.get("force_resume")
-        current_run = None if force_resume else await self._fetch_current_run()
-
-        current_status = None
-        if current_run is not None:
-            current_status = (
-                current_run["status"]
-                if _is_record(current_run)
-                else getattr(current_run, "status", None)
-            )
-
-        has_interrupts = False
-        if params.get("input") is not None and not force_resume:
-            has_interrupts = await self._has_pending_interrupts()
-        if has_interrupts and not _keyed_by_interrupt_id(params["input"]):
-            # One answer can't say which of several pending interrupts it is
-            # for: langgraph fails the run, or picks one when they share a
-            # subgraph task. Only a paused thread's row is current, so a run in
-            # flight keeps resuming as before.
-            paused_on = await self._collect_interrupt_ids_unless_busy()
-            if paused_on is not None and len(paused_on) > 1:
-                raise _AmbiguousResumeError(
-                    f"run.start input can't say which of the {len(paused_on)} "
-                    "pending interrupts it answers; answer them with input.respond."
-                )
-
+        # ``input.respond`` checked its interrupts already and always resumes.
         is_resume = params.get("input") is not None and (
-            force_resume
-            or (current_run is not None and current_status == "interrupted")
-            or has_interrupts
+            bool(params.get("force_resume"))
+            or await self._run_start_resumes(params["input"])
         )
 
         run_config: dict[str, Any] = {
@@ -903,6 +886,16 @@ class ThreadRunManager:
         except Exception:
             raise
 
+        # ``input.respond`` clears the interrupts it answered itself.
+        if is_resume and not params.get("force_resume") and self._session is not None:
+            # Until the stream rebinds to the resumed run, input sent next must
+            # not answer these interrupts a second time.
+            answered = params["input"]
+            if _keyed_by_interrupt_id(answered):
+                for interrupt_id in answered:
+                    self._session.clear_pending_interrupt(interrupt_id)
+            else:
+                self._session._pending_interrupts.clear()
         return run
 
     async def _ensure_run_session(
@@ -959,6 +952,7 @@ class ThreadRunManager:
             get_thread_state=self._make_get_thread_state(thread_id),
             source=None,
             send=self._make_send(),
+            max_buffer_size=None if self._replay_buffer else 0,
         )
 
         self._session = session
@@ -1086,19 +1080,6 @@ class ThreadRunManager:
     # Run lookup
     # ------------------------------------------------------------------
 
-    async def _fetch_current_run(self) -> dict[str, Any] | None:
-        """Fetch the currently-bound run from storage.
-
-        ``Runs.get`` uses keyword-only ``thread_id`` / ``ctx`` args so we
-        cannot call it positionally. We also rely on ``ApiRoute``'s
-        ``with_user`` to populate the auth context var instead of
-        passing ``ctx=self._auth`` (which is a starlette
-        ``AuthCredentials``, not a ``BaseAuthContext``).
-        """
-        if self._current_run_id is None:
-            return None
-        return await self._fetch_run_by_id(self._current_run_id)
-
     async def _fetch_run_by_id(self, run_id: str) -> dict[str, Any] | None:
         """Fetch a run by id without searching for the latest run."""
         from langgraph_runtime.database import connect  # noqa: PLC0415
@@ -1127,41 +1108,6 @@ class ThreadRunManager:
     # Interrupt detection
     # ------------------------------------------------------------------
 
-    async def _lookup_interrupt_in_thread_state(
-        self, interrupt_id: str
-    ) -> list[str] | None:
-        """Existence check for ``interrupt_id`` against persisted thread state.
-
-        Fallback for ``input.respond`` on stateless HTTP transports, where the
-        fresh session hasn't observed ``input.requested`` yet. Backed by the
-        durable thread-row map (see :meth:`_collect_persisted_interrupt_ids`).
-
-        Returns ``[]`` if the interrupt exists, else ``None``. The ``[]`` is a
-        sentinel, not a namespace — the map carries no namespace, so callers
-        must treat it as "found, namespace unknown" and trust the client claim.
-        """
-        found = await self._collect_persisted_interrupt_ids()
-        if found is None:
-            return None
-        return [] if interrupt_id in found else None
-
-    async def _collect_persisted_interrupt_ids(self) -> set[str] | None:
-        """Collect interrupt ids from the durable thread-row ``interrupts`` map.
-
-        ``Threads.set_status`` writes ``{task_id: [{id, value}, ...]}`` onto the
-        thread row atomically with the status whenever a run pauses. Reading it
-        is a plain row fetch (same ``connect()`` + ``Threads.get`` path as
-        :meth:`_get_thread_assistant_id`) — unlike ``Threads.State.get`` it does
-        not rebuild the graph, so it can't spuriously raise and reject a
-        legitimate resume, and it survives reconnects/redeploys.
-
-        Returns the set of interrupt ids (empty when none are pending), or
-        ``None`` if the fetch failed — callers treat ``None`` as "unavailable"
-        and fall open rather than fabricating ``no_such_interrupt``.
-        """
-        thread = await self._fetch_thread_row()
-        return None if thread is None else self._interrupt_ids(thread)
-
     async def _fetch_thread_row(self) -> dict[str, Any] | None:
         """Return the durable thread row, or ``None`` if the fetch failed."""
         from langgraph_runtime.database import connect  # noqa: PLC0415
@@ -1182,6 +1128,11 @@ class ThreadRunManager:
 
     @staticmethod
     def _interrupt_ids(thread: dict[str, Any]) -> set[str]:
+        """Ids in the row's ``interrupts`` map, written with the status when a run ends.
+
+        Read instead of ``Threads.State.get``, which rebuilds the graph and can
+        raise, turning a valid answer into ``no_such_interrupt``.
+        """
         interrupts_map = thread.get("interrupts")
         if not _is_record(interrupts_map):
             return set()
@@ -1197,40 +1148,6 @@ class ThreadRunManager:
                     found.add(entry_id)
         return found
 
-    async def _fetch_thread_status(self) -> str | None:
-        """Return durable thread status, or ``None`` if unreadable."""
-        from langgraph_runtime.database import connect  # noqa: PLC0415
-
-        try:
-            async with connect() as conn:
-                result = await self._threads.get(conn, self._thread_id)
-                thread = await anext(result) if hasattr(result, "__anext__") else result
-        except Exception:
-            return None
-        status = thread.get("status") if _is_record(thread) else None
-        return status if isinstance(status, str) else None
-
-    async def _collect_settled_interrupt_ids(self) -> set[str] | None:
-        """Persisted interrupt ids, polling while the thread is still ``busy``."""
-        ids = await self._collect_persisted_interrupt_ids()
-        if ids is None:
-            return None
-        if ids:
-            return ids
-        deadline = time.monotonic() + _INTERRUPT_SETTLE_TIMEOUT_SECONDS
-        while True:
-            status = await self._fetch_thread_status()
-            if status != _IN_FLIGHT_THREAD_STATUS:
-                return await self._collect_persisted_interrupt_ids()
-            if time.monotonic() >= deadline:
-                return set()
-            await asyncio.sleep(_INTERRUPT_SETTLE_POLL_INTERVAL_SECONDS)
-            ids = await self._collect_persisted_interrupt_ids()
-            if ids is None:
-                return None
-            if ids:
-                return ids
-
     async def _collect_interrupt_ids_unless_busy(self) -> set[str] | None:
         """Persisted interrupt ids, or ``None`` while a run is in flight.
 
@@ -1247,16 +1164,45 @@ class ThreadRunManager:
             return None
         return self._interrupt_ids(thread)
 
-    async def _has_pending_interrupts(self) -> bool:
-        # Prefer the session's in-memory pending interrupts (populated the
-        # instant ``input.requested`` surfaces) to skip a DB round-trip;
-        # otherwise consult the durable thread-row map. A lookup failure
-        # (``None``) reads as "none pending" — ``run.start`` then falls back to
-        # the ``current_status == "interrupted"`` signal for resume-vs-start.
-        if self._session is not None and self._session._pending_interrupts:
+    async def _run_start_resumes(self, value: Any) -> bool:
+        """Whether ``run.start`` input answers the interrupts the thread is paused on.
+
+        Decided without waiting, from one read of the thread row. Interrupts
+        reach the row only when their run ends, so while a run is in flight the
+        input is a new run for the multitask strategy (``enqueue``, the default,
+        queues it behind the running one), never an answer for whichever
+        interrupt is open when that run pauses. The exception is the run this
+        connection streams: the session reports it ``interrupted`` as soon as it
+        raises an interrupt, so input sent after that answers the streamed
+        interrupts, until this connection resumes them or that run ends. When
+        the row can't be read, the streamed interrupts decide. The last run's
+        status isn't consulted: a run that pauses on an interrupt ends
+        ``success``, and ``interrupted`` means it was cancelled; any interrupt it
+        left open is in the row.
+
+        Raises ``_AmbiguousResumeError`` when the input would answer several
+        interrupts and isn't keyed by interrupt id.
+        """
+        if _keyed_by_interrupt_id(value):
             return True
-        found = await self._collect_settled_interrupt_ids()
-        return bool(found)
+        session = self._session
+        streamed = set(session._pending_interrupts) if session is not None else set()
+        thread = await self._fetch_thread_row()
+        if thread is None:
+            paused_on = streamed
+        elif thread.get("status") == _IN_FLIGHT_THREAD_STATUS:
+            paused_on = set() if session is None or session.run_done else streamed
+        else:
+            paused_on = self._interrupt_ids(thread)
+        if len(paused_on) > 1:
+            # One answer can't say which of several pending interrupts it is
+            # for: langgraph fails the run, or picks one when they share a
+            # subgraph task.
+            raise _AmbiguousResumeError(
+                f"run.start input can't say which of the {len(paused_on)} "
+                "pending interrupts it answers; answer them with input.respond."
+            )
+        return bool(paused_on)
 
     # ------------------------------------------------------------------
     # Command forwarding

langgraph_api/event_streaming/session.py

@@ -228,8 +228,8 @@ class EventStreamingSession:
     ) -> None:
         if max_buffer_size is None:
             max_buffer_size = LSD_PROTOCOL_V2_BUFFER_SIZE
-        if max_buffer_size < 1:
-            raise ValueError("max_buffer_size must be a positive integer")
+        if max_buffer_size < 0:
+            raise ValueError("max_buffer_size must be zero or a positive integer")
         self._run_id = run_id
         self._thread_id = thread_id
         self._initial_run = initial_run
@@ -251,12 +251,14 @@ class EventStreamingSession:
         self._buffer: list[dict[str, Any]] = []
         self._source_task: asyncio.Task[None] | None = None
         self._next_seq = 0
+        # 0 keeps no replay buffer, for transports that never replay from it.
         self._max_buffer_size = max_buffer_size
         self._root_graph_name = "root"
         self._terminal_lifecycle_emitted = False
         # Maps interrupt_id -> namespace that emitted it, so ``input.respond``
         # from the client can be verified against the originating subgraph.
         self._pending_interrupts: dict[str, Namespace] = {}
+        self.run_done = False
         # Latches once the underlying transport starts rejecting sends so
         # we don't spam the logs for every subsequent event on a dead
         # WebSocket / SSE stream. The session is torn down by ``close()``
@@ -374,6 +376,7 @@ class EventStreamingSession:
 
     async def complete(self) -> None:
         """Emit terminal lifecycle when an external source reports run completion."""
+        self.run_done = True
         await self._emit_terminal_lifecycle()
 
     async def handle_event_streaming_command(
@@ -971,7 +974,8 @@ class EventStreamingSession:
         return _synth_event_id(self._run_id, str(self._next_seq))
 
     async def _push_event(self, event: dict[str, Any]) -> None:
-        self._buffer.append(event)
+        if self._max_buffer_size:
+            self._buffer.append(event)
         reporter = get_otlp_metrics_reporter()
         if len(self._buffer) > self._max_buffer_size:
             evicted = len(self._buffer) - self._max_buffer_size
@@ -1036,9 +1040,10 @@ class EventStreamingSession:
         callback for events with ``seq > since`` that match the filter,
         then the subscription is activated so live events flow.
 
-        Returns the number of events replayed. Used by both the WebSocket
-        ``subscription.subscribe`` command and the SSE event stream, which
-        accept a body ``since`` cursor to resume after a reconnect.
+        Returns the number of events replayed. Used by the WebSocket
+        ``subscription.subscribe`` and ``subscription.reconnect`` commands;
+        ``since`` resumes after a reconnect. SSE streams replay from the
+        thread's event stream instead.
 
         Raises :class:`ResumeGap` when *since* is older than the
         session's retained buffer head. This lets callers surface a

langgraph_api/grpc/ops/threads.py

@@ -68,6 +68,10 @@ logger = structlog.stdlib.get_logger(__name__)
 # only need graph_id (from metadata) and the thread config.
 THREAD_METADATA_READ_MASK_PATHS: list[str] = ["metadata", "config"]
 
+# Read-mask preset for an auth/existence check that discards the thread body;
+# Go's ``repos.ThreadExistenceCheckMask``.
+THREAD_EXISTENCE_CHECK_READ_MASK_PATHS: list[str] = []
+
 
 THREAD_STATUS_TO_PB = {
     "idle": enum_thread_status.idle,
@@ -971,13 +975,20 @@ class Threads(Authenticated):
             stream_modes: list[str] | None = None,
             last_event_id: str | None = None,
             ctx: Any = None,
+            auth_filters: list[pb.AuthFilter] | None = None,
         ):
-            """Stream thread events with their run id for protocol demux."""
-            auth_filters = await Threads.Stream.handle_event(
-                ctx,
-                "read",
-                Auth.types.ThreadsRead(thread_id=UUID(str(thread_id))),
-            )
+            """Stream thread events with their run id for protocol demux.
+
+            ``auth_filters`` comes from a ``check_thread_stream_auth`` the
+            caller already ran, so the read handler doesn't run twice. With
+            ``None``, the handler runs here.
+            """
+            if auth_filters is None:
+                auth_filters = await Threads.Stream.handle_event(
+                    ctx,
+                    "read",
+                    Auth.types.ThreadsRead(thread_id=UUID(str(thread_id))),
+                )
 
             stream_modes_pb = _map_thread_stream_modes(stream_modes)
 
@@ -1013,6 +1024,43 @@ class Threads(Authenticated):
                     _handle_grpc_error(e)
                 raise
 
+        @staticmethod
+        async def check_thread_stream_auth(
+            thread_id: UUID,
+            ctx: Any = None,
+        ) -> list[pb.AuthFilter]:
+            """Raise 403/404 before a thread stream's response starts.
+
+            Same check as the Go ``Stream`` RPC: the thread is looked up only
+            when custom auth returns filters. Without filters, a thread that
+            doesn't exist yet must stay streamable, because the Python SDK
+            opens its lifecycle stream on ``async with client.threads.stream()``,
+            before the ``run.start`` that creates the thread.
+
+            Returns the auth filters for ``join_event_streaming``.
+            """
+            auth_filters = await Threads.Stream.handle_event(
+                ctx,
+                "read",
+                Auth.types.ThreadsRead(thread_id=thread_id),
+            )
+            if not auth_filters:
+                return auth_filters
+            client = await get_shared_client()
+            try:
+                await client.threads.Get(
+                    pb.GetThreadRequest(
+                        thread_id=pb.UUID(value=_normalize_uuid(thread_id)),
+                        filters=auth_filters,
+                        read_mask=field_mask_pb2.FieldMask(
+                            paths=THREAD_EXISTENCE_CHECK_READ_MASK_PATHS
+                        ),
+                    )
+                )
+            except AioRpcError as e:
+                _handle_grpc_error(e)
+            return auth_filters
+
     class State(Authenticated):
         # treat this like threads resource
         resource = "threads"

langgraph_api/models/run.py

@@ -36,6 +36,7 @@ from langgraph_api.tracing_session import resolve_tracing_session_name
 from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx, get_user_id
 from langgraph_api.utils.headers import get_configurable_headers
 from langgraph_api.utils.uuids import uuid7
+from langgraph_api.validation import strip_reserved
 from langgraph_api.webhook import validate_webhook_url_or_raise
 
 if IS_POSTGRES_OR_GRPC_BACKEND:
@@ -261,6 +262,12 @@ async def create_valid_run(
     if checkpoint_id:
         configurable["checkpoint_id"] = str(checkpoint_id)
     if checkpoint := payload.get("checkpoint"):
+        # Cron payloads stored before requests had checkpoint stripped can still carry server-owned keys.
+        strip_reserved(
+            checkpoint,
+            "checkpoint",
+            message="Stripped reserved keys from stored checkpoint",
+        )
         configurable.update(checkpoint)
     configurable.update(get_configurable_headers(headers))
     # cron_id is server-owned: drop any value merged from the request, then stamp the scheduler's.

langgraph_api/utils/headers.py

@@ -8,6 +8,8 @@ from collections.abc import Mapping
 import orjson
 import structlog
 
+from langgraph_api.validation import RESERVED_CONFIGURABLE_KEYS
+
 logger = structlog.stdlib.get_logger(__name__)
 
 LANGSMITH_METADATA = "langsmith-metadata"
@@ -146,6 +148,9 @@ def should_include_header(key: str) -> bool:
         or key == "authorization"
     ):
         return False
+    # Server-owned configurable keys are never taken from a request header.
+    if key in RESERVED_CONFIGURABLE_KEYS:
+        return False
 
     include_patterns, exclude_patterns = get_header_patterns("configurable_headers")
 

langgraph_api/validation.py

@@ -112,7 +112,7 @@ _RESERVED_KEYS_SET = frozenset(RESERVED_CONFIGURABLE_KEYS)
 _RESERVED_METADATA_KEYS_SET = frozenset(RESERVED_METADATA_KEYS)
 
 
-def _strip_reserved(
+def strip_reserved(
     d: dict,
     location: str,
     reserved_keys: frozenset[str] = _RESERVED_KEYS_SET,
@@ -134,7 +134,7 @@ def _strip_metadata(d: dict, location: str) -> None:
     """Strip reserved keys from a ``metadata`` sub-dict if present."""
     metadata = d.get("metadata")
     if isinstance(metadata, dict):
-        _strip_reserved(
+        strip_reserved(
             metadata,
             location,
             reserved_keys=_RESERVED_METADATA_KEYS_SET,
@@ -184,22 +184,22 @@ def sanitize_reserved_keys(data: typing.Any, *, strip_metadata: bool = True) ->
     if isinstance(config, dict):
         configurable = config.get("configurable")
         if isinstance(configurable, dict):
-            _strip_reserved(configurable, "config.configurable")
+            strip_reserved(configurable, "config.configurable")
 
     # Config schema: top-level configurable
     configurable = data.get("configurable")
     if isinstance(configurable, dict):
-        _strip_reserved(configurable, "configurable")
+        strip_reserved(configurable, "configurable")
 
     # write schemas: context
     context = data.get("context")
     if isinstance(context, dict):
-        _strip_reserved(context, "context")
+        strip_reserved(context, "context")
 
     # checkpoint: merged into configurable on run create and when a cron fires
     checkpoint = data.get("checkpoint")
     if isinstance(checkpoint, dict):
-        _strip_reserved(checkpoint, "checkpoint")
+        strip_reserved(checkpoint, "checkpoint")
 
 
 def should_strip_reserved_metadata(schema: typing.Any) -> bool:

{langgraph_api-0.18.0.dev3.dist-info → langgraph_api-0.18.0.dev4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev3
+Version: 0.18.0.dev4
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

{langgraph_api-0.18.0.dev3.dist-info → langgraph_api-0.18.0.dev4.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langgraph_api/__init__.py,sha256=b5nthx5CSl_Gv3rgaVrhQAxjWbs8Nm1xFX98jRMm6OU,28
+langgraph_api/__init__.py,sha256=lKV0HWITd9TkyE-O95yarED1frbG86ds67s3ivE3cFk,28
 langgraph_api/_factory_utils.py,sha256=_FqW0olMu2PGLsnRq0ylt3a4jDCe12YIFHExMXI6Nyo,5976
 langgraph_api/asgi_transport.py,sha256=XApY3lIWBZTMbbsl8dDJzl0cLGirmAGE0SifqZUnXvs,11896
 langgraph_api/asyncio.py,sha256=-p-Vx89TnErypdPcWb-2EdbsSvhdIdHfriCFG7UP7ls,12444
@@ -7,7 +7,7 @@ langgraph_api/cache.py,sha256=xtBTkEQOP0GJ0wb9EH_BdIvaDfRxPG5DPNnEh2Zmcmg,16198
 langgraph_api/cli.py,sha256=ATtS9s9Cx7QNiGPJceKnMCko29A25ZA-xz39fdxmgfg,22389
 langgraph_api/command.py,sha256=d-k8h6H4ix1n7fSZ-Zb01NbSkEyqrD6cMKfDFXEIYEw,821
 langgraph_api/cron_scheduler.py,sha256=H1jPymC68A1MYyjfdApX4-hELiGBlJpGgSOsN8qhc-8,5595
-langgraph_api/drain.py,sha256=h1RaXhk-pBYuh2nGQmlOi0vt7GbWyhbV_rNERDA-T1A,3533
+langgraph_api/drain.py,sha256=MLUm3fDq3R8yxrZ-1W3TeCfhNzgNSzUA7TvB-D6K2_s,6108
 langgraph_api/errors.py,sha256=QJSriNZn3VMnMzcxbTNmUgT8u1a0GddpMXamJ4A_a6o,2583
 langgraph_api/feature_flags.py,sha256=AWkWe--MlzoF7O0tazXNxFJYa9P9CZSxPSpt7hL9p6o,3938
 langgraph_api/graph.py,sha256=uQaC_yOWRFZIZwQt5WGdjnVW5iB0WaaBniUcUV82Y5Q,40594
@@ -35,7 +35,7 @@ langgraph_api/stream.py,sha256=SMrditrbTJ7QtKW-ThpYAPiVsQD-ot_tQeGJIp9PKGI,36519
 langgraph_api/stream_v2.py,sha256=cmbE566boEgKkjcqqf8OvDqjWh8VzvCCsTTlvUF5Drg,10762
 langgraph_api/traceblock.py,sha256=GhgAtLhAQ8Z8LHtRQq3par-rfPpRBQp2Q7WBACJq1NI,677
 langgraph_api/tracing_session.py,sha256=gmfv-BW1XRar6suVur1P4rTVKWkjElDEb2hhkBduWOs,728
-langgraph_api/validation.py,sha256=Y3It_OCQ0vcb__GPBfGhsZpeETCB4HtteGuHRCA9A4k,14936
+langgraph_api/validation.py,sha256=_fmqjbETfsrc4KKJLtfhVjELD-1WzEVrK6G1pfDrmtk,14930
 langgraph_api/webhook.py,sha256=qXEtkE6orek2POeOQmPRsEarJgXIYp-LBrZB-OwITxc,9572
 langgraph_api/worker.py,sha256=Y6bsWW5shcfqYw-vwRV3H9D8XLXltPSJMOxBMOJyZzw,22201
 langgraph_api/worker_runtime.py,sha256=zzVW7A4vHyJE6DRxdjRZIa2U334Eh5oO157SyWmQ3G8,11861
@@ -46,7 +46,7 @@ langgraph_api/api/__init__.py,sha256=E95h8fdtBERIRsEEoRu_n3INZc1vb5LK5eHvR9ss-V8
 langgraph_api/api/a2a.py,sha256=dYuxX4HhU0RlsOWKraA1gYD58FyyVXeR0QihLn4xNfg,148659
 langgraph_api/api/a2ui.py,sha256=Dx9qwwIOmQ0MfgOwL-UZabBI0F7DEvz3qG1cFkjvnjE,3108
 langgraph_api/api/assistants.py,sha256=iWrmWsAXpO9kgAb2ihKuJPCABYYf_7I9BPEITwwBsrA,19822
-langgraph_api/api/event_streaming.py,sha256=4EUL9NNa94B317mebB6830ONC00cdkE9qZyXA87iEI4,18903
+langgraph_api/api/event_streaming.py,sha256=0Nu2WQdTz1f-uxmZ01mz2cr_Bx2IqZnvOiqADN0wH1o,22063
 langgraph_api/api/meta.py,sha256=5s017GfMs-Ghq6Z5K6yW4UjbVFzCsmeXKn4UEJmfs98,4757
 langgraph_api/api/openapi.py,sha256=Zkdlb9mjrQyHro1TtrDIWVuaBDovxx-uGWJ1fZMOg54,12604
 langgraph_api/api/profile.py,sha256=CA1ZkHALOuP8orYTICnEhcG_JnnA2wnyjbWyeb117jA,3455
@@ -77,7 +77,7 @@ langgraph_api/auth/studio_user.py,sha256=Lx3eMsRA8gxZ3--ApL09hDW84A6qIncaZoBZjSg
 langgraph_api/auth/langsmith/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 langgraph_api/auth/langsmith/backend.py,sha256=gaSuZC8JO32XHe8IdqttNpBGO6PCVrtXaq1Negc7vX0,3857
 langgraph_api/auth/langsmith/client.py,sha256=79kwCVeHU64nsHsxWipfZhf44lM6vfs2nlfTxlJF6LU,4142
-langgraph_api/config/__init__.py,sha256=AwDDdpR5yVywhP1Qkf5RfE30rzVjj21eALfTf5qGMns,31755
+langgraph_api/config/__init__.py,sha256=-BOsd7Xqrtw89dPYnqM71i2GdGRzEPspOBJOCJ9HfWk,31699
 langgraph_api/config/_parse.py,sha256=RpfZgFAPJlRMv13AzGr3kAYbIrqHcgjzO8IgeboTw4A,3922
 langgraph_api/config/schemas.py,sha256=RaV-huiOALaJDsGi-wVp7Ghz8aE7UDXgL9YB2TYvQKA,21439
 langgraph_api/encryption/__init__.py,sha256=gaCZ00CocSbqSqrDn6XJHaSp2CZCnC8qnrD9G4fbzyI,363
@@ -91,8 +91,8 @@ langgraph_api/event_streaming/capabilities.py,sha256=qjVbhCjl1VEQPGeiDxeJAhYGI_7
 langgraph_api/event_streaming/constants.py,sha256=eGsm-NvOlqV3gNxDO5vlr00FdngmgEQf59zuHSi_74E,1378
 langgraph_api/event_streaming/event_normalizers.py,sha256=5bVSqGPW-Uh7WX91qgTfwpK433pCSv_wchpbzW8TLi4,2794
 langgraph_api/event_streaming/namespace.py,sha256=aJDFt45Or2_bQdRpKJgdFhBgTDj6PYl7Coz5GzfbM84,1509
-langgraph_api/event_streaming/service.py,sha256=pO0EiQM8ZHlJs4y-qY9FK0J6vSJTkbNW1ZojqWHLpd8,54495
-langgraph_api/event_streaming/session.py,sha256=8kx5nxJvJlfIu5fFzQCxEl-8UBJEtxftBLhCYgXMNwo,75947
+langgraph_api/event_streaming/service.py,sha256=t739MpvrkBrrRjdMw1ln3w-Lz1F52HcKiuinoNSELLU,52216
+langgraph_api/event_streaming/session.py,sha256=sw5orsEKDTADaxCBURd9TNRAyhqqcWrp0yDkWuBrsY0,76170
 langgraph_api/event_streaming/state_normalizers.py,sha256=vgT4O4tJPr9VDBMn1EP994ieDGDYP43sROnOyLjkEAE,13659
 langgraph_api/event_streaming/types.py,sha256=RyZqfqgH-jmmmmAFQj5f6nH9M1rGK93zVG7nlmvqZgc,3647
 langgraph_api/executor/__init__.py,sha256=mZBT8HSqe9pMlBpE7sw6DMI4ULB4xwNPWGkN9zp1B7k,302
@@ -106,7 +106,7 @@ langgraph_api/grpc/ops/assistants.py,sha256=hLDZrAahpGSjzWNzr8nQidTW_4MoCR6sZy5V
 langgraph_api/grpc/ops/cache.py,sha256=MoPAmSuOwbt2Cud1YZJm_YJeaDHPFy1IiV4m0PDImgg,1399
 langgraph_api/grpc/ops/crons.py,sha256=aDlvNVYIfSP8gtr5NptLiAj-bfMtJOuMWYIA2NifWm0,19713
 langgraph_api/grpc/ops/runs.py,sha256=ID0oOVvwZEZKdLSNfPUVcA8k3fNrTra62jy0JElMjss,43832
-langgraph_api/grpc/ops/threads.py,sha256=8c6ivd5XS2EReXBz6SVDU_waSh5WGwFWKIrHln3kHlQ,48890
+langgraph_api/grpc/ops/threads.py,sha256=nWp2qrt4FxxM_SEW5GBEeiOiKk6qdTPmY2hPTcYgsjY,50912
 langgraph_api/grpc/servicers/__init__.py,sha256=l8yqTA_gMbIj0xHw5-RZYo0JbjL-EpFD8RxPMgW_-bA,422
 langgraph_api/grpc/servicers/checkpointer.py,sha256=kn9J3HQEmqggtOGiDxpEAeBVkVi4qDCJikj2bXo5k4g,10543
 langgraph_api/grpc/servicers/encryption.py,sha256=ddAjRZ9btWBf4MPa7yd793japdCEi-DfEPi1Ynt8gzk,10563
@@ -147,7 +147,7 @@ langgraph_api/middleware/http_logger.py,sha256=79iMlqKdSP5sS6G-iuEAHl2h0Z2ygYDxs
 langgraph_api/middleware/private_network.py,sha256=eQEzWI8epBNUCiNsMu9O27ofHBQ45M0p2OZy5YdUYos,2097
 langgraph_api/middleware/request_id.py,sha256=-p230Q5jDJAJLmSZRqQvB4dFFkJS9B4Vwg6pUgQtI24,1259
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=UqZkqi4G7IMC2i5Dim5RKXoazlwt5yXV6KRcQo_kn4c,15484
+langgraph_api/models/run.py,sha256=MW7Q17G3veh3WCPwwyDVA9qkk-ih8MPo3QKqY-_Wyho,15795
 langgraph_api/timing/__init__.py,sha256=UDMuNBmc5NqX0m5T-9PUFioCa1lNvd4Wv4juPIBRb-w,877
 langgraph_api/timing/profiler.py,sha256=_n0qJYJMjCGo95RDuH5z8FIzePGNSNbnm3cvGmcgn6A,6186
 langgraph_api/timing/startup.py,sha256=1Jp4-tquBhiE5glWQhXGX5XS2_006myJXHHZMOi15ng,6161
@@ -159,7 +159,7 @@ langgraph_api/utils/config.py,sha256=tyxWNnJhw_PbQ-18ekSFZxsN23d2COf6SmpNsU9X3m8
 langgraph_api/utils/errors.py,sha256=51WNBkbk1JHlTvA-J2lgkA3PDj3BEGcnhIECwAihWgU,2728
 langgraph_api/utils/extract.py,sha256=KaBzFc_WosmzRTtN9L5z4UAzJzGqCmcV_eGk9ATUg-o,3873
 langgraph_api/utils/future.py,sha256=coCKJiRZCgoF_pEijVLR4v6mGGOjx_057vEkNwAC5gU,7414
-langgraph_api/utils/headers.py,sha256=Q1kbyda-EBxh103KKKpoZjVnKjDQbqDqq19YmSZB9zI,6359
+langgraph_api/utils/headers.py,sha256=4012Nup4FRR8fxbDdqpX7eVJQtNUBqVwfAdUaNQKLnk,6563
 langgraph_api/utils/network.py,sha256=CO0H95QO6R6xxBPQNU_TVaf4z3XbO7oX4qDdwbpmaZY,1190
 langgraph_api/utils/retriable_client.py,sha256=WKdjquy6eIdeNuyO68AxVyskSgBAF_ViO-K-tmRCdDs,2551
 langgraph_api/utils/stream_codec.py,sha256=rt7Vz2AMPetwBdson1Suof3IzM4m3UaPW7_o7TuCgeo,10243
@@ -180,7 +180,7 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
 hatch_build.py,sha256=Nn9N-EFfVqmH5q3iCUrhqX6zc7qT1jLI3gWSBN2xgYQ,1738
 logging.json,sha256=sBy8HDDPuucpLbLUD6e8t5fsiQjJoklZsbVHi2qQ7aQ,367
-openapi.json,sha256=BUlosTZcsL46oTMHVAnPWjVJSaWT6Het3dBBLin0Sn8,226101
+openapi.json,sha256=yxvwPZ74Y-uXRR5di9YcP_3cVxE5RR_MOWba-50tCmk,226652
 langgraph_grpc_common/__init__.py,sha256=sO7jFHekQxt6zZPhTPZAWLYLB_S8w7-VuJ7NyWFlFNo,97
 langgraph_grpc_common/checkpointer.py,sha256=qNUrdS8veKuxy-S4-soCvsiB_P0SpoS5jdJ5q6JAzRg,15620
 langgraph_grpc_common/serde.py,sha256=8q290nZ6TdxbEhCTzwEs44XGi2b-3pfrUeMYY5WGlTY,6179
@@ -258,8 +258,8 @@ langgraph_grpc_common/proto/store_pb2.py,sha256=VWJ7wtzL9pVmZZKbxMzOzCoiFn58bB2g
 langgraph_grpc_common/proto/store_pb2.pyi,sha256=atXejijuYEb9tE0stGQdZcfA9ucMFj-ytTMwvkxwviM,29322
 langgraph_grpc_common/proto/store_pb2_grpc.py,sha256=Kyt8eV2NXkjh3be_BYytGdD19kNf74961cruonMvCrw,3300
 langgraph_grpc_common/proto/store_pb2_grpc.pyi,sha256=oS1h2cDoq2OjyM8xazcmc8LwRDC5oCAD0zto2QUmPQw,2027
-langgraph_api-0.18.0.dev3.dist-info/METADATA,sha256=aNFk0rP_xIALhz66Hfj0_PnB9TV7MT5FwDKHSbTzhK0,5879
-langgraph_api-0.18.0.dev3.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-langgraph_api-0.18.0.dev3.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.18.0.dev3.dist-info/licenses/LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
-langgraph_api-0.18.0.dev3.dist-info/RECORD,,
+langgraph_api-0.18.0.dev4.dist-info/METADATA,sha256=ivAuNjWbJAU_vF-F9u0At8L6u09I9C8Pz2NU8vXFeds,5879
+langgraph_api-0.18.0.dev4.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+langgraph_api-0.18.0.dev4.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.18.0.dev4.dist-info/licenses/LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
+langgraph_api-0.18.0.dev4.dist-info/RECORD,,

openapi.json

@@ -1722,6 +1722,26 @@
                 }
               }
             }
+          },
+          "404": {
+            "description": "Not Found",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
+          },
+          "422": {
+            "description": "Validation Error",
+            "content": {
+              "application/json": {
+                "schema": {
+                  "$ref": "#/components/schemas/ErrorResponse"
+                }
+              }
+            }
           }
         }
       }