langgraph-api 0.2.40__tar.gz → 0.2.43__tar.gz

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.40
+Version: 0.2.43
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE

langgraph_api-0.2.43/langgraph_api/__init__.py

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

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/api/runs.py

@@ -38,6 +38,7 @@ async def create_run(request: ApiRequest):
             thread_id,
             payload,
             request.headers,
+            request_start_time=request.scope.get("request_start_time_ms"),
         )
     return ApiResponse(
         run,
@@ -55,6 +56,7 @@ async def create_stateless_run(request: ApiRequest):
             None,
             payload,
             request.headers,
+            request_start_time=request.scope.get("request_start_time_ms"),
         )
     return ApiResponse(
         run,
@@ -75,6 +77,7 @@ async def create_stateless_run_batch(request: ApiRequest):
                 payload,
                 request.headers,
                 barrier,
+                request_start_time=request.scope.get("request_start_time_ms"),
             )
             for payload in batch_payload
         ]
@@ -100,6 +103,7 @@ async def stream_run(
                 payload,
                 request.headers,
                 run_id=run_id,
+                request_start_time=request.scope.get("request_start_time_ms"),
             )
     except Exception:
         if not sub.cancelled():
@@ -139,6 +143,7 @@ async def stream_run_stateless(
                 payload,
                 request.headers,
                 run_id=run_id,
+                request_start_time=request.scope.get("request_start_time_ms"),
             )
     except Exception:
         if not sub.cancelled():
@@ -178,6 +183,7 @@ async def wait_run(request: ApiRequest):
                 payload,
                 request.headers,
                 run_id=run_id,
+                request_start_time=request.scope.get("request_start_time_ms"),
             )
     except Exception:
         if not sub.cancelled():
@@ -250,6 +256,7 @@ async def wait_run_stateless(request: ApiRequest):
                 payload,
                 request.headers,
                 run_id=run_id,
+                request_start_time=request.scope.get("request_start_time_ms"),
             )
     except Exception:
         if not sub.cancelled():

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/logging.py

@@ -81,23 +81,6 @@ class JSONRenderer:
 LEVELS = logging.getLevelNamesMapping()
 
 
