langgraph-api 0.17.0.dev4__tar.gz → 0.17.0.dev5__tar.gz

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/PKG-INFO

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

@@ -0,0 +1 @@
+__version__ = "0.17.0.dev5"

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/langgraph_api/api/event_streaming.py

@@ -33,7 +33,7 @@ from starlette.websockets import WebSocketDisconnect
 
 from langgraph_api.event_streaming.service import ThreadRunManager
 from langgraph_api.event_streaming.session import _is_supported_channel
-from langgraph_api.event_streaming.types import Subscription
+from langgraph_api.event_streaming.types import ErrorResponse, Subscription
 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
@@ -61,6 +61,19 @@ logger = structlog.stdlib.get_logger(__name__)
 # connection, vs. the unbounded set this replaces.
 _DELIVERED_DEDUP_WINDOW = 2048
 
+# Final frame on SSE and WebSocket when the thread-stream consumer stops
+# without being cancelled. A thread stream has no natural end, so that always
+# means the read failed. The message is fixed because the exception text can
+# carry raw backend errors; the consumer has already logged it.
+_THREAD_STREAM_FAILED_DATA = json_dumpb(
+    ErrorResponse(
+        type="error",
+        id=None,
+        error="unknown_error",
+        message="Thread event stream failed.",
+    )
+)
+
 
 def _json_response(content: Any, *, status_code: int = 200) -> Response:
     """JSON response backed by the repo's orjson helper.
@@ -118,6 +131,10 @@ async def _thread_events(request: Request) -> Response:
         The filter applies for the lifetime of the connection; closing the
         connection unsubscribes. No state is persisted server-side beyond the
         connection.
+
+        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"``).
     """
     thread_id = request.path_params["thread_id"]
     try:
@@ -245,10 +262,9 @@ async def _thread_events(request: Request) -> Response:
         try:
             while True:
                 # Race ``flush_pending`` against the thread-stream consumer
-                # ending. If the consumer dies (transient join_event_streaming
-                # error, or normal shutdown), we want this loop to exit
-                # rather than wedge forever waiting for events that will
-                # never arrive.
+                # ending. If the consumer stops (its read failed or its
+                # source ended), we want this loop to exit rather than
+                # wedge forever waiting for events that will never arrive.
                 flush_task = asyncio.create_task(flush_pending.wait())
                 done_task = asyncio.create_task(manager.wait_for_thread_stream_end())
                 try:
@@ -285,6 +301,8 @@ async def _thread_events(request: Request) -> Response:
                         str(sse_id).encode() if isinstance(sse_id, int) else None,
                     )
                 if stream_finished:
+                    if manager.thread_stream_failed:
+                        yield (b"error", _THREAD_STREAM_FAILED_DATA)
                     break
         finally:
             await manager.close()
@@ -366,14 +384,16 @@ async def _thread_websocket(websocket: WebSocket) -> None:
     manager = _make_manager(thread_id, send_event=ws_send_event)
     manager.start_thread_stream()
 
-    # Watchdog: when the thread-stream consumer ends (transient
-    # ``join_event_streaming`` failure or normal shutdown), close the socket so
-    # the client sees a clean disconnect instead of an open connection
-    # that will never deliver another event. ``receive_text`` below
-    # raises ``WebSocketDisconnect`` once the close lands, exiting the
-    # loop through its existing handler.
+    # Watchdog: when the thread-stream consumer stops, send the error frame
+    # (if it wasn't cancelled) and close the socket, instead of leaving the
+    # client on an open connection that will never deliver another event.
+    # ``receive_text`` below raises ``WebSocketDisconnect`` once the close
+    # lands, exiting the loop through its existing handler.
     async def _stream_watchdog() -> None:
         await manager.wait_for_thread_stream_end()
+        if manager.thread_stream_failed:
+            with contextlib.suppress(Exception):
+                await websocket.send_text(_THREAD_STREAM_FAILED_DATA.decode())
         with contextlib.suppress(Exception):
             await websocket.close(code=1011, reason="thread stream ended")
 

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/langgraph_api/event_streaming/service.py

