langgraph-api 0.18.0.dev4__tar.gz → 0.18.0.dev6__tar.gz

{langgraph_api-0.18.0.dev4 → langgraph_api-0.18.0.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev4
+Version: 0.18.0.dev6
 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.dev6/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0.dev6"

{langgraph_api-0.18.0.dev4 → langgraph_api-0.18.0.dev6}/langgraph_api/event_streaming/service.py

@@ -22,6 +22,7 @@ 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
@@ -145,7 +146,10 @@ 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.
@@ -794,10 +798,38 @@ class ThreadRunManager:
         sanitize_reserved_keys(params)
         config = params.get("config") if _is_record(params.get("config")) else {}
 
-        # ``input.respond`` checked its interrupts already and always resumes.
+        # ``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."
+                )
+
         is_resume = params.get("input") is not None and (
-            bool(params.get("force_resume"))
-            or await self._run_start_resumes(params["input"])
+            force_resume
+            or (current_run is not None and current_status == "interrupted")
+            or has_interrupts
         )
 
         run_config: dict[str, Any] = {
@@ -886,16 +918,6 @@ 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(
@@ -1080,6 +1102,19 @@ 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
@@ -1108,6 +1143,41 @@ 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
@@ -1128,11 +1198,6 @@ 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()
@@ -1148,6 +1213,40 @@ 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.
 
@@ -1164,45 +1263,16 @@ class ThreadRunManager:
             return None
         return self._interrupt_ids(thread)
 
-    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):
+    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:
             return True
-        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)
+        found = await self._collect_settled_interrupt_ids()
+        return bool(found)
 
     # ------------------------------------------------------------------
     # Command forwarding

{langgraph_api-0.18.0.dev4 → langgraph_api-0.18.0.dev6}/langgraph_api/event_streaming/session.py

@@ -258,7 +258,6 @@ class EventStreamingSession:
         # 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()``
@@ -376,7 +375,6 @@ 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(

{langgraph_api-0.18.0.dev4 → langgraph_api-0.18.0.dev6}/openapi.json

@@ -4602,7 +4602,7 @@
             "type": "string",
             "enum": ["sync", "async", "exit"],
             "title": "Durability",
-            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/durable-execution#durability-modes) for more details.",
+            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/checkpointers#durability-modes) for more details.",
             "default": "async"
           }
         },
@@ -4782,7 +4782,7 @@
             "type": "string",
             "enum": ["sync", "async", "exit"],
             "title": "Durability",
-            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/durable-execution#durability-modes) for more details.",
+            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/checkpointers#durability-modes) for more details.",
             "default": "async"
           }
         },
@@ -5351,7 +5351,7 @@
             "type": "string",
             "enum": ["sync", "async", "exit"],
             "title": "Durability",
-            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/durable-execution#durability-modes) for more details.",
+            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/checkpointers#durability-modes) for more details.",
             "default": "async"
           }
         },
@@ -5542,7 +5542,7 @@
             "type": "string",
             "enum": ["sync", "async", "exit"],
             "title": "Durability",
-            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/durable-execution#durability-modes) for more details.",
+            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/checkpointers#durability-modes) for more details.",
             "default": "async"
           }
         },
@@ -6783,7 +6783,7 @@
             "type": "string",
             "enum": ["sync", "async", "exit"],
             "title": "Durability",
-            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/durable-execution#durability-modes) for more details.",
+            "description": "Durability level for the run. Must be one of `sync`, `async`, or `exit`. See [durability modes](https://docs.langchain.com/oss/python/langgraph/checkpointers#durability-modes) for more details.",
             "default": "async"
           }
         },

langgraph_api-0.18.0.dev4/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.18.0.dev4"