-class TapForMetadata:
-    def __call__(
-        self, logger: logging.Logger, method_name: str, event_dict: EventDict
-    ) -> str:
-        """
-        Tap WARN and above logs for metadata. Exclude user loggers.
-        """
-        if (
-            event_dict["logger"].startswith("langgraph")
-            and LEVELS[event_dict["level"].upper()] > LEVELS["INFO"]
-        ):
-            from langgraph_api.metadata import append_log
-
-            append_log(event_dict.copy())
-        return event_dict
-
-
 # shared config, for both logging and structlog
 
 shared_processors = [
@@ -136,7 +119,6 @@ class Formatter(structlog.stdlib.ProcessorFormatter):
         super().__init__(
             processors=[
                 structlog.stdlib.ProcessorFormatter.remove_processors_meta,
-                TapForMetadata(),
                 renderer,
             ],
             foreign_pre_chain=shared_processors,

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/metadata.py

@@ -35,7 +35,6 @@ else:
 PLAN = "enterprise" if plus_features_enabled() else "developer"
 USER_API_URL = os.getenv("LANGGRAPH_API_URL", None)
 
-LOGS: list[dict] = []
 RUN_COUNTER = 0
 NODE_COUNTER = 0
 FROM_TIMESTAMP = datetime.now(UTC).isoformat()
@@ -59,14 +58,6 @@ def incr_nodes(_, *, incr: int = 1) -> None:
     NODE_COUNTER += incr
 
 
-def append_log(log: dict) -> None:
-    if not LANGGRAPH_CLOUD_LICENSE_KEY and not LANGSMITH_API_KEY:
-        return
-
-    global LOGS
-    LOGS.append(log)
-
-
 async def metadata_loop() -> None:
     try:
         from langgraph_api import __version__
@@ -91,8 +82,6 @@ async def metadata_loop() -> None:
         to_timestamp = datetime.now(UTC).isoformat()
         nodes = NODE_COUNTER
         runs = RUN_COUNTER
-        logs = LOGS.copy()
-        LOGS.clear()
         RUN_COUNTER = 0
         NODE_COUNTER = 0
         FROM_TIMESTAMP = to_timestamp
@@ -123,7 +112,7 @@ async def metadata_loop() -> None:
                 "langgraph.platform.runs": runs,
                 "langgraph.platform.nodes": nodes,
             },
-            "logs": logs,
+            "logs": [],
         }
         try:
             await http_request(

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/middleware/request_id.py

@@ -1,6 +1,7 @@
 """Middleware to handle setting request IDs for logging."""
 
 import re
+import time
 import uuid
 
 from starlette.types import ASGIApp, Receive, Scope, Send
@@ -27,4 +28,5 @@ class RequestIdMiddleware:
             if request_id is None:
                 request_id = str(uuid.uuid4()).encode()
                 scope["headers"].append((b"x-request-id", request_id))
+            scope["request_start_time_ms"] = int(time.time() * 1000)
         await self.app(scope, receive, send)

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/models/run.py

@@ -1,6 +1,7 @@
 import asyncio
 import functools
 import re
+import time
 import urllib.parse
 import uuid
 from collections.abc import Mapping, Sequence
@@ -249,6 +250,7 @@ async def create_valid_run(
     headers: Mapping[str, str],
     barrier: asyncio.Barrier | None = None,
     run_id: UUID | None = None,
+    request_start_time: float | None = None,
 ) -> Run:
     request_id = headers.get("x-request-id")  # Will be null in the crons scheduler.
     (
@@ -293,6 +295,11 @@ async def create_valid_run(
         user_id = None
     if not configurable.get("langgraph_request_id"):
         configurable["langgraph_request_id"] = request_id
+    if request_start_time:
+        configurable["__request_start_time_ms__"] = request_start_time
+    after_seconds = payload.get("after_seconds", 0)
+    configurable["__after_seconds__"] = after_seconds
+    put_time_start = time.time()
     run_coro = Runs.put(
         conn,
         assistant_id,
@@ -317,7 +324,7 @@ async def create_valid_run(
         run_id=run_id,
         multitask_strategy=multitask_strategy,
         prevent_insert_if_inflight=prevent_insert_if_inflight,
-        after_seconds=payload.get("after_seconds", 0),
+        after_seconds=after_seconds,
         if_not_exists=payload.get("if_not_exists", "reject"),
     )
     run_ = await run_coro
@@ -344,8 +351,14 @@ async def create_valid_run(
             multitask_strategy=multitask_strategy,
             stream_mode=stream_mode,
             temporary=temporary,
-            after_seconds=payload.get("after_seconds", 0),
+            after_seconds=after_seconds,
             if_not_exists=payload.get("if_not_exists", "reject"),
+            run_create_ms=(
+                int(time.time() * 1_000) - request_start_time
+                if request_start_time
+                else None
+            ),
+            run_put_ms=int((time.time() - put_time_start) * 1_000),
         )
         # inserted, proceed
         if multitask_strategy in ("interrupt", "rollback") and inflight_runs:

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/stream.py

@@ -207,11 +207,16 @@ async def astream_state(
                 elif "events" in stream_mode:
                     yield "events", event
     else:
+        output_keys = kwargs.pop("output_keys", graph.output_channels)
         async with (
             stack,
             aclosing(
                 graph.astream(
-                    input, config, stream_mode=list(stream_modes_set), **kwargs
+                    input,
+                    config,
+                    stream_mode=list(stream_modes_set),
+                    output_keys=output_keys,
+                    **kwargs,
                 )
             ) as stream,
         ):

{langgraph_api-0.2.40 → langgraph_api-0.2.43}/langgraph_api/worker.py

@@ -1,4 +1,5 @@
 import asyncio
+import time
 from collections.abc import AsyncGenerator
 from contextlib import AsyncExitStack, asynccontextmanager
 from datetime import UTC, datetime
@@ -74,8 +75,21 @@ async def worker(
     exception: Exception | None = None
     status: str | None = None
     webhook = run["kwargs"].get("webhook", None)
-    run_started_at = datetime.now(UTC)
+    request_created_at: int | None = run["kwargs"]["config"]["configurable"].get(
+        "__request_start_time_ms__"
+    )
+    after_seconds = run["kwargs"]["config"]["configurable"].get("__after_seconds__", 0)
     run_ended_at: str | None = None
+    run_started_at = datetime.now(UTC)
+    # Note that "created_at" is inclusive of the `after_seconds`
+    run_creation_ms = (
+        int(
+            ((run["created_at"].timestamp() - after_seconds) * 1_000)
+            - request_created_at
+        )
+        if request_created_at is not None
+        else None
+    )
 
     async with (
         connect() as conn,
@@ -95,11 +109,13 @@ async def worker(
                 "request_id": _get_request_id(run),
             }
         )
-
+        run_stream_started_at = datetime.now(UTC)
         await logger.ainfo(
             "Starting background run",
             run_started_at=run_started_at.isoformat(),
+            run_creation_ms=run_creation_ms,
             run_queue_ms=ms(run_started_at, run["created_at"]),
+            run_stream_start_ms=ms(run_stream_started_at, run_started_at),
         )
 
         def on_checkpoint(checkpoint_arg: CheckpointPayload):
@@ -115,7 +131,15 @@ async def worker(
 
         try:
             if attempt > BG_JOB_MAX_RETRIES:
-                await logger.aerror("Run exceeded max attempts", run_id=run["run_id"])
+                await logger.aerror(
+                    "Run exceeded max attempts",
+                    run_id=run["run_id"],
+                    run_completed_in_ms=(
+                        int((time.time() * 1_000) - request_created_at)
+                        if request_created_at is not None
+                        else None
+                    ),
+                )
 
                 error_message = (
                     f"Run {run['run_id']} exceeded max attempts ({BG_JOB_MAX_RETRIES}).\n\n"
@@ -131,13 +155,12 @@ async def worker(
                     )
 
                 raise RuntimeError(error_message)
+            exit_stack = AsyncExitStack()
             if temporary:
-                stream = astream_state(
-                    AsyncExitStack(), conn, cast(Run, run), attempt, done
-                )
+                stream = astream_state(exit_stack, conn, cast(Run, run), attempt, done)
             else:
                 stream = astream_state(
-                    AsyncExitStack(),
+                    exit_stack,
                     conn,
                     cast(Run, run),
                     attempt,
@@ -149,7 +172,8 @@ async def worker(
                 consume(stream, run_id, resumable),
                 BG_JOB_TIMEOUT_SECS,
             )
-            run_ended_at = datetime.now(UTC).isoformat()
+            run_ended_at_dt = datetime.now(UTC)
+            run_ended_at = run_ended_at_dt.isoformat()
             await logger.ainfo(
                 "Background run succeeded",
                 run_id=str(run_id),
@@ -157,7 +181,12 @@ async def worker(
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
                 run_ended_at=run_ended_at,
-                run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                run_completed_in_ms=(
+                    int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
+                    if request_created_at is not None
+                    else None
+                ),
             )
             status = "success"
             await Runs.set_status(conn, run_id, "success")
@@ -173,13 +202,21 @@ async def worker(
                 run_started_at=run_started_at.isoformat(),
                 run_ended_at=run_ended_at,
                 run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                run_completed_in_ms=(
+                    int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
+                    if request_created_at is not None
+                    else None
+                ),
             )
             await Runs.set_status(conn, run_id, "timeout")
         except UserRollback as e:
             exception = e
             status = "rollback"
-            run_ended_at = datetime.now(UTC).isoformat()
+            run_ended_at_dt = datetime.now(UTC)
+            run_ended_at = run_ended_at_dt.isoformat()
             try:
+                # Need to close the pipeline to re-use the connection
+                await exit_stack.aclose()
                 await Runs.delete(conn, run_id, thread_id=run["thread_id"])
                 await logger.ainfo(
                     "Background run rolled back",
@@ -188,7 +225,12 @@ async def worker(
                     run_created_at=run_created_at,
                     run_started_at=run_started_at.isoformat(),
                     run_ended_at=run_ended_at,
-                    run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                    run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                    run_completed_in_ms=(
+                        int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
+                        if request_created_at is not None
+                        else None
+                    ),
                 )
 
             except InFailedSqlTransaction as e:
@@ -199,9 +241,6 @@ async def worker(
                     run_created_at=run_created_at,
                     exc=str(e),
                 )
-                # We need to clean up the transaction early if we want to
-                # update the thread status with the same connection
-                await exit.aclose()
             except HTTPException as e:
                 if e.status_code == 404:
                     await logger.ainfo(
@@ -217,7 +256,8 @@ async def worker(
         except UserInterrupt as e:
             exception = e
             status = "interrupted"
-            run_ended_at = datetime.now(UTC).isoformat()
+            run_ended_at_dt = datetime.now(UTC)
+            run_ended_at = run_ended_at_dt.isoformat()
             await logger.ainfo(
                 "Background run interrupted",
                 run_id=str(run_id),
@@ -225,13 +265,19 @@ async def worker(
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
                 run_ended_at=run_ended_at,
-                run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                run_completed_in_ms=(
+                    int((run_ended_at_dt.timestamp() * 1_000) - request_created_at)
+                    if request_created_at is not None
+                    else None
+                ),
             )
             await Runs.set_status(conn, run_id, "interrupted")
         except RETRIABLE_EXCEPTIONS as e:
             exception = e
             status = "retry"
-            run_ended_at = datetime.now(UTC).isoformat()
+            run_ended_at_dt = datetime.now(UTC)
+            run_ended_at = run_ended_at_dt.isoformat()
             await logger.awarning(
                 f"Background run failed, will retry. Exception: {e}",
                 exc_info=True,
@@ -240,14 +286,15 @@ async def worker(
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
                 run_ended_at=run_ended_at,
-                run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                run_exec_ms=ms(run_ended_at_dt, run_started_at),
             )
             await Runs.set_status(conn, run_id, "pending")
             raise
         except Exception as exc:
             exception = exc
             status = "error"
-            run_ended_at = datetime.now(UTC).isoformat()
+            run_ended_at_dt = datetime.now(UTC)
+            run_ended_at = run_ended_at_dt.isoformat()
             await logger.aexception(
                 f"Background run failed. Exception: {exc}",
                 exc_info=not isinstance(exc, RemoteException),
@@ -256,7 +303,7 @@ async def worker(
                 run_created_at=run_created_at,
                 run_started_at=run_started_at.isoformat(),
                 run_ended_at=run_ended_at,
-                run_exec_ms=ms(datetime.now(UTC), run_started_at),
+                run_exec_ms=ms(run_ended_at_dt, run_started_at),
             )
             await Runs.set_status(conn, run_id, "error")
         set_auth_ctx(None, None)

langgraph_api-0.2.40/langgraph_api/__init__.py

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