@@ -194,11 +194,13 @@ class ThreadRunManager:
         self._seq: int = 0
         self._thread_source_task: asyncio.Task[None] | None = None
         # Set by ``_consume_thread_stream`` when the background task
-        # exits — success, cancellation, or unexpected failure all
-        # transition this. Route handlers (SSE body_iter, WS watchdog)
-        # await this so a transient ``join_event_streaming`` failure can no
-        # longer leave the connection wedged with no events flowing.
+        # exits for any reason, including cancellation. Route handlers
+        # (SSE body_iter, WS watchdog) await this so a transient
+        # ``join_event_streaming`` failure can no longer leave the
+        # connection wedged with no events flowing.
         self._thread_stream_done: asyncio.Event = asyncio.Event()
+        # Set when the consumer stops for any reason other than cancellation.
+        self._thread_stream_failed: bool = False
         # WebSocket clients typically call ``subscription.subscribe``
         # before ``run.start`` — natural ordering since they want to
         # observe before firing. Buffer those subscriptions here and
@@ -224,6 +226,15 @@ class ThreadRunManager:
     def seq(self) -> int:
         return self._seq
 
+    @property
+    def thread_stream_failed(self) -> bool:
+        """Whether the thread-stream consumer stopped without being cancelled.
+
+        A thread stream has no natural end, so the consumer stopping on its
+        own, by raising or by its source finishing, means the read failed.
+        """
+        return self._thread_stream_failed
+
     async def attach_event_sink(self, send_event: EventSink) -> None:
         """Attach a live transport consumer and flush buffered events."""
         self._send_event = send_event
@@ -307,12 +318,19 @@ class ThreadRunManager:
         except asyncio.CancelledError:
             raise
         except Exception as exc:
+            self._thread_stream_failed = True
             await logger.aexception(
                 "protocol thread stream failed",
                 thread_id=str(self._thread_id),
                 error=str(exc),
                 error_type=type(exc).__name__,
             )
+        else:
+            self._thread_stream_failed = True
+            await logger.awarning(
+                "protocol thread stream ended unexpectedly",
+                thread_id=str(self._thread_id),
+            )
         finally:
             # Wake up SSE body_iter / WS watchdog so the connection can
             # be torn down. Without this, a transient ``join_event_streaming``

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/langgraph_api/stream.py

