langgraph-api 0.7.74__tar.gz → 0.7.76__tar.gz

{langgraph_api-0.7.74 → langgraph_api-0.7.76}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.7.74
+Version: 0.7.76
 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.7.74 → langgraph_api-0.7.76}/constraints.txt

@@ -10,7 +10,7 @@ orjson>=3.9.7
 httpx>=0.25.0
 tenacity>=8.0.0
 uvicorn>=0.26.0
-sse-starlette>=3.0.0,<3.4.0
+sse-starlette>=2.1.0,<3.4.0
 uvloop>=0.18.0
 httptools>=0.5.0
 jsonschema-rs>=0.20.0

langgraph_api-0.7.76/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.7.76"

{langgraph_api-0.7.74 → langgraph_api-0.7.76}/langgraph_api/config/__init__.py

@@ -155,6 +155,9 @@ GRPC_CLIENT_MAX_RECV_MSG_BYTES = env(
 GRPC_CLIENT_MAX_SEND_MSG_BYTES = env(
     "GRPC_CLIENT_MAX_SEND_MSG_BYTES", cast=int, default=300 * 1024 * 1024
 )
+GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE = env(
+    "GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE", cast=int, default=64 * 1024
+)
 LSD_GRPC_SERVER_ADDRESS = env(
     "LSD_GRPC_SERVER_ADDRESS",
     cast=str,
@@ -494,6 +497,7 @@ __all__ = [
     "FF_PYSPY_PROFILING_ENABLED",
     "FF_PYSPY_PROFILING_MAX_DURATION_SECS",
     "FF_USE_REDIS_QUEUE",
+    "GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE",
     "GRPC_CLIENT_MAX_RECV_MSG_BYTES",
     "GRPC_CLIENT_MAX_SEND_MSG_BYTES",
     "GRPC_CLIENT_POOL_SIZE",

{langgraph_api-0.7.74 → langgraph_api-0.7.76}/langgraph_api/grpc/client.py

@@ -73,6 +73,10 @@ class GrpcClient:
         options = [
             ("grpc.max_receive_message_length", config.GRPC_CLIENT_MAX_RECV_MSG_BYTES),
             ("grpc.max_send_message_length", config.GRPC_CLIENT_MAX_SEND_MSG_BYTES),
+            (
+                "grpc.http2.initial_window_size",
+                config.GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE,
+            ),
         ]
 
         self._channel = aio.insecure_channel(self.server_address, options=options)

{langgraph_api-0.7.74 → langgraph_api-0.7.76}/langgraph_api/grpc/ops/runs.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 import contextlib
 from contextlib import asynccontextmanager
 from datetime import UTC
@@ -35,7 +36,7 @@ from langgraph_grpc_common.proto import (
 from langgraph_sdk import Auth
 from starlette.exceptions import HTTPException
 
-from langgraph_api.asyncio import SimpleTaskGroup, ValueEvent
+from langgraph_api.asyncio import ValueEvent
 from langgraph_api.auth.custom import handle_event as auth_handle_event
 from langgraph_api.errors import UserInterrupt, UserRollback
 from langgraph_api.graph import SYSTEM_ASSISTANT_IDS
@@ -983,84 +984,91 @@ class Runs(Authenticated):
             )
             enter_stream = client.runs.Enter(enter_request)
 
-            async with SimpleTaskGroup(cancel=True, taskgroup_name="Runs.enter") as tg:
-                # Background task to listen for control signals from the stream
-                async def listen_for_signals():
-                    try:
-                        async for event in enter_stream:
-                            if event.action == enum_control_signal.interrupt:
-                                logger.info(
-                                    "Received interrupt signal from gRPC stream",
-                                    run_id=run_id,
-                                    thread_id=thread_id,
-                                )
-                                done.set(UserInterrupt())
-                                break
-                            elif event.action == enum_control_signal.rollback:
-                                logger.info(
-                                    "Received rollback signal from gRPC stream",
-                                    run_id=run_id,
-                                    thread_id=thread_id,
-                                )
-                                done.set(UserRollback())
-                                break
-                    except Exception as exc:
-                        logger.exception(
-                            "listen_for_signals failed",
-                            run_id=run_id,
-                            thread_id=thread_id,
-                            exc_info=exc,
-                        )
-                        done.set(
-                            GrpcRetryableException(
-                                f"listen_for_signals failed. \nError: {exc!r}"
-                            )
-                        )
-                        raise
-
-                tg.create_task(listen_for_signals())
-
+            # Background task to listen for control signals from the stream
+            async def listen_for_signals():
                 try:
-                    yield done
-                    # Signal done via gRPC (stops heartbeat and cleanup on server)
-                    await Runs.mark_done(
-                        run_id=run_id, thread_id=thread_id, resumable=resumable
-                    )
-                except GrpcRetryableException:
-                    logger.info(
-                        "Retriable exception, will not signal done",
+                    async for event in enter_stream:
+                        if event.action == enum_control_signal.interrupt:
+                            logger.info(
+                                "Received interrupt signal from gRPC stream",
+                                run_id=run_id,
+                                thread_id=thread_id,
+                            )
+                            done.set(UserInterrupt())
+                            break
+                        elif event.action == enum_control_signal.rollback:
+                            logger.info(
+                                "Received rollback signal from gRPC stream",
+                                run_id=run_id,
+                                thread_id=thread_id,
+                            )
+                            done.set(UserRollback())
+                            break
+                except Exception as exc:
+                    logger.exception(
+                        "listen_for_signals failed",
                         run_id=run_id,
                         thread_id=thread_id,
+                        exc_info=exc,
+                    )
+                    done.set(
+                        GrpcRetryableException(
+                            f"listen_for_signals failed. \nError: {exc!r}"
+                        )
                     )
-                except RETRIABLE_EXCEPTIONS:
+                    raise
+
+            listener: asyncio.Task | None = None
+            try:
+                listener = asyncio.create_task(listen_for_signals())
+                yield done
+                # Signal done via gRPC (stops heartbeat and cleanup on server)
+                await Runs.mark_done(
+                    run_id=run_id, thread_id=thread_id, resumable=resumable
+                )
+            except GrpcRetryableException:
+                logger.info(
+                    "Retriable exception, will not signal done",
+                    run_id=run_id,
+                    thread_id=thread_id,
+                )
+            except RETRIABLE_EXCEPTIONS:
+                logger.info(
+                    "Retriable exception, will not signal done",
+                    run_id=run_id,
+                    thread_id=thread_id,
+                )
+            except AioRpcError as e:
+                if e.code() in GRPC_RETRIABLE_STATUS_CODES:
                     logger.info(
-                        "Retriable exception, will not signal done",
+                        "Retriable gRPC error, will not signal done",
                         run_id=run_id,
                         thread_id=thread_id,
+                        grpc_code=e.code().name,
                     )
-                except AioRpcError as e:
-                    if e.code() in GRPC_RETRIABLE_STATUS_CODES:
-                        logger.info(
-                            "Retriable gRPC error, will not signal done",
-                            run_id=run_id,
-                            thread_id=thread_id,
-                            grpc_code=e.code().name,
-                        )
-                    else:
-                        logger.exception(
-                            "Non-retriable gRPC error when marking run as done",
-                            run_id=run_id,
-                            thread_id=thread_id,
-                            grpc_code=e.code().name,
-                        )
-                        raise
-                except BaseException:
+                else:
                     logger.exception(
-                        "Non-retriable exception when marking run as done",
+                        "Non-retriable gRPC error when marking run as done",
                         run_id=run_id,
                         thread_id=thread_id,
+                        grpc_code=e.code().name,
                     )
                     raise
+            except BaseException:
+                logger.exception(
+                    "Non-retriable exception when marking run as done",
+                    run_id=run_id,
+                    thread_id=thread_id,
+                )
+                raise
+            finally:
+                # Quiet teardown: cancel listener first, then close stream.
+                if listener is not None:
+                    listener.cancel()
+                    with contextlib.suppress(asyncio.CancelledError, Exception):
+                        await listener
+                if not enter_stream.done():
+                    enter_stream.cancel()
 
         return _enter_impl()
 

{langgraph_api-0.7.74 → langgraph_api-0.7.76}/langgraph_api/queue_entrypoint.py

@@ -53,9 +53,10 @@ async def health_and_metrics_server():
     port = int(os.getenv("PORT", "8080"))
     host = os.getenv("LANGGRAPH_SERVER_HOST", "0.0.0.0")
 
-    async def health_endpoint(request):
-        # if db or redis is not healthy, this will raise an exception
-        await healthcheck()
+    async def health_endpoint(request: Request):
+        check_db = int(request.query_params.get("check_db", "1"))
+
+        await healthcheck(check_db=bool(check_db))
         return JSONResponse({"status": "ok"})
 
     async def metrics_endpoint(request: Request):

{langgraph_api-0.7.74 → langgraph_api-0.7.76}/langgraph_api/sse.py

@@ -13,6 +13,9 @@ from langgraph_api.asyncio import SimpleTaskGroup, aclosing
 from langgraph_api.serde import json_dumpb
 
 logger = structlog.stdlib.get_logger(__name__)
+# Version 2 is listen_for_exit_signal and listen_for_disconnect
+# Version 3 is _listen_for_exit_signal and _listen_for_disconnect
+USE_PUBLIC_SSE = hasattr(sse_starlette.EventSourceResponse, "listen_for_disconnect")
 
 
 class EventSourceResponse(sse_starlette.EventSourceResponse):
@@ -35,12 +38,18 @@ class EventSourceResponse(sse_starlette.EventSourceResponse):
                 task_group.cancel_scope.cancel()
 
             task_group.start_soon(wrap, partial(self.stream_response, send))
-            task_group.start_soon(wrap, self._listen_for_exit_signal)
+            if USE_PUBLIC_SSE:
+                task_group.start_soon(wrap, self.listen_for_exit_signal)
+            else:
+                task_group.start_soon(wrap, self._listen_for_exit_signal)
 
             if self.data_sender_callable:
                 task_group.start_soon(self.data_sender_callable)
 
-            await wrap(partial(self._listen_for_disconnect, receive))
+            if USE_PUBLIC_SSE:
+                await wrap(partial(self.listen_for_disconnect, receive))
+            else:
+                await wrap(partial(self._listen_for_disconnect, receive))
 
         if self.background is not None:  # pragma: no cover, tested in StreamResponse
             await self.background()

langgraph_api-0.7.74/langgraph_api/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.7.74"