langgraph-api 0.2.45__tar.gz → 0.2.48__tar.gz

{langgraph_api-0.2.45 → langgraph_api-0.2.48}/PKG-INFO

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

langgraph_api-0.2.48/langgraph_api/__init__.py

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

{langgraph_api-0.2.45 → langgraph_api-0.2.48}/langgraph_api/api/assistants.py

@@ -189,40 +189,40 @@ async def get_assistant_graph(
     async with connect() as conn:
         assistant_ = await Assistants.get(conn, assistant_id)
         assistant = await fetchone(assistant_)
-        config = await ajson_loads(assistant["config"])
-        async with get_graph(
-            assistant["graph_id"],
-            config,
-            checkpointer=Checkpointer(conn),
-            store=(await api_store.get_store()),
-        ) as graph:
-            xray: bool | int = False
-            xray_query = request.query_params.get("xray")
-            if xray_query:
-                if xray_query in ("true", "True"):
-                    xray = True
-                elif xray_query in ("false", "False"):
-                    xray = False
-                else:
-                    try:
-                        xray = int(xray_query)
-                    except ValueError:
-                        raise HTTPException(422, detail="Invalid xray value") from None
-
-                    if xray <= 0:
-                        raise HTTPException(422, detail="Invalid xray value") from None
-
-            if isinstance(graph, BaseRemotePregel):
-                drawable_graph = await graph.fetch_graph(xray=xray)
-                return ApiResponse(drawable_graph.to_json())
+    config = await ajson_loads(assistant["config"])
+    async with get_graph(
+        assistant["graph_id"],
+        config,
+        checkpointer=Checkpointer(),
+        store=(await api_store.get_store()),
+    ) as graph:
+        xray: bool | int = False
+        xray_query = request.query_params.get("xray")
+        if xray_query:
+            if xray_query in ("true", "True"):
+                xray = True
+            elif xray_query in ("false", "False"):
+                xray = False
+            else:
+                try:
+                    xray = int(xray_query)
+                except ValueError:
+                    raise HTTPException(422, detail="Invalid xray value") from None
+
+                if xray <= 0:
+                    raise HTTPException(422, detail="Invalid xray value") from None
+
+        if isinstance(graph, BaseRemotePregel):
+            drawable_graph = await graph.fetch_graph(xray=xray)
+            return ApiResponse(drawable_graph.to_json())
 
-            try:
-                drawable_graph = await graph.aget_graph(xray=xray)
-                return ApiResponse(drawable_graph.to_json())
-            except NotImplementedError:
-                raise HTTPException(
-                    422, detail="The graph does not support visualization"
-                ) from None
+        try:
+            drawable_graph = await graph.aget_graph(xray=xray)
+            return ApiResponse(drawable_graph.to_json())
+        except NotImplementedError:
+            raise HTTPException(
+                422, detail="The graph does not support visualization"
+            ) from None
 
 
 @retry_db
@@ -239,7 +239,7 @@ async def get_assistant_subgraphs(
         async with get_graph(
             assistant["graph_id"],
             config,
-            checkpointer=Checkpointer(conn),
+            checkpointer=Checkpointer(),
             store=(await api_store.get_store()),
         ) as graph:
             namespace = request.path_params.get("namespace")
@@ -285,7 +285,7 @@ async def get_assistant_schemas(
         async with get_graph(
             assistant["graph_id"],
             config,
-            checkpointer=Checkpointer(conn),
+            checkpointer=Checkpointer(),
             store=(await api_store.get_store()),
         ) as graph:
             if isinstance(graph, BaseRemotePregel):

{langgraph_api-0.2.45 → langgraph_api-0.2.48}/langgraph_api/api/meta.py

@@ -2,7 +2,7 @@ import os
 
 from starlette.responses import JSONResponse, PlainTextResponse
 
-from langgraph_api import config, metadata
+from langgraph_api import __version__, config, metadata
 from langgraph_api.route import ApiRequest
 from langgraph_license.validation import plus_features_enabled
 from langgraph_runtime.database import connect, pool_stats
@@ -16,10 +16,12 @@ async def meta_info(request: ApiRequest):
     plus = plus_features_enabled()
     return JSONResponse(
         {
+            "version": __version__,
             "flags": {
                 "assistants": True,
                 "crons": plus and config.FF_CRONS_ENABLED,
                 "langsmith": bool(config.LANGSMITH_API_KEY) and bool(config.TRACING),
+                "langsmith_tracing_replicas": True,
             },
             "host": {
                 "kind": metadata.HOST,

{langgraph_api-0.2.45 → langgraph_api-0.2.48}/langgraph_api/api/runs.py

@@ -222,6 +222,9 @@ async def wait_run(request: ApiRequest):
         stream = asyncio.create_task(consume())
         while True:
             try:
+                if stream.done():
+                    # raise stream exception if any
+                    stream.result()
                 yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
                 break
             except TimeoutError:
@@ -270,7 +273,10 @@ async def wait_run_stateless(request: ApiRequest):
         vchunk: bytes | None = None
         async with aclosing(
             Runs.Stream.join(
-                run["run_id"], thread_id=run["thread_id"], stream_mode=await sub
+                run["run_id"],
+                thread_id=run["thread_id"],
+                stream_mode=await sub,
+                ignore_404=True,
             )
         ) as stream:
             async for mode, chunk, _ in stream:
@@ -290,6 +296,9 @@ async def wait_run_stateless(request: ApiRequest):
         stream = asyncio.create_task(consume())
         while True:
             try:
+                if stream.done():
+                    # raise stream exception if any
+                    stream.result()
                 yield await asyncio.wait_for(last_chunk.wait(), timeout=5)
                 break
             except TimeoutError:

{langgraph_api-0.2.45 → langgraph_api-0.2.48}/langgraph_api/js/remote.py

@@ -48,7 +48,6 @@ from langgraph_api.js.sse import SSEDecoder, aiter_lines_raw
 from langgraph_api.route import ApiResponse
 from langgraph_api.schema import Config
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import AsyncConnectionProto
 
 logger = structlog.stdlib.get_logger(__name__)
 
@@ -469,10 +468,10 @@ class PassthroughSerialiser(SerializerProtocol):
         return orjson.loads(payload)
 
 
-def _get_passthrough_checkpointer(conn: AsyncConnectionProto):
+def _get_passthrough_checkpointer():
     from langgraph_runtime.checkpoint import Checkpointer
 
-    checkpointer = Checkpointer(conn)
+    checkpointer = Checkpointer()
     # This checkpointer does not attempt to revive LC-objects.
     # Instead, it will pass through the JSON values as-is.
     checkpointer.serde = PassthroughSerialiser()
@@ -487,53 +486,46 @@ async def _get_passthrough_store():
 # Setup a HTTP server on top of CHECKPOINTER_SOCKET unix socket
 # used by `client.mts` to communicate with the Python checkpointer
 async def run_remote_checkpointer():
-    from langgraph_runtime.database import connect
-
     async def checkpointer_list(payload: dict):
         """Search checkpoints"""
 
         result = []
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            async for item in checkpointer.alist(
-                config=payload.get("config"),
-                limit=int(payload.get("limit") or 10),
-                before=payload.get("before"),
-                filter=payload.get("filter"),
-            ):
-                result.append(item)
+        checkpointer = _get_passthrough_checkpointer()
+        async for item in checkpointer.alist(
+            config=payload.get("config"),
+            limit=int(payload.get("limit") or 10),
+            before=payload.get("before"),
+            filter=payload.get("filter"),
+        ):
+            result.append(item)
 
         return result
 
     async def checkpointer_put(payload: dict):
         """Put the new checkpoint metadata"""
 
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            return await checkpointer.aput(
-                payload["config"],
-                payload["checkpoint"],
-                payload["metadata"],
-                payload.get("new_versions", {}),
-            )
+        checkpointer = _get_passthrough_checkpointer()
+        return await checkpointer.aput(
+            payload["config"],
+            payload["checkpoint"],
+            payload["metadata"],
+            payload.get("new_versions", {}),
+        )
 
     async def checkpointer_get_tuple(payload: dict):
         """Get actual checkpoint values (reads)"""
-
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            return await checkpointer.aget_tuple(config=payload["config"])
+        checkpointer = _get_passthrough_checkpointer()
+        return await checkpointer.aget_tuple(config=payload["config"])
 
     async def checkpointer_put_writes(payload: dict):
         """Put actual checkpoint values (writes)"""
 
-        async with connect() as conn:
-            checkpointer = _get_passthrough_checkpointer(conn)
-            return await checkpointer.aput_writes(
-                payload["config"],
-                payload["writes"],
-                payload["taskId"],
-            )
+        checkpointer = _get_passthrough_checkpointer()
+        return await checkpointer.aput_writes(
+            payload["config"],
+            payload["writes"],
+            payload["taskId"],
+        )
 
     async def store_batch(payload: dict):
         """Batch operations on the store"""

{langgraph_api-0.2.45 → langgraph_api-0.2.48}/langgraph_api/stream.py

@@ -32,7 +32,6 @@ from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
 from langgraph_api.schema import Run, StreamMode
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import AsyncConnectionProto
 from langgraph_runtime.checkpoint import Checkpointer
 from langgraph_runtime.ops import Runs
 
@@ -79,8 +78,6 @@ async def async_tracing_context(*args, **kwargs):
 
 
 async def astream_state(
-    stack: AsyncExitStack,
-    conn: AsyncConnectionProto,
     run: Run,
     attempt: int,
     done: ValueEvent,
@@ -90,7 +87,6 @@ async def astream_state(
 ) -> AnyStream:
     """Stream messages from the runnable."""
     run_id = str(run["run_id"])
-    await stack.enter_async_context(conn.pipeline())
     # extract args from run
     kwargs = run["kwargs"].copy()
     kwargs.pop("webhook", None)
@@ -98,12 +94,13 @@ async def astream_state(
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
     config = kwargs.pop("config")
+    stack = AsyncExitStack()
     graph = await stack.enter_async_context(
         get_graph(
             config["configurable"]["graph_id"],
             config,
             store=(await api_store.get_store()),
-            checkpointer=None if temporary else Checkpointer(conn),
+            checkpointer=None if temporary else Checkpointer(),
         )
     )
     input = kwargs.pop("input")

langgraph_api-0.2.48/langgraph_api/worker.py

@@ -0,0 +1,366 @@
+import asyncio
+import time
+from collections.abc import AsyncGenerator
+from contextlib import asynccontextmanager
+from datetime import UTC, datetime
+from typing import TypedDict, cast
+
+import structlog
+from langgraph.pregel.debug import CheckpointPayload, TaskResultPayload
+from starlette.exceptions import HTTPException
+
+import langgraph_api.logging as lg_logging
+from langgraph_api.auth.custom import SimpleUser, normalize_user
+from langgraph_api.config import (
+    BG_JOB_ISOLATED_LOOPS,
+    BG_JOB_MAX_RETRIES,
+    BG_JOB_TIMEOUT_SECS,
+)
+from langgraph_api.errors import UserInterrupt, UserRollback
+from langgraph_api.js.errors import RemoteException
+from langgraph_api.metadata import incr_runs
+from langgraph_api.schema import Run
+from langgraph_api.state import state_snapshot_to_thread_state
+from langgraph_api.stream import astream_state, consume
+from langgraph_api.utils import with_user
+from langgraph_runtime.database import connect
+from langgraph_runtime.ops import Runs, Threads
+from langgraph_runtime.retry import RETRIABLE_EXCEPTIONS
+
+logger = structlog.stdlib.get_logger(__name__)
+
+
+class WorkerResult(TypedDict):
+    checkpoint: CheckpointPayload | None
+    status: str | None
+    exception: Exception | None
+    run: Run
+    webhook: str | None
+    run_started_at: str
+    run_ended_at: str | None
+
+
+@asynccontextmanager
+async def set_auth_ctx_for_run(
+    run_kwargs: dict, user_id: str | None = None
+) -> AsyncGenerator[None, None]:
+    # user_id is a fallback.
+    try:
+        user = run_kwargs["config"]["configurable"]["langgraph_auth_user"]
+        permissions = run_kwargs["config"]["configurable"]["langgraph_auth_permissions"]
+        user = normalize_user(user)
+    except Exception:
+        user = SimpleUser(user_id) if user_id is not None else None
+        permissions = None
+    if user is not None:
+        async with with_user(user, permissions):
+            yield None
+    else:
+        yield None
+
+
+async def worker(
+    run: Run,
+    attempt: int,
+    main_loop: asyncio.AbstractEventLoop,
+) -> WorkerResult:
+    run_id = run["run_id"]
+    if attempt == 1:
+        incr_runs()
+    checkpoint: CheckpointPayload | None = None
+    exception: Exception | None = None
+    status: str | None = None
+    webhook = run["kwargs"].get("webhook", None)
+    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
+    )
+    temporary = run["kwargs"].get("temporary", False)
+    resumable = run["kwargs"].get("resumable", False)
+    run_created_at = run["created_at"].isoformat()
+    lg_logging.set_logging_context(
+        {
+            "run_id": str(run_id),
+            "run_attempt": attempt,
+            "thread_id": str(run.get("thread_id")),
+            "assistant_id": str(run.get("assistant_id")),
+            "graph_id": _get_graph_id(run),
+            "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):
+        nonlocal checkpoint
+        checkpoint = checkpoint_arg
+
+    def on_task_result(task_result: TaskResultPayload):
+        if checkpoint is not None:
+            for task in checkpoint["tasks"]:
+                if task["id"] == task_result["id"]:
+                    task.update(task_result)
+                    break
+
+    async with Runs.enter(run_id, main_loop) as done:
+        # attempt the run
+        try:
+            if attempt > BG_JOB_MAX_RETRIES:
+                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"
+                    "This may happen if your code blocks the event loop with synchronous I/O bound calls (network requests, database queries, etc.).\n\n"
+                    "If that is the case, your issues may be resolved by converting synchronous operations to async (e.g., use aiohttp instead of requests).\n\n"
+                )
+
+                if not BG_JOB_ISOLATED_LOOPS:
+                    error_message += (
+                        "Also consider setting BG_JOB_ISOLATED_LOOPS=true in your environment. This will isolate I/O-bound operations to avoid"
+                        " blocking the main API server.\n\n"
+                        "See: https://langchain-ai.github.io/langgraph/cloud/reference/env_var/#bg_job_isolated_loops\n\n"
+                    )
+
+                raise RuntimeError(error_message)
+            async with set_auth_ctx_for_run(run["kwargs"]):
+                if temporary:
+                    stream = astream_state(cast(Run, run), attempt, done)
+                else:
+                    stream = astream_state(
+                        cast(Run, run),
+                        attempt,
+                        done,
+                        on_checkpoint=on_checkpoint,
+                        on_task_result=on_task_result,
+                    )
+                await asyncio.wait_for(
+                    consume(stream, run_id, resumable),
+                    BG_JOB_TIMEOUT_SECS,
+                )
+                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),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_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 Exception as ee:
+            # Note we don't handle asyncio.CancelledError here, as we want to
+            # let it bubble up and rollback db transaction, thus marking the run
+            # as available to be picked up by another worker
+            exception = ee
+
+        # handle exceptions and set status
+        async with connect() as conn:
+            if exception is None:
+                status = "success"
+                await Runs.set_status(conn, run_id, "success")
+                # If a stateful run succeeded but no checkpoint was returned, likely
+                # there was a retriable exception that resumed right at the end
+                if checkpoint is None and not temporary:
+                    await logger.ainfo(
+                        "Fetching missing checkpoint for webhook",
+                        run_id=str(run_id),
+                        run_attempt=attempt,
+                    )
+                    try:
+                        state_snapshot = await Threads.State.get(
+                            conn, run["kwargs"]["config"]
+                        )
+                        checkpoint = state_snapshot_to_thread_state(state_snapshot)
+                    except Exception:
+                        await logger.aerror(
+                            "Failed to fetch missing checkpoint for webhook. Continuing...",
+                            exc_info=True,
+                            run_id=str(run_id),
+                            run_attempt=attempt,
+                        )
+            elif isinstance(exception, TimeoutError):
+                status = "timeout"
+                run_ended_at = datetime.now(UTC).isoformat()
+                await logger.awarning(
+                    "Background run timed out",
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    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_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")
+            elif isinstance(exception, UserRollback):
+                status = "rollback"
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
+                try:
+                    await Runs.delete(conn, run_id, thread_id=run["thread_id"])
+                    await logger.ainfo(
+                        "Background run rolled back",
+                        run_id=str(run_id),
+                        run_attempt=attempt,
+                        run_created_at=run_created_at,
+                        run_started_at=run_started_at.isoformat(),
+                        run_ended_at=run_ended_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 HTTPException as e:
+                    if e.status_code == 404:
+                        await logger.ainfo(
+                            "Ignoring rollback error for missing run",
+                            run_id=str(run_id),
+                            run_attempt=attempt,
+                            run_created_at=run_created_at,
+                        )
+                    else:
+                        raise
+
+                checkpoint = None  # reset the checkpoint
+            elif isinstance(exception, UserInterrupt):
+                status = "interrupted"
+                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),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_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")
+            elif isinstance(exception, RETRIABLE_EXCEPTIONS):
+                status = "retry"
+                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: {exception}",
+                    exc_info=True,
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                )
+                await Runs.set_status(conn, run_id, "pending")
+            else:
+                status = "error"
+                run_ended_at_dt = datetime.now(UTC)
+                run_ended_at = run_ended_at_dt.isoformat()
+                await logger.aexception(
+                    f"Background run failed. Exception: {exception}",
+                    exc_info=not isinstance(exception, RemoteException),
+                    run_id=str(run_id),
+                    run_attempt=attempt,
+                    run_created_at=run_created_at,
+                    run_started_at=run_started_at.isoformat(),
+                    run_ended_at=run_ended_at,
+                    run_exec_ms=ms(run_ended_at_dt, run_started_at),
+                )
+                await Runs.set_status(conn, run_id, "error")
+
+            # delete or set status of thread
+            if not isinstance(exception, RETRIABLE_EXCEPTIONS):
+                if temporary:
+                    await Threads.delete(conn, run["thread_id"])
+                else:
+                    try:
+                        await Threads.set_status(
+                            conn, run["thread_id"], checkpoint, exception
+                        )
+                    except HTTPException as e:
+                        if e.status_code == 404:
+                            await logger.ainfo(
+                                "Ignoring set_status error for missing thread",
+                                exc=str(e),
+                            )
+                        else:
+                            raise
+
+        if isinstance(exception, RETRIABLE_EXCEPTIONS):
+            # re-raise so Runs.enter knows not to mark as done
+            # Runs.enter will catch the exception, but what triggers the retry
+            # is setting the status to "pending"
+            raise exception
+
+    return WorkerResult(
+        checkpoint=checkpoint,
+        status=status,
+        exception=exception,
+        run=run,
+        webhook=webhook,
+        run_started_at=run_started_at.isoformat(),
+        run_ended_at=run_ended_at,
+    )
+
+
+def ms(after: datetime, before: datetime) -> int:
+    return int((after - before).total_seconds() * 1000)
+
+
+def _get_request_id(run: Run) -> str | None:
+    try:
+        return run["kwargs"]["config"]["configurable"]["langgraph_request_id"]
+    except Exception:
+        return None
+
+
+def _get_graph_id(run: Run) -> str | None:
+    try:
+        return run["kwargs"]["config"]["configurable"]["graph_id"]
+    except Exception:
+        logger.info(f"Failed to get graph_id from run {run['run_id']}")
+        return "Unknown"