@@ -726,6 +726,7 @@ async def _consume_inline(
                         "error",
                         await run_in_executor(None, json_dumpb, e),
                         thread_id=thread_id,
+                        resumable=resumable,
                     )
                 await logger.aerror(
                     "Suppressing stream consume exception",

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/langgraph_api/worker.py

@@ -350,12 +350,14 @@ async def worker(
                 # re-raises without emitting, so a retriable attempt stays silent
                 # until the run actually fails. Emit before the status write so raw
                 # SSE clients (no status fallback) see it even if that write fails.
+                # Resumable runs cache it so `Last-Event-ID` replays end with it too.
                 with suppress(Exception):
                     await Runs.Stream.publish(
                         run_id,
                         "error",
                         json_dumpb(exception),
                         thread_id=run["thread_id"],
+                        resumable=resumable,
                     )
 
                 # We're outside the original `except` block, so build exc_info manually.

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/langgraph_grpc_common/conversion/checkpoint.py

@@ -27,13 +27,17 @@ from langgraph_grpc_common.conversion.value import (
 )
 from langgraph_grpc_common.proto import checkpointer_pb2, engine_common_pb2
 
-SOURCE_MAP = {
+SOURCE_MAP: dict[
+    Literal["input", "loop", "update", "fork"] | None,
+    engine_common_pb2.CheckpointMetadata.CheckpointSource.ValueType,
+] = {
     None: engine_common_pb2.CheckpointMetadata.CheckpointSource.unknown,
     "input": engine_common_pb2.CheckpointMetadata.CheckpointSource.input,
     "loop": engine_common_pb2.CheckpointMetadata.CheckpointSource.loop,
     "update": engine_common_pb2.CheckpointMetadata.CheckpointSource.update,
     "fork": engine_common_pb2.CheckpointMetadata.CheckpointSource.fork,
 }
+_SOURCE_FROM_PROTO = {v: k for k, v in SOURCE_MAP.items()}
 
 
 def checkpoint_config_to_proto(
@@ -170,12 +174,19 @@ def checkpoint_metadata_from_proto(
     if not metadata_pb:
         return None
 
-    return {
-        "source": metadata_source_from_proto(metadata_pb.source),
+    metadata: CheckpointMetadata = {
         "step": metadata_pb.step,
         "parents": dict(metadata_pb.parents),
         **dict_from_raw_map(metadata_pb.extras),
     }
+    # A missing source crosses the wire as `unknown`, since proto3 enums can't be
+    # absent (Go's `toMap` drops the key the same way). The stub that
+    # durability="exit" saves as a new thread's first checkpoint has none.
+    if (source := metadata_source_from_proto(metadata_pb.source)) is not None:
+        metadata["source"] = source
+    if metadata_pb.HasField("run_id"):
+        metadata["run_id"] = metadata_pb.run_id
+    return metadata
 
 
 def checkpoint_metadata_to_proto(
@@ -199,17 +210,11 @@ def checkpoint_metadata_to_proto(
 
 def metadata_source_from_proto(
     source: engine_common_pb2.CheckpointMetadata.CheckpointSource.ValueType,
-) -> Literal["input", "loop", "update", "fork"]:
-    if source == engine_common_pb2.CheckpointMetadata.CheckpointSource.input:
-        return "input"
-    elif source == engine_common_pb2.CheckpointMetadata.CheckpointSource.loop:
-        return "loop"
-    elif source == engine_common_pb2.CheckpointMetadata.CheckpointSource.update:
-        return "update"
-    elif source == engine_common_pb2.CheckpointMetadata.CheckpointSource.fork:
-        return "fork"
-    else:
-        raise ValueError(f"Unknown checkpoint source: {source}")
+) -> Literal["input", "loop", "update", "fork"] | None:
+    try:
+        return _SOURCE_FROM_PROTO[source]
+    except KeyError:
+        raise ValueError(f"Unknown checkpoint source: {source}") from None
 
 
 def pending_writes_from_proto(

{langgraph_api-0.17.0.dev4 → langgraph_api-0.17.0.dev5}/openapi.json

@@ -1708,7 +1708,7 @@
               "text/event-stream": {
                 "schema": {
                   "type": "string",
-                  "description": "Stream of `ProtocolEvent` frames. Each SSE frame uses the event's `method` as the `event:` field and a JSON-encoded `ProtocolEvent` as the `data:` field; `id:` is set to the event's `seq`.\n\n**Example frame:**\n\nid: 42\n\nevent: messages\n\ndata: {\"type\":\"event\",\"event_id\":\"42\",\"seq\":42,\"method\":\"messages\",\"params\":{\"namespace\":[],\"timestamp\":1700000000000,\"data\":{...}}}"
+                  "description": "Stream of `ProtocolEvent` frames. Each SSE frame uses the event's `method` as the `event:` field and a JSON-encoded `ProtocolEvent` as the `data:` field; `id:` is set to the event's `seq`.\n\nIf reading the thread's event stream fails, the server ends the stream with a final frame whose `event:` field is `error` and whose `data:` field is a `ProtocolError` with `id: null` and `error: \"unknown_error\"`. That frame has no `id:` field.\n\n**Example frame:**\n\nid: 42\n\nevent: messages\n\ndata: {\"type\":\"event\",\"event_id\":\"42\",\"seq\":42,\"method\":\"messages\",\"params\":{\"namespace\":[],\"timestamp\":1700000000000,\"data\":{...}}}"
                 }
               }
             }

langgraph_api-0.17.0.dev4/langgraph_api/__init__.py

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