langgraph-api 0.2.130__py3-none-any.whl → 0.2.132__py3-none-any.whl

langgraph_api/js/remote.py

@@ -106,6 +106,10 @@ async def _client_stream(method: str, data: dict[str, Any]):
                 yield sse.data
 
 
+class NoopModel(BaseModel):
+    pass
+
+
 async def _client_invoke(method: str, data: dict[str, Any]):
     graph_id = data.get("graph_id")
     res = await _client.post(
@@ -177,13 +181,10 @@ class RemotePregel(BaseRemotePregel):
         nodes: list[Any] = response.pop("nodes")
         edges: list[Any] = response.pop("edges")
 
-        class NoopModel(BaseModel):
-            pass
-
         return DrawableGraph(
             {
                 data["id"]: Node(
-                    data["id"], data["id"], NoopModel(), data.get("metadata")
+                    data["id"], data["id"], NoopModel, data.get("metadata")
                 )
                 for data in nodes
             },
@@ -244,9 +245,9 @@ class RemotePregel(BaseRemotePregel):
                 )
             return tuple(result)
 
-        return StateSnapshot(
+        return StateSnapshot(  # type: ignore[missing-argument]
             item.get("values"),
-            item.get("next"),
+            cast(tuple, item.get("next", ())),
             item.get("config"),
             item.get("metadata"),
             item.get("createdAt"),
@@ -352,7 +353,7 @@ class RemotePregel(BaseRemotePregel):
         return result["nodesExecuted"]
 
 
-async def run_js_process(paths_str: str, watch: bool = False):
+async def run_js_process(paths_str: str | None, watch: bool = False):
     # check if tsx is available
     tsx_path = shutil.which("tsx")
     if tsx_path is None:
@@ -360,7 +361,7 @@ async def run_js_process(paths_str: str, watch: bool = False):
             "tsx not found in PATH. Please upgrade to latest LangGraph CLI to support running JS graphs."
         )
     attempt = 0
-    while not asyncio.current_task().cancelled():
+    while (current_task := asyncio.current_task()) and not current_task.cancelled():
         client_file = os.path.join(os.path.dirname(__file__), "client.mts")
         client_preload_file = os.path.join(
             os.path.dirname(__file__), "src", "preload.mjs"
@@ -408,7 +409,9 @@ async def run_js_process(paths_str: str, watch: bool = False):
                 attempt += 1
 
 
-async def run_js_http_process(paths_str: str, http_config: dict, watch: bool = False):
+async def run_js_http_process(
+    paths_str: str | None, http_config: dict, watch: bool = False
+):
     # check if tsx is available
     tsx_path = shutil.which("tsx")
     if tsx_path is None:
@@ -417,7 +420,7 @@ async def run_js_http_process(paths_str: str, http_config: dict, watch: bool = F
         )
 
     attempt = 0
-    while not asyncio.current_task().cancelled():
+    while (current_task := asyncio.current_task()) and not current_task.cancelled():
         client_file = os.path.join(os.path.dirname(__file__), "client.http.mts")
         args = ("tsx", "watch", client_file) if watch else ("tsx", client_file)
         pid = None
@@ -795,7 +798,9 @@ async def wait_until_js_ready():
             ) as checkpointer_client,
         ):
             attempt = 0
-            while not asyncio.current_task().cancelled():
+            while (
+                current_task := asyncio.current_task()
+            ) and not current_task.cancelled():
                 try:
                     res = await graph_client.get("/ok")
                     res.raise_for_status()
@@ -909,7 +914,7 @@ class CustomJsAuthBackend(AuthenticationBackend):
 
 
 async def handle_js_auth_event(
-    ctx: Auth.types.AuthContext | None,
+    ctx: Auth.types.AuthContext,
     value: dict,
 ) -> Auth.types.FilterType | None:
     if hasattr(ctx.user, "dict") and callable(ctx.user.dict):

langgraph_api/js/src/preload.mjs

@@ -11,7 +11,15 @@ const cwd = process.cwd();
 // be working fine as well.
 const firstGraphFile =
   Object.values(graphs)
-    .flatMap((i) => i.split(":").at(0))
+    .map((i) => {
+      if (typeof i === "string") {
+        return i.split(":").at(0);
+      } else if (i && typeof i === "object" && i.path) {
+        return i.path.split(":").at(0);
+      }
+      return null;
+    })
+    .filter(Boolean)
     .at(0) || "index.mts";
 
 // enforce API @langchain/langgraph resolution

langgraph_api/js/src/utils/files.mts

@@ -1,4 +1,7 @@
-export function filterValidExportPath(path: string | undefined) {
+export function filterValidExportPath(
+  path: string | { path: string } | undefined,
+) {
   if (!path) return false;
-  return !path.split(":")[0].endsWith(".py");
+  const p = typeof path === "string" ? path : path.path;
+  return !p.split(":")[0].endsWith(".py");
 }

langgraph_api/js/sse.py

@@ -91,7 +91,7 @@ class SSEDecoder:
 
             sse = StreamPart(
                 event=self._event,
-                data=orjson.loads(self._data) if self._data else None,
+                data=orjson.loads(self._data) if self._data else None,  # type: ignore[invalid-argument-type]
             )
 
             # NOTE: as per the SSE spec, do not reset last_event_id.

langgraph_api/logging.py

@@ -19,8 +19,8 @@ LOG_LEVEL = log_env("LOG_LEVEL", cast=str, default="INFO")
 logging.getLogger().setLevel(LOG_LEVEL.upper())
 logging.getLogger("psycopg").setLevel(logging.WARNING)
 
-worker_config: contextvars.ContextVar[dict[str, typing.Any] | None] = (
-    contextvars.ContextVar("worker_config", default=None)
+worker_config = contextvars.ContextVar[dict[str, typing.Any] | None](
+    "worker_config", default=None
 )
 
 # custom processors
@@ -165,6 +165,6 @@ if not structlog.is_configured():
             structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
         ],
         logger_factory=structlog.stdlib.LoggerFactory(),
-        wrapper_class=structlog.stdlib.BoundLogger,
+        wrapper_class=structlog.stdlib.BoundLogger,  # type: ignore[invalid-argument-type]
         cache_logger_on_first_use=True,
     )

langgraph_api/middleware/http_logger.py

@@ -84,6 +84,7 @@ class AccessLoggerMiddleware:
 
             if method and route and status:
                 HTTP_METRICS_COLLECTOR.record_request(method, route, status, latency)
+            qs = scope.get("query_string")
             self.logger.log(
                 _get_level(status),
                 f"{method} {path} {status} {latency}ms",
@@ -93,7 +94,7 @@ class AccessLoggerMiddleware:
                 latency_ms=latency,
                 route=route,
                 path_params=scope.get("path_params"),
-                query_string=scope.get("query_string").decode(),
+                query_string=qs.decode() if qs else "",
                 proto=scope.get("http_version"),
                 req_header=_headers_to_dict(scope.get("headers")),
                 res_header=_headers_to_dict(info["response"].get("headers")),

langgraph_api/models/run.py

@@ -3,11 +3,11 @@ import time
 import urllib.parse
 import uuid
 from collections.abc import Mapping, Sequence
-from typing import Any, NamedTuple
+from typing import Any, NamedTuple, cast
 from uuid import UUID
 
 import orjson
-from langgraph.checkpoint.base.id import uuid6
+import structlog
 from starlette.authentication import BaseUser
 from starlette.exceptions import HTTPException
 from typing_extensions import TypedDict
@@ -27,7 +27,10 @@ from langgraph_api.schema import (
 )
 from langgraph_api.utils import AsyncConnectionProto, get_auth_ctx
 from langgraph_api.utils.headers import should_include_header
-from langgraph_runtime.ops import Runs, logger
+from langgraph_api.utils.uuids import uuid7
+from langgraph_runtime.ops import Runs
+
+logger = structlog.stdlib.get_logger(__name__)
 
 
 class LangSmithTracer(TypedDict, total=False):
@@ -183,7 +186,7 @@ LANGSMITH_PROJECT = "langsmith-project"
 DEFAULT_RUN_HEADERS_EXCLUDE = {"x-api-key", "x-tenant-id", "x-service-key"}
 
 
-def get_configurable_headers(headers: dict[str, str]) -> dict[str, str]:
+def get_configurable_headers(headers: Mapping[str, str]) -> dict[str, str]:
     """Extract headers that should be added to run configuration.
 
     This function handles special cases like langsmith-trace and baggage headers,
@@ -249,7 +252,7 @@ async def create_valid_run(
     request_id = headers.get("x-request-id")  # Will be null in the crons scheduler.
     (
         assistant_id,
-        thread_id,
+        thread_id_,
         checkpoint_id,
         run_id,
     ) = _get_ids(
@@ -258,7 +261,7 @@ async def create_valid_run(
         run_id=run_id,
     )
     if (
-        thread_id is None
+        thread_id_ is None
         and (command := payload.get("command"))
         and command.get("resume")
     ):
@@ -266,7 +269,9 @@ async def create_valid_run(
             status_code=400,
             detail="You must provide a thread_id when resuming.",
         )
-    temporary = thread_id is None and payload.get("on_completion", "delete") == "delete"
+    temporary = (
+        thread_id_ is None and payload.get("on_completion", "delete") == "delete"
+    )
     stream_resumable = payload.get("stream_resumable", False)
     stream_mode, multitask_strategy, prevent_insert_if_inflight = assign_defaults(
         payload
@@ -296,7 +301,7 @@ async def create_valid_run(
     configurable.update(get_configurable_headers(headers))
     ctx = get_auth_ctx()
     if ctx:
-        user = ctx.user
+        user = cast(BaseUser | None, ctx.user)
         user_id = get_user_id(user)
         configurable["langgraph_auth_user"] = user
         configurable["langgraph_auth_user_id"] = user_id
@@ -336,7 +341,7 @@ async def create_valid_run(
         metadata=payload.get("metadata"),
         status="pending",
         user_id=user_id,
-        thread_id=thread_id,
+        thread_id=thread_id_,
         run_id=run_id,
         multitask_strategy=multitask_strategy,
         prevent_insert_if_inflight=prevent_insert_if_inflight,
@@ -362,7 +367,7 @@ async def create_valid_run(
         logger.info(
             "Created run",
             run_id=str(run_id),
-            thread_id=str(thread_id),
+            thread_id=str(thread_id_),
             assistant_id=str(assistant_id),
             multitask_strategy=multitask_strategy,
             stream_mode=stream_mode,
@@ -383,7 +388,7 @@ async def create_valid_run(
                 await Runs.cancel(
                     conn,
                     [run["run_id"] for run in inflight_runs],
-                    thread_id=thread_id,
+                    thread_id=thread_id_,
                     action=multitask_strategy,
                 )
             except HTTPException:
@@ -415,15 +420,15 @@ def _get_ids(
     assistant_id = get_assistant_id(payload["assistant_id"])
 
     # ensure UUID validity defaults
-    assistant_id, thread_id, checkpoint_id = ensure_ids(
+    assistant_id, thread_id_, checkpoint_id = ensure_ids(
         assistant_id, thread_id, payload
     )
 
-    run_id = run_id or uuid6()
+    run_id = run_id or uuid7()
 
     return _Ids(
         assistant_id,
-        thread_id,
+        thread_id_,
         checkpoint_id,
         run_id,
     )

langgraph_api/patch.py

@@ -41,8 +41,8 @@ async def StreamingResponse_stream_response(self, send: Send) -> None:
 
 # patch StreamingResponse.stream_response
 
-StreamingResponse.stream_response = StreamingResponse_stream_response
+StreamingResponse.stream_response = StreamingResponse_stream_response  # type: ignore[invalid-assignment]
 
 # patch Response.render
 
-Response.render = Response_render
+Response.render = Response_render  # type: ignore[invalid-assignment]

langgraph_api/queue_entrypoint.py

@@ -18,9 +18,9 @@ import os
 import pathlib
 import signal
 from contextlib import asynccontextmanager
+from typing import cast
 
 import structlog
-import uvloop
 
 from langgraph_runtime.lifespan import lifespan
 from langgraph_runtime.metrics import get_metrics
@@ -36,21 +36,22 @@ async def health_and_metrics_server():
     class HealthAndMetricsHandler(http.server.SimpleHTTPRequestHandler):
         def log_message(self, format, *args):
             # Skip logging for /ok and /metrics endpoints
-            if self.path in ["/ok", "/metrics"]:
+            if getattr(self, "path", None) in ["/ok", "/metrics"]:
                 return
             # Log other requests normally
             super().log_message(format, *args)
 
         def do_GET(self):
-            if self.path == "/ok":
+            path = getattr(self, "path", None)
+            if path == "/ok":
                 self.send_response(200)
                 self.send_header("Content-Type", "application/json")
                 self.send_header("Content-Length", ok_len)
                 self.end_headers()
                 self.wfile.write(ok)
-            elif self.path == "/metrics":
+            elif path == "/metrics":
                 metrics = get_metrics()
-                worker_metrics = metrics["workers"]
+                worker_metrics = cast(dict[str, int], metrics["workers"])
                 workers_max = worker_metrics["max"]
                 workers_active = worker_metrics["active"]
                 workers_available = worker_metrics["available"]
@@ -93,20 +94,27 @@ async def health_and_metrics_server():
             httpd.shutdown()
 
 
-async def entrypoint():
+async def entrypoint(
+    grpc_port: int | None = None, entrypoint_name: str = "python-queue"
+):
     from langgraph_api import logging as lg_logging
     from langgraph_api.api import user_router
 
-    lg_logging.set_logging_context({"entrypoint": "python-queue"})
+    lg_logging.set_logging_context({"entrypoint": entrypoint_name})
     tasks: set[asyncio.Task] = set()
     tasks.add(asyncio.create_task(health_and_metrics_server()))
 
     original_lifespan = user_router.router.lifespan_context if user_router else None
 
     @asynccontextmanager
-    async def combined_lifespan(app, with_cron_scheduler=False, taskset=None):
+    async def combined_lifespan(
+        app, with_cron_scheduler=False, grpc_port=None, taskset=None
+    ):
         async with lifespan(
-            app, with_cron_scheduler=with_cron_scheduler, taskset=taskset
+            app,
+            with_cron_scheduler=with_cron_scheduler,
+            grpc_port=grpc_port,
+            taskset=taskset,
         ):
             if original_lifespan:
                 async with original_lifespan(app):
@@ -114,11 +122,13 @@ async def entrypoint():
             else:
                 yield
 
-    async with combined_lifespan(None, with_cron_scheduler=False, taskset=tasks):
+    async with combined_lifespan(
+        None, with_cron_scheduler=False, grpc_port=grpc_port, taskset=tasks
+    ):
         await asyncio.gather(*tasks)
 
 
-async def main():
+async def main(grpc_port: int | None = None, entrypoint_name: str = "python-queue"):
     """Run the queue entrypoint and shut down gracefully on SIGTERM/SIGINT."""
     loop = asyncio.get_running_loop()
     stop_event = asyncio.Event()
@@ -132,11 +142,9 @@ async def main():
     except (NotImplementedError, RuntimeError):
         signal.signal(signal.SIGTERM, lambda *_: _handle_signal())
 
-    from langgraph_api import config
-
-    config.IS_QUEUE_ENTRYPOINT = True
-
-    entry_task = asyncio.create_task(entrypoint())
+    entry_task = asyncio.create_task(
+        entrypoint(grpc_port=grpc_port, entrypoint_name=entrypoint_name)
+    )
     await stop_event.wait()
 
     logger.warning("Cancelling queue entrypoint task")
@@ -146,10 +154,17 @@ async def main():
 
 
 if __name__ == "__main__":
+    from langgraph_api import config
+
+    config.IS_QUEUE_ENTRYPOINT = True
     with open(pathlib.Path(__file__).parent.parent / "logging.json") as file:
         loaded_config = json.load(file)
         logging.config.dictConfig(loaded_config)
+    try:
+        import uvloop  # type: ignore[unresolved-import]
 
-    uvloop.install()
-
+        uvloop.install()
+    except ImportError:
+        pass
+    # run the entrypoint
     asyncio.run(main())

langgraph_api/schema.py

@@ -3,6 +3,7 @@ from datetime import datetime
 from typing import Any, Literal, Optional, TypeAlias
 from uuid import UUID
 
+from langchain_core.runnables.config import RunnableConfig
 from typing_extensions import TypedDict
 
 from langgraph_api.serde import Fragment
@@ -157,6 +158,22 @@ class ThreadState(TypedDict):
     """The interrupts for this state."""
 
 
+class RunKwargs(TypedDict):
+    config: RunnableConfig
+    context: dict[str, Any]
+    input: dict[str, Any] | None
+    command: dict[str, Any] | None
+    stream_mode: StreamMode
+    interrupt_before: Sequence[str] | str | None
+    interrupt_after: Sequence[str] | str | None
+    webhook: str | None
+    feedback_keys: Sequence[str] | None
+    temporary: bool
+    subgraphs: bool
+    resumable: bool
+    checkpoint_during: bool
+
+
 class Run(TypedDict):
     run_id: UUID
     """The ID of the run."""
@@ -172,7 +189,7 @@ class Run(TypedDict):
     """The status of the run. One of 'pending', 'error', 'success'."""
     metadata: Fragment
     """The run metadata."""
-    kwargs: Fragment
+    kwargs: RunKwargs
     """The run kwargs."""
     multitask_strategy: MultitaskStrategy
     """Strategy to handle concurrent runs on the same thread."""
@@ -214,6 +231,8 @@ class Cron(TypedDict):
     """The next run date of the cron."""
     metadata: Fragment
     """The cron metadata."""
+    now: datetime
+    """The current time."""
 
 
 class ThreadUpdateResponse(TypedDict):

langgraph_api/serde.py

@@ -1,4 +1,5 @@
 import asyncio
+import base64
 import re
 import uuid
 from base64 import b64encode
@@ -16,7 +17,7 @@ from ipaddress import (
 )
 from pathlib import Path
 from re import Pattern
-from typing import Any, NamedTuple
+from typing import Any, NamedTuple, cast
 from zoneinfo import ZoneInfo
 
 import cloudpickle
@@ -46,10 +47,14 @@ def decimal_encoder(dec_value: Decimal) -> int | float:
     >>> decimal_encoder(Decimal("1"))
     1
     """
-    if dec_value.as_tuple().exponent >= 0:
-        return int(dec_value)
-    else:
+    if (
+        # maps to float('nan') / float('inf') / float('-inf')
+        not dec_value.is_finite()
+        # or regular float
+        or cast(int, dec_value.as_tuple().exponent) < 0
+    ):
         return float(dec_value)
+    return int(dec_value)
 
 
 def default(obj):
@@ -142,7 +147,7 @@ def json_loads(content: bytes | Fragment | dict) -> Any:
         content = content.buf
     if isinstance(content, dict):
         return content
-    return orjson.loads(content)
+    return orjson.loads(cast(bytes, content))
 
 
 async def ajson_loads(content: bytes | Fragment) -> Any:
@@ -170,3 +175,25 @@ class Serializer(JsonPlusSerializer):
                 )
                 return None
         return super().loads_typed(data)
+
+
+mpack_keys = {"method", "value"}
+SERIALIZER = Serializer()
+
+
+# TODO: Make more performant (by removing)
+async def reserialize_message(message: bytes) -> bytes:
+    # Stream messages from golang runtime are a byte dict of StreamChunks.
+    loaded = await ajson_loads(message)
+    converted = {}
+    for k, v in loaded.items():
+        if isinstance(v, dict) and v.keys() == mpack_keys:
+            if v["method"] == "missing":
+                converted[k] = v["value"]  # oops
+            else:
+                converted[k] = SERIALIZER.loads_typed(
+                    (v["method"], base64.b64decode(v["value"]))
+                )
+        else:
+            converted[k] = v
+    return json_dumpb(converted)

langgraph_api/server.py

@@ -122,17 +122,19 @@ if user_router:
     # Merge routes
     app = user_router
 
-    meta_route_paths = [route.path for route in meta_routes]
+    meta_route_paths = [
+        getattr(route, "path", None) for route in meta_routes if hasattr(route, "path")
+    ]
     custom_route_paths = [
         route.path
         for route in user_router.router.routes
-        if route.path not in meta_route_paths
+        if hasattr(route, "path") and route.path not in meta_route_paths
     ]
     logger.info(f"Custom route paths: {custom_route_paths}")
 
     update_openapi_spec(app)
     for route in routes:
-        if route.path in ("/docs", "/openapi.json"):
+        if getattr(route, "path", None) in ("/docs", "/openapi.json"):
             # Our handlers for these are inclusive of the custom routes and default API ones
             # Don't let these be shadowed
             app.router.routes.insert(0, route)

langgraph_api/state.py

@@ -60,11 +60,11 @@ def patch_interrupt(
         return {"id": id, **interrupt.raw}
 
     if USE_NEW_INTERRUPTS:
-        interrupt = Interrupt(**interrupt) if isinstance(interrupt, dict) else interrupt
+        interrupt = Interrupt(**interrupt) if isinstance(interrupt, dict) else interrupt  # type: ignore[missing-argument]
 
         return {
-            "id": interrupt.id,
-            "value": interrupt.value,
+            "id": interrupt.id,  # type: ignore[unresolved-attribute]
+            "value": interrupt.value,  # type: ignore[unresolved-attribute]
         }
     else:
         if isinstance(interrupt, dict):
@@ -72,16 +72,16 @@ def patch_interrupt(
             # id is the new field we use for identification, also not supported on init for old versions
             interrupt.pop("interrupt_id", None)
             interrupt.pop("id", None)
-            interrupt = Interrupt(**interrupt)
+            interrupt = Interrupt(**interrupt)  # type: ignore[missing-argument]
 
         return {
             "id": interrupt.interrupt_id
             if hasattr(interrupt, "interrupt_id")
             else None,
-            "value": interrupt.value,
-            "resumable": interrupt.resumable,
-            "ns": interrupt.ns,
-            "when": interrupt.when,
+            "value": interrupt.value,  # type: ignore[unresolved-attribute]
+            "resumable": interrupt.resumable,  # type: ignore[unresolved-attribute]
+            "ns": interrupt.ns,  # type: ignore[unresolved-attribute]
+            "when": interrupt.when,  # type: ignore[unresolved-attribute]
         }
 
 

langgraph_api/store.py

@@ -93,7 +93,7 @@ def _load_store(store_path: str) -> Any:
             raise ValueError(f"Could not find store file: {path_name}")
         module = importlib.util.module_from_spec(modspec)
         sys.modules[module_name] = module
-        modspec.loader.exec_module(module)
+        modspec.loader.exec_module(module)  # type: ignore[possibly-unbound-attribute]
 
     else:
         path_name, function = store_path.rsplit(".", 1)