langgraph-api 0.0.15__py3-none-any.whl → 0.0.17__py3-none-any.whl

langgraph_api/api/assistants.py

@@ -1,6 +1,7 @@
 from typing import Any
 from uuid import uuid4
 
+import structlog
 from langchain_core.runnables.utils import create_model
 from langgraph.pregel import Pregel
 from starlette.exceptions import HTTPException
@@ -23,6 +24,8 @@ from langgraph_storage.database import connect
 from langgraph_storage.ops import Assistants
 from langgraph_storage.retry import retry_db
 
+logger = structlog.stdlib.get_logger(__name__)
+
 
 def _state_jsonschema(graph: Pregel) -> dict | None:
     fields: dict = {}
@@ -39,11 +42,17 @@ def _state_jsonschema(graph: Pregel) -> dict | None:
 def _graph_schemas(graph: Pregel) -> dict:
     try:
         input_schema = graph.get_input_jsonschema()
-    except Exception:
+    except Exception as e:
+        logger.warning(
+            f"Failed to get input schema for graph {graph.name} with error: `{str(e)}`"
+        )
         input_schema = None
     try:
         output_schema = graph.get_output_jsonschema()
-    except Exception:
+    except Exception as e:
+        logger.warning(
+            f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
+        )
         output_schema = None
     state_schema = _state_jsonschema(graph)
     try:
@@ -52,7 +61,10 @@ def _graph_schemas(graph: Pregel) -> dict:
             if "configurable" in graph.config_schema().__fields__
             else {}
         )
