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

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

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

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

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/api/runs.py

@@ -309,6 +309,8 @@ async def stream_run(
         await sub.__aexit__(None, None, None)
         raise
 
+    request.scope["run_id"] = str(run["run_id"])
+
     async def body():
         try:
             async for event, message, stream_id in Runs.Stream.join(
@@ -358,6 +360,8 @@ async def stream_run_stateless(
         await sub.__aexit__(None, None, None)
         raise
 
+    request.scope["run_id"] = str(run["run_id"])
+
     async def body():
         try:
             async for event, message, stream_id in Runs.Stream.join(
@@ -404,6 +408,8 @@ async def wait_run(request: ApiRequest):
         await sub.__aexit__(None, None, None)
         raise
 
+    request.scope["run_id"] = str(run["run_id"])
+
     body = _run_result_body(
         run_id=run["run_id"],
         thread_id=run["thread_id"],
@@ -448,6 +454,8 @@ async def wait_run_stateless(request: ApiRequest):
         await sub.__aexit__(None, None, None)
         raise
 
+    request.scope["run_id"] = str(run["run_id"])
+
     async def stateless_fallback() -> bytes:
         await logger.awarning(
             "No checkpoint emitted for stateless run",

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

@@ -142,7 +142,12 @@ See https://developer.chrome.com/blog/private-network-access-update-2024-03
 # gRPC client pool size for persistence server.
 GRPC_CLIENT_POOL_SIZE = env("GRPC_CLIENT_POOL_SIZE", cast=int, default=5)
 
-# gRPC message size limits (100MB default)
+# HTTP request body size limit (default matches gRPC limits: 300MB)
+HTTP_MAX_REQUEST_BODY_BYTES = env(
+    "HTTP_MAX_REQUEST_BODY_BYTES", cast=int, default=300 * 1024 * 1024
+)
+
+# gRPC message size limits (300MB default)
 LSD_GRPC_SERVER_MAX_RECV_MSG_BYTES = env(
     "LSD_GRPC_SERVER_MAX_RECV_MSG_BYTES", cast=int, default=300 * 1024 * 1024
 )
@@ -502,6 +507,7 @@ __all__ = [
     "GRPC_CLIENT_MAX_SEND_MSG_BYTES",
     "GRPC_CLIENT_POOL_SIZE",
     "HTTP_CONFIG",
+    "HTTP_MAX_REQUEST_BODY_BYTES",
     "IS_EXECUTOR_ENTRYPOINT",
     "IS_QUEUE_ENTRYPOINT",
     "JSON_THREAD_POOL_MINIMUM_SIZE_BYTES",

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/graph.py

@@ -143,6 +143,7 @@ def _log_slow_graph_generation(
     start: float,
     value_type: str,
     graph_id: str,
+    run_id: str | None = None,
     warn_threshold_ms: float = 100,
     error_threshold_ms: float = 250,
 ) -> None:
@@ -164,14 +165,19 @@ def _log_slow_graph_generation(
             elapsed_ms=elapsed_ms_rounded,
             value_type=value_type,
             graph_id=graph_id,
+            run_id=run_id,
         )
 
 
 @asynccontextmanager
-async def _generate_graph(value: Any, graph_id: str) -> AsyncIterator[Any]:
+async def _generate_graph(
+    value: Any, graph_id: str, run_id: str | None = None
+) -> AsyncIterator[Any]:
     """Yield a graph object regardless of its type.
 
     Logs a warning if graph generation takes >100ms, error if >250ms.
+    run_id is passed through solely for inclusion in slow-load log entries,
+    enabling correlation with access logs.
     """
     start = time.perf_counter()
     value_type = type(value).__name__
@@ -179,15 +185,15 @@ async def _generate_graph(value: Any, graph_id: str) -> AsyncIterator[Any]:
         yield value
     elif hasattr(value, "__aenter__") and hasattr(value, "__aexit__"):
         async with value as ctx_value:
-            _log_slow_graph_generation(start, value_type, graph_id)
+            _log_slow_graph_generation(start, value_type, graph_id, run_id=run_id)
             yield ctx_value
     elif hasattr(value, "__enter__") and hasattr(value, "__exit__"):
         with value as ctx_value:
-            _log_slow_graph_generation(start, value_type, graph_id)
+            _log_slow_graph_generation(start, value_type, graph_id, run_id=run_id)
             yield ctx_value
     elif asyncio.iscoroutine(value):
         result = await value
-        _log_slow_graph_generation(start, value_type, graph_id)
+        _log_slow_graph_generation(start, value_type, graph_id, run_id=run_id)
         yield result
     else:
         yield value
@@ -206,6 +212,7 @@ async def get_graph(
     checkpointer: BaseCheckpointSaver | None = None,
     store: BaseStore,
     access_context: AccessContext,
+    run_id: str | None = None,
 ) -> AsyncIterator[Pregel]:
     """Return the runnable."""
     from langgraph_api.utils import config as lg_config  # noqa: PLC0415
@@ -239,7 +246,7 @@ async def get_graph(
 
         value = invoke_factory(value, graph_id, config, server_runtime)
     try:
-        async with _generate_graph(value, graph_id) as graph_obj:
+        async with _generate_graph(value, graph_id, run_id=run_id) as graph_obj:
             if isinstance(graph_obj, StateGraph):
                 graph_obj = graph_obj.compile()
             if not isinstance(graph_obj, Pregel | BaseRemotePregel):

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/js/client.mts

@@ -148,15 +148,21 @@ const GRAPH_SPEC: Record<string, GraphSpec> = {};
 
 async function getGraph(
   graphId: string,
-  config: { configurable?: Record<string, unknown> },
+  config: Parameters<CompiledGraphFactory<string>>[0],
   name: string | null | undefined,
 ) {
   if (!GRAPH_RESOLVED[graphId])
     throw new HTTPException(404, { message: `Graph "${graphId}" not found` });
 
+  const factoryConfig = {
+    ...config,
+    checkpointer: GRAPH_OPTIONS.checkpointer,
+    store: GRAPH_OPTIONS.store,
+  };
+
   const resolved =
     typeof GRAPH_RESOLVED[graphId] === "function"
-      ? await GRAPH_RESOLVED[graphId](config)
+      ? await GRAPH_RESOLVED[graphId](factoryConfig)
       : GRAPH_RESOLVED[graphId];
 
   if (GRAPH_OPTIONS.checkpointer) {

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/js/src/graph.mts

@@ -1,7 +1,8 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 
-import type { CompiledGraph, Graph } from "@langchain/langgraph";
+import type { BaseStore, CompiledGraph, Graph } from "@langchain/langgraph";
+import type { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import type { JSONSchema7 } from "json-schema";
 
 export interface GraphSchema {
@@ -16,9 +17,15 @@ export interface GraphSpec {
   exportSymbol: string;
 }
 
-export type CompiledGraphFactory<T extends string> = (config: {
+export type FactoryConfig = {
   configurable?: Record<string, unknown>;
-}) => Promise<CompiledGraph<T>>;
+  store?: BaseStore;
+  checkpointer?: BaseCheckpointSaver<string | number>;
+};
+
+export type CompiledGraphFactory<T extends string> = (
+  config: FactoryConfig,
+) => Promise<CompiledGraph<T>>;
 
 export async function resolveGraph(
   spec: string,
@@ -52,9 +59,7 @@ export async function resolveGraph(
   type GraphUnknown =
     | GraphLike
     | Promise<GraphLike>
-    | ((config: {
-        configurable?: Record<string, unknown>;
-      }) => GraphLike | Promise<GraphLike>)
+    | ((config: FactoryConfig) => GraphLike | Promise<GraphLike>)
     | undefined;
 
   const isGraph = (graph: GraphLike): graph is Graph<string> => {
@@ -97,7 +102,7 @@ export async function resolveGraph(
       };
 
       if (typeof graph === "function") {
-        return async (config: { configurable?: Record<string, unknown> }) => {
+        return async (config: FactoryConfig) => {
           const graphLike = await graph(config);
           return afterResolve(graphLike);
         };

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/middleware/http_logger.py

@@ -46,7 +46,7 @@ class AccessLoggerMiddleware:
             return await self.app(scope, receive, send)  # pragma: no cover
 
         loop = asyncio.get_event_loop()
-        info = {"response": {}}
+        info = {"response": {}, "response_bytes": 0, "first_byte_time": None}
 
         if self.debug_enabled:
 
@@ -58,6 +58,10 @@ class AccessLoggerMiddleware:
             async def inner_send(message: Message) -> None:
                 if message["type"] == "http.response.start":
                     info["response"] = message
+                elif message["type"] == "http.response.body":
+                    if info["first_byte_time"] is None:
+                        info["first_byte_time"] = loop.time()
+                    info["response_bytes"] += len(message.get("body", b""))
                 await send(message)
                 asgi.debug(f"ASGI send {message['type']}", **message)
 
@@ -67,6 +71,10 @@ class AccessLoggerMiddleware:
             async def inner_send(message) -> None:
                 if message["type"] == "http.response.start":
                     info["response"] = message
+                elif message["type"] == "http.response.body":
+                    if info["first_byte_time"] is None:
+                        info["first_byte_time"] = loop.time()
+                    info["response_bytes"] += len(message.get("body", b""))
                 await send(message)
 
         try:
@@ -90,6 +98,12 @@ class AccessLoggerMiddleware:
             if method and route and status:
                 HTTP_METRICS_COLLECTOR.record_request(method, route, status, latency)
             qs = scope.get("query_string")
+            first_byte_time = info["first_byte_time"]
+            ttfb_ms = (
+                round((first_byte_time - info["start_time"]) * 1000, 2)
+                if first_byte_time is not None
+                else None
+            )
             self.logger.log(
                 _get_level(status),
                 f"{method} {path} {status} {latency}ms",
@@ -97,6 +111,9 @@ class AccessLoggerMiddleware:
                 path=path,
                 status=status,
                 latency_ms=latency,
+                ttfb_ms=ttfb_ms,
+                run_id=scope.get("run_id"),
+                response_size_bytes=info["response_bytes"],
                 route=str(route),
                 path_params=scope.get("path_params"),
                 query_string=qs.decode() if qs else "",

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/route.py

@@ -80,8 +80,14 @@ class ApiRequest(Request):
     async def body(self) -> bytearray:
         if not hasattr(self, "_body"):
             chunks = bytearray()
+            limit = config.HTTP_MAX_REQUEST_BODY_BYTES
             async for chunk in self.stream():
                 chunks.extend(chunk)
+                if len(chunks) > limit:
+                    raise HTTPException(
+                        status_code=413,
+                        detail=f"Request body too large (limit: {limit} bytes)",
+                    )
             self._body = chunks
         return self._body
 

{langgraph_api-0.7.76 → langgraph_api-0.7.77}/langgraph_api/stream.py

@@ -171,6 +171,7 @@ async def astream_state(
             if temporary
             else await api_checkpointer.get_checkpointer(),
             access_context="threads.create_run",
+            run_id=run_id,
         )
     )
 

langgraph_api-0.7.76/langgraph_api/__init__.py

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