-    except Exception:
+    except Exception as e:
+        logger.warning(
+            f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
+        )
         config_schema = None
     return {
         "input_schema": input_schema,
@@ -141,7 +153,13 @@ async def get_assistant_graph(
         if isinstance(graph, BaseRemotePregel):
             drawable_graph = await graph.fetch_graph(xray=xray)
             return ApiResponse(drawable_graph.to_json())
-        return ApiResponse(graph.get_graph(xray=xray).to_json())
+
+        try:
+            return ApiResponse(graph.get_graph(xray=xray).to_json())
+        except NotImplementedError:
+            raise HTTPException(
+                422, detail="The graph does not support visualization"
+            ) from None
 
 
 @retry_db
@@ -167,16 +185,21 @@ async def get_assistant_subgraphs(
                 )
             )
 
-        return ApiResponse(
-            {
-                ns: _graph_schemas(subgraph)
-                async for ns, subgraph in graph.aget_subgraphs(
-                    namespace=namespace,
-                    recurse=request.query_params.get("recurse", "False")
-                    in ("true", "True"),
-                )
-            }
-        )
+        try:
+            return ApiResponse(
+                {
+                    ns: _graph_schemas(subgraph)
+                    async for ns, subgraph in graph.aget_subgraphs(
+                        namespace=namespace,
+                        recurse=request.query_params.get("recurse", "False")
+                        in ("true", "True"),
+                    )
+                }
+            )
+        except NotImplementedError:
+            raise HTTPException(
+                422, detail="The graph does not support visualization"
+            ) from None
 
 
 @retry_db
@@ -205,11 +228,17 @@ async def get_assistant_schemas(
 
         try:
             input_schema = graph.get_input_schema().schema()
-        except Exception:
+        except Exception as e:
+            logger.warning(
+                f"Failed to get input schema for graph {graph.name} with error: `{str(e)}`"
+            )
             input_schema = None
         try:
             output_schema = graph.get_output_schema().schema()
-        except Exception:
+        except Exception as e:
+            logger.warning(
+                f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
+            )
             output_schema = None
 
         state_schema = _state_jsonschema(graph)
@@ -219,8 +248,11 @@ async def get_assistant_schemas(
                 if "configurable" in graph.config_schema().__fields__
                 else {}
             )
-        except Exception:
+        except Exception as e:
             config_schema = None
+            logger.warning(
+                f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
+            )
         return ApiResponse(
             {
                 "graph_id": assistant["graph_id"],

langgraph_api/api/store.py

@@ -1,7 +1,12 @@
+from typing import Any
+
+from langgraph_sdk.auth import Auth
 from starlette.responses import Response
 from starlette.routing import BaseRoute
 
+from langgraph_api.auth.custom import handle_event as _handle_event
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
+from langgraph_api.utils import get_auth_ctx
 from langgraph_api.validation import (
     StoreDeleteRequest,
     StoreListNamespacesRequest,
@@ -21,6 +26,24 @@ def _validate_namespace(namespace: tuple[str, ...]) -> Response | None:
             )
 
 
+async def handle_event(
+    action: str,
+    value: Any,
+) -> None:
+    ctx = get_auth_ctx()
+    if not ctx:
+        return
+    await _handle_event(
+        Auth.types.AuthContext(
+            user=ctx.user,
+            permissions=ctx.permissions,
+            resource="store",
+            action=action,
+        ),
+        value,
+    )
+
+
 @retry_db
 async def put_item(request: ApiRequest):
     """Store or update an item."""
@@ -28,9 +51,13 @@ async def put_item(request: ApiRequest):
     namespace = tuple(payload["namespace"]) if payload.get("namespace") else ()
     if err := _validate_namespace(namespace):
         return err
-    key = payload["key"]
-    value = payload["value"]
-    await Store().aput(namespace, key, value)
+    handler_payload = {
+        "namespace": namespace,
+        "key": payload["key"],
+        "value": payload["value"],
+    }
+    await handle_event("put", handler_payload)
+    await Store().aput(namespace, handler_payload["key"], handler_payload["value"])
     return Response(status_code=204)
 
 
@@ -43,6 +70,11 @@ async def get_item(request: ApiRequest):
     key = request.query_params.get("key")
     if not key:
         return ApiResponse({"error": "Key is required"}, status_code=400)
+    handler_payload = {
+        "namespace": namespace,
+        "key": key,
+    }
+    await handle_event("get", handler_payload)
     result = await Store().aget(namespace, key)
     return ApiResponse(result.dict() if result is not None else None)
 
@@ -54,8 +86,12 @@ async def delete_item(request: ApiRequest):
     namespace = tuple(payload["namespace"]) if payload.get("namespace") else ()
     if err := _validate_namespace(namespace):
         return err
-    key = payload["key"]
-    await Store().adelete(namespace, key)
+    handler_payload = {
+        "namespace": namespace,
+        "key": payload["key"],
+    }
+    await handle_event("delete", handler_payload)
+    await Store().adelete(handler_payload["namespace"], handler_payload["key"])
     return Response(status_code=204)
 
 
@@ -70,12 +106,20 @@ async def search_items(request: ApiRequest):
     limit = payload.get("limit") or 10
     offset = payload.get("offset") or 0
     query = payload.get("query")
+    handler_payload = {
+        "namespace": namespace_prefix,
+        "filter": filter,
+        "limit": limit,
+        "offset": offset,
+        "query": query,
+    }
+    await handle_event("search", handler_payload)
     items = await Store().asearch(
-        namespace_prefix,
-        filter=filter,
-        limit=limit,
-        offset=offset,
-        query=query,
+        handler_payload["namespace"],
+        filter=handler_payload["filter"],
+        limit=handler_payload["limit"],
+        offset=handler_payload["offset"],
+        query=handler_payload["query"],
     )
     return ApiResponse({"items": [item.dict() for item in items]})
 
@@ -93,12 +137,20 @@ async def list_namespaces(request: ApiRequest):
     max_depth = payload.get("max_depth")
     limit = payload.get("limit", 100)
     offset = payload.get("offset", 0)
+    handler_payload = {
+        "namespace": prefix,
+        "suffix": suffix,
+        "max_depth": max_depth,
+        "limit": limit,
+        "offset": offset,
+    }
+    await handle_event("list_namespaces", handler_payload)
     result = await Store().alist_namespaces(
-        prefix=prefix,
-        suffix=suffix,
-        max_depth=max_depth,
-        limit=limit,
-        offset=offset,
+        prefix=handler_payload["namespace"],
+        suffix=handler_payload["suffix"],
+        max_depth=handler_payload["max_depth"],
+        limit=handler_payload["limit"],
+        offset=handler_payload["offset"],
     )
     return ApiResponse({"namespaces": result})
 

langgraph_api/asyncio.py

@@ -60,6 +60,11 @@ async def wait_if_not_done(coro: Coroutine[Any, Any, T], done: ValueEvent) -> T:
             try:
                 return await coro_task
             except asyncio.CancelledError as e:
+                if e.args and asyncio.isfuture(e.args[-1]):
+                    await logger.ainfo(
+                        "Awaiting future upon cancellation", task=str(e.args[-1])
+                    )
+                    await e.args[-1]
                 if e.args and isinstance(e.args[0], Exception):
                     raise e.args[0] from None
                 raise

langgraph_api/auth/custom.py

@@ -16,7 +16,6 @@ from starlette.authentication import (
     AuthenticationBackend,
     AuthenticationError,
     BaseUser,
-    SimpleUser,
 )
 from starlette.concurrency import run_in_threadpool
 from starlette.exceptions import HTTPException
@@ -398,6 +397,16 @@ class DotDict:
             raise AttributeError(f"'DotDict' object has no attribute '{name}'")
         return self._dict[name]
 
+    def __getitem__(self, key):
+        return self._dict[key]
+
+    def __setitem__(self, key, value):
+        self._dict[key] = value
+        if isinstance(value, dict):
+            setattr(self, key, DotDict(value))
+        else:
+            setattr(self, key, value)
+
     def __deepcopy__(self, memo):
         return DotDict(copy.deepcopy(self._dict))
 
@@ -457,11 +466,22 @@ class ProxyUser(BaseUser):
             **d,
         }
 
+    def __getitem__(self, key):
+        return self._user[key]
+
+    def __setitem__(self, key, value):
+        self._user[key] = value
+
     def __getattr__(self, name: str) -> Any:
         """Proxy any other attributes to the underlying user object."""
         return getattr(self._user, name)
 
 
+class SimpleUser(ProxyUser):
+    def __init__(self, username: str):
+        super().__init__(DotDict({"identity": username}))
+
+
 def _normalize_auth_response(
     response: Any,
 ) -> tuple[AuthCredentials, BaseUser]:
@@ -481,10 +501,10 @@ def _normalize_auth_response(
         user = response
         permissions = []
 
-    return AuthCredentials(permissions), _normalize_user(user)
+    return AuthCredentials(permissions), normalize_user(user)
 
 
-def _normalize_user(user: Any) -> BaseUser:
+def normalize_user(user: Any) -> BaseUser:
     """Normalize user into a BaseUser instance."""
     if isinstance(user, BaseUser):
         return user
@@ -571,9 +591,8 @@ def _get_handler(auth: Auth, ctx: Auth.types.AuthContext) -> Auth.types.Handler
     ]
     for key in keys:
         if key in auth._handlers:
-            result = auth._handlers[key][
-                -1
-            ]  # Get the last defined, most specific handler
+            # Get the last defined, most specific handler
+            result = auth._handlers[key][-1]
             auth._handler_cache[key] = result
             return result
     if auth._global_handlers:

langgraph_api/auth/noop.py

@@ -2,11 +2,19 @@ from starlette.authentication import (
     AuthCredentials,
     AuthenticationBackend,
     BaseUser,
-    UnauthenticatedUser,
+)
+from starlette.authentication import (
+    UnauthenticatedUser as StarletteUnauthenticatedUser,
 )
 from starlette.requests import HTTPConnection
 
 
+class UnauthenticatedUser(StarletteUnauthenticatedUser):
+    @property
+    def identity(self) -> str:
+        return ""
+
+
 class NoopAuthBackend(AuthenticationBackend):
     async def authenticate(
         self, conn: HTTPConnection

langgraph_api/config.py

@@ -24,7 +24,12 @@ CORS_ALLOW_ORIGINS = env("CORS_ALLOW_ORIGINS", cast=CommaSeparatedStrings, defau
 
 # queue
 
-BG_JOB_NO_DELAY = env("BG_JOB_NO_DELAY", cast=bool, default=False)
+BG_JOB_NO_DELAY = env("BG_JOB_NO_DELAY", cast=bool, default=None)
+BG_JOB_DELAY = env("BG_JOB_DELAY", cast=float, default=0.5)
+if BG_JOB_NO_DELAY is True:
+    BG_JOB_DELAY = 0
+
+
 N_JOBS_PER_WORKER = env("N_JOBS_PER_WORKER", cast=int, default=10)
 BG_JOB_TIMEOUT_SECS = env("BG_JOB_TIMEOUT_SECS", cast=float, default=3600)
 FF_CRONS_ENABLED = env("FF_CRONS_ENABLED", cast=bool, default=True)

langgraph_api/cron_scheduler.py

@@ -3,10 +3,10 @@ from random import random
 
 import structlog
 from langchain_core.runnables.config import run_in_executor
-from starlette.authentication import SimpleUser
 
 from langgraph_api.models.run import create_valid_run
-from langgraph_api.utils import next_cron_date, with_user
+from langgraph_api.queue import set_auth_ctx_for_run
+from langgraph_api.utils import next_cron_date
 from langgraph_storage.database import connect
 from langgraph_storage.ops import Crons
 from langgraph_storage.retry import retry_db
@@ -23,10 +23,13 @@ async def cron_scheduler():
         try:
             async with connect() as conn:
                 async for cron in Crons.next(conn):
-                    async with with_user(SimpleUser(str(cron["user_id"])), None):
+                    run_payload = cron["payload"]
+
+                    async with set_auth_ctx_for_run(
+                        run_payload, user_id=cron["user_id"]
+                    ):
                         logger.debug(f"Scheduling cron run {cron}")
                         try:
-                            run_payload = cron["payload"]
                             run = await create_valid_run(
                                 conn,
                                 thread_id=(

langgraph_api/js/client.mts

@@ -446,6 +446,7 @@ const StreamModeSchema = z.union([
 const ExtraStreamModeSchema = z.union([
   StreamModeSchema,
   z.literal("messages"),
+  z.literal("messages-tuple"),
 ]);
 
 const StreamEventsPayload = z.object({
@@ -476,11 +477,14 @@ async function* streamEventsRequest(
         ? payload.stream_mode
         : [payload.stream_mode];
 
-  const graphStreamMode: Set<"updates" | "debug" | "values"> = new Set();
+  const graphStreamMode: Set<"updates" | "debug" | "values" | "messages"> =
+    new Set();
   if (payload.stream_mode) {
     for (const mode of userStreamMode) {
       if (mode === "messages") {
         graphStreamMode.add("values");
+      } else if (mode === "messages-tuple") {
+        graphStreamMode.add("messages");
       } else {
         graphStreamMode.add(mode);
       }

langgraph_api/js/client.new.mts

@@ -504,6 +504,7 @@ const StreamModeSchema = z.union([
 const ExtraStreamModeSchema = z.union([
   StreamModeSchema,
   z.literal("messages"),
+  z.literal("messages-tuple"),
 ]);
 
 const StreamEventsPayload = z.object({
@@ -534,11 +535,14 @@ async function* streamEventsRequest(
         ? payload.stream_mode
         : [payload.stream_mode];
 
-  const graphStreamMode: Set<"updates" | "debug" | "values"> = new Set();
+  const graphStreamMode: Set<"updates" | "debug" | "values" | "messages"> =
+    new Set();
   if (payload.stream_mode) {
     for (const mode of userStreamMode) {
       if (mode === "messages") {
         graphStreamMode.add("values");
+      } else if (mode === "messages-tuple") {
+        graphStreamMode.add("messages");
       } else {
         graphStreamMode.add(mode);
       }

langgraph_api/js/package.json

@@ -10,7 +10,7 @@
     "@hono/node-server": "^1.12.0",
     "@hono/zod-validator": "^0.2.2",
     "@langchain/core": "^0.3.22",
-    "@langchain/langgraph": "^0.2.31",
+    "@langchain/langgraph": "^0.2.35",
     "@types/json-schema": "^7.0.15",
     "@typescript/vfs": "^1.6.0",
     "dedent": "^1.5.3",
@@ -22,7 +22,7 @@
     "undici": "^6.19.7",
     "uuid": "^10.0.0",
     "winston": "^3.15.0",
-    "zeromq": "^6.1.1",
+    "zeromq": "^6.3.0",
     "zod": "^3.23.8"
   },
   "devDependencies": {

langgraph_api/js/remote_new.py

@@ -23,6 +23,7 @@ from langgraph.pregel.types import PregelTask, StateSnapshot
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.types import Command, Interrupt
 from pydantic import BaseModel
+from starlette.exceptions import HTTPException
 from zmq.utils.monitor import recv_monitor_message
 
 from langgraph_api.js.base import BaseRemotePregel
@@ -681,5 +682,12 @@ async def js_healthcheck():
     try:
         await _client_invoke("ok", {})
         return True
-    except (RemoteException, TimeoutError, zmq.error.ZMQBaseError):
-        return False
+    except (RemoteException, TimeoutError, zmq.error.ZMQBaseError) as exc:
+        logger.warning(
+            "JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+            error=exc,
+        )
+        raise HTTPException(
+            status_code=500,
+            detail="JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+        ) from exc

langgraph_api/js/remote_old.py

@@ -22,6 +22,7 @@ from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.types import Command, Interrupt
 from pydantic import BaseModel
 from starlette.applications import Starlette
+from starlette.exceptions import HTTPException
 from starlette.requests import Request
 from starlette.routing import Route
 
@@ -653,5 +654,12 @@ async def js_healthcheck():
             res = await checkpointer_client.get("/ok")
             res.raise_for_status()
             return True
-        except httpx.HTTPError:
-            return False
+        except httpx.HTTPError as exc:
+            logger.warning(
+                "JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+                error=exc,
+            )
+            raise HTTPException(
+                status_code=500,
+                detail="JS healthcheck failed. Either the JS server is not running or the event loop is blocked by a CPU-intensive task.",
+            ) from exc