langgraph-api 0.2.102__tar.gz → 0.2.108__tar.gz

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/Makefile

@@ -36,7 +36,7 @@ test-license-oss:
 	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_HTTP='$(HTTP_CONFIG)' LANGGRAPH_STORE='$(STORE_CONFIG)' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run pytest -v $(TEST)
 
 test-watch-oss:
-	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_HTTP='$(HTTP_CONFIG)' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run ptw . -- -x -vv --ff --capture=no $(TEST)
+	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_HTTP='$(HTTP_CONFIG)' REDIS_URI=_FAKE DATABASE_URI=:memory: MIGRATIONS_PATH=__inmem__ uv run --no-sync ptw . -- -x -vv --ff --capture=no $(TEST)
 
 test: test-license-oss
 test-watch: test-watch-oss
@@ -54,8 +54,7 @@ start:
 	LANGGRAPH_RUNTIME_EDITION=inmem \
 	LANGGRAPH_AES_KEY='$(LANGGRAPH_AES_KEY)' \
 	N_JOBS_PER_WORKER=2 \
-	LANGGRAPH_CONFIG='{"agent": {"configurable": {"model_name": "openai"}}}' \
-	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph"}' \
+	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "single_node": "./tests/graphs/single_node.py:graph", "benchmark": "./tests/graphs/benchmark.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph"}' \
 	LANGGRAPH_STORE='$(STORE_CONFIG)' \
 	LANGGRAPH_CONFIG='{"agent": {"configurable": {"model_name": "openai"}}}' \
 	LANGSMITH_LANGGRAPH_API_VARIANT=test \
@@ -78,7 +77,7 @@ start-auth-jwt:
 	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_HTTP='$(HTTP_CONFIG)' \
 	LANGGRAPH_AES_KEY='$(LANGGRAPH_AES_KEY)' \
 	N_JOBS_PER_WORKER=2 \
-	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph"}' \
+	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph"}' \
 	LANGGRAPH_STORE='$(STORE_CONFIG)' \
 	LANGGRAPH_AUTH='{"path": "tests/graphs/jwt_auth.py:auth"}' \
 	LANGSMITH_LANGGRAPH_API_VARIANT=test \
@@ -96,7 +95,7 @@ start-auth-jwt:
 start-auth-fastapi-jwt:
 	LANGGRAPH_RUNTIME_EDITION=inmem LANGGRAPH_HTTP='$(HTTP_CONFIG)' \
 	N_JOBS_PER_WORKER=2 \
-	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph"}' \
+	LANGSERVE_GRAPHS='{"agent": "./tests/graphs/agent.py:graph", "other": "./tests/graphs/other.py:make_graph", "weather": "./tests/graphs/weather.py:mk_weather_graph", "searchy": "./tests/graphs/searchy.py:graph", "agent_simple": "./tests/graphs/agent_simple.py:graph", "simple_runtime": "./tests/graphs/simple_runtime.py:graph"}' \
 	LANGGRAPH_STORE='$(STORE_CONFIG)' \
 	LANGGRAPH_AUTH='{"path": "./tests/graphs/fastapi_jwt_auth.py:auth"}' \
 	LANGSMITH_LANGGRAPH_API_VARIANT=test \

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.102
+Version: 0.2.108
 Author-email: Nuno Campos <nuno@langchain.dev>, Will Fu-Hinthorn <will@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -12,8 +12,8 @@ Requires-Dist: jsonschema-rs<0.30,>=0.20.0
 Requires-Dist: langchain-core>=0.3.64
 Requires-Dist: langgraph-checkpoint>=2.0.23
 Requires-Dist: langgraph-runtime-inmem<0.7,>=0.6.0
-Requires-Dist: langgraph-sdk>=0.1.74
-Requires-Dist: langgraph>=0.3.27
+Requires-Dist: langgraph-sdk>=0.2.0
+Requires-Dist: langgraph>=0.4.0
 Requires-Dist: langsmith>=0.3.45
 Requires-Dist: orjson>=3.9.7
 Requires-Dist: pyjwt>=2.9.0

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/constraints.txt

@@ -1,8 +1,8 @@
 # When editing this file, also update docs pages:
 # https://github.com/langchain-ai/langgraph/blob/main/docs/docs/cloud/deployment/setup.md
 # https://github.com/langchain-ai/langgraph/blob/main/docs/docs/cloud/deployment/setup_pyproject.md
-langgraph>=0.3.27
-langgraph-sdk>=0.1.74
+langgraph>=0.4.0
+langgraph-sdk>=0.2.0
 langgraph-checkpoint>=2.0.23
 langchain-core>=0.3.64
 langsmith>=0.3.45

langgraph_api-0.2.108/langgraph_api/__init__.py

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

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/api/assistants.py

@@ -12,6 +12,7 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute
 
 from langgraph_api import store as api_store
+from langgraph_api.feature_flags import USE_RUNTIME_CONTEXT_API
 from langgraph_api.graph import get_assistant_id, get_graph
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.route import ApiRequest, ApiResponse, ApiRoute
@@ -55,6 +56,9 @@ def _get_configurable_jsonschema(graph: Pregel) -> dict:
 
     Returns:
        The JSON schema for the configurable part of the graph.
+
+    Whenever we no longer support langgraph < 0.6, we can remove this method
+    in favor of graph.get_context_jsonschema().
     """
     # Otherwise, use the config_schema method.
     config_schema = graph.config_schema()
@@ -112,6 +116,7 @@ def _graph_schemas(graph: Pregel) -> dict:
             f"Failed to get state schema for graph {graph.name} with error: `{str(e)}`"
         )
         state_schema = None
+
     try:
         config_schema = _get_configurable_jsonschema(graph)
     except Exception as e:
@@ -119,18 +124,31 @@ def _graph_schemas(graph: Pregel) -> dict:
             f"Failed to get config schema for graph {graph.name} with error: `{str(e)}`"
         )
         config_schema = None
+
+    if USE_RUNTIME_CONTEXT_API:
+        try:
+            context_schema = graph.get_context_jsonschema()
+        except Exception as e:
+            logger.warning(
+                f"Failed to get context schema for graph {graph.name} with error: `{str(e)}`"
+            )
+            context_schema = graph.config_schema()
+    else:
+        context_schema = None
+
     return {
         "input_schema": input_schema,
         "output_schema": output_schema,
         "state_schema": state_schema,
         "config_schema": config_schema,
+        "context_schema": context_schema,
     }
 
 
 @retry_db
 async def create_assistant(request: ApiRequest) -> ApiResponse:
-    payload = await request.json(AssistantCreate)
     """Create an assistant."""
+    payload = await request.json(AssistantCreate)
     if assistant_id := payload.get("assistant_id"):
         validate_uuid(assistant_id, "Invalid assistant ID: must be a UUID")
     async with connect() as conn:
@@ -138,6 +156,7 @@ async def create_assistant(request: ApiRequest) -> ApiResponse:
             conn,
             assistant_id or str(uuid4()),
             config=payload.get("config") or {},
+            context=payload.get("context") or {},
             graph_id=payload["graph_id"],
             metadata=payload.get("metadata") or {},
             if_exists=payload.get("if_exists") or "raise",
@@ -309,39 +328,16 @@ async def get_assistant_schemas(
                         "output_schema": schemas.get("output"),
                         "state_schema": schemas.get("state"),
                         "config_schema": schemas.get("config"),
+                        "context_schema": schemas.get("context"),
                     }
                 )
 
-            try:
-                input_schema = graph.get_input_jsonschema()
-            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 as e:
-                logger.warning(
-                    f"Failed to get output schema for graph {graph.name} with error: `{str(e)}`"
-                )
-                output_schema = None
+            schemas = _graph_schemas(graph)
 
-            state_schema = _state_jsonschema(graph)
-            try:
-                config_schema = _get_configurable_jsonschema(graph)
-            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"],
-                    "input_schema": input_schema,
-                    "output_schema": output_schema,
-                    "state_schema": state_schema,
-                    "config_schema": config_schema,
+                    **schemas,
                 }
             )
 
@@ -359,6 +355,7 @@ async def patch_assistant(
             conn,
             assistant_id,
             config=payload.get("config"),
+            context=payload.get("context"),
             graph_id=payload.get("graph_id"),
             metadata=payload.get("metadata"),
             name=payload.get("name"),

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/cli.py

@@ -83,6 +83,12 @@ class SecurityConfig(TypedDict, total=False):
     paths: dict[str, dict[str, list]]
 
 
+class CacheConfig(TypedDict, total=False):
+    cache_keys: list[str]
+    ttl_seconds: int
+    max_size: int
+
+
 class AuthConfig(TypedDict, total=False):
     path: str
     """Path to the authentication function in a Python file."""
@@ -112,6 +118,7 @@ class AuthConfig(TypedDict, total=False):
             ]
         }
     """
+    cache: CacheConfig | None
 
 
 def _check_newer_version(pkg: str, timeout: float = 0.2) -> None:

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/feature_flags.py

@@ -4,4 +4,5 @@ from langgraph.version import __version__
 LANGGRAPH_PY_MINOR = tuple(map(int, __version__.split(".")[:2]))
 
 OMIT_PENDING_SENDS = LANGGRAPH_PY_MINOR >= (0, 5)
-USE_RUNTIME_API = LANGGRAPH_PY_MINOR >= (0, 6)
+USE_RUNTIME_CONTEXT_API = LANGGRAPH_PY_MINOR >= (0, 6)
+USE_NEW_INTERRUPTS = LANGGRAPH_PY_MINOR >= (0, 6)

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/graph.py

@@ -23,7 +23,7 @@ from starlette.exceptions import HTTPException
 
 from langgraph_api import asyncio as lg_asyncio
 from langgraph_api import config
-from langgraph_api.feature_flags import USE_RUNTIME_API
+from langgraph_api.feature_flags import USE_RUNTIME_CONTEXT_API
 from langgraph_api.js.base import BaseRemotePregel, is_js_path
 from langgraph_api.schema import Config
 from langgraph_api.utils.config import run_in_executor, var_child_runnable_config
@@ -78,6 +78,7 @@ async def register_graph(
                 graph_id=graph_id,
                 metadata={"created_by": "system"},
                 config=config or {},
+                context={},
                 if_exists="do_nothing",
                 name=assistant_name,
                 description=description,
@@ -131,16 +132,19 @@ async def get_graph(
         config = lg_config.ensure_config(config)
 
         if store is not None:
-            if USE_RUNTIME_API:
+            if USE_RUNTIME_CONTEXT_API:
                 from langgraph._internal._constants import CONFIG_KEY_RUNTIME
                 from langgraph.runtime import Runtime
 
-                if (
-                    (runtime := config["configurable"].get(CONFIG_KEY_RUNTIME))
-                    is not None
-                ) and runtime.store is None:
+                runtime = config["configurable"].get(CONFIG_KEY_RUNTIME)
+                if runtime is None:
+                    patched_runtime = Runtime(store=store)
+                elif runtime.store is None:
                     patched_runtime = cast(Runtime, runtime).override(store=store)
-                    config["configurable"][CONFIG_KEY_RUNTIME] = patched_runtime
+                else:
+                    patched_runtime = runtime
+
+                config["configurable"][CONFIG_KEY_RUNTIME] = patched_runtime
             else:
                 from langgraph.constants import CONFIG_KEY_STORE
 
@@ -412,6 +416,8 @@ def _handle_exception(task: asyncio.Task) -> None:
         task.result()
     except asyncio.CancelledError:
         pass
+    except Exception as e:
+        logger.exception("Task failed", exc_info=e)
     finally:
         # if the task died either with exception or not, we should exit
         sys.exit(1)

langgraph_api-0.2.108/langgraph_api/js/base.py

@@ -0,0 +1,62 @@
+import os
+from collections.abc import Sequence
+from dataclasses import dataclass
+from typing import Any, Literal
+
+from langchain_core.runnables import Runnable
+
+from langgraph_api.schema import Config
+
+_DC_KWARGS = {"kw_only": True, "slots": True, "frozen": True}
+
+JS_EXTENSIONS = (
+    ".ts",
+    ".mts",
+    ".cts",
+    ".js",
+    ".mjs",
+    ".cjs",
+)
+
+
+def is_js_path(path: str | None) -> bool:
+    if path is None:
+        return False
+    return os.path.splitext(path)[1] in JS_EXTENSIONS
+
+
+@dataclass(**_DC_KWARGS)
+class RemoteInterrupt:
+    raw: dict
+
+    @property
+    def id(self) -> str:
+        return self.raw["id"]
+
+    @property
+    def value(self) -> Any:
+        return self.raw["value"]
+
+    @property
+    def ns(self) -> Sequence[str] | None:
+        return self.raw.get("ns")
+
+    @property
+    def resumable(self) -> bool:
+        return self.raw.get("resumable", True)
+
+    @property
+    def when(self) -> Literal["during"]:
+        return self.raw.get("when", "during")
+
+
+class BaseRemotePregel(Runnable):
+    name: str = "LangGraph"
+
+    graph_id: str
+
+    # Config passed from get_graph()
+    config: Config
+
+    async def get_nodes_executed(self) -> int:
+        return 0

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/js/client.mts

@@ -57,6 +57,7 @@ import {
 } from "@langchain/langgraph-api/schema";
 import { filterValidExportPath } from "./src/utils/files.mts";
 import { patchFetch } from "./traceblock.mts";
+import { writeHeapSnapshot } from "node:v8";
 
 const injectConfigFormatter = format((info) => {
   const config = getConfig();
@@ -1058,7 +1059,6 @@ async function main() {
         const headers = new Headers(rawHeaders);
         headers.delete("x-langgraph-auth-url");
         headers.delete("x-langgraph-auth-method");
-
         const context = await authenticate(
           new Request(authUrl, { headers, method }),
         );
@@ -1094,6 +1094,21 @@ async function main() {
   }
 
   app.get("/ok", (c) => c.json({ ok: true }));
+  
+  app.get("/debug/heapdump", async (c) => {
+    try {
+      const target =
+        `/tmp/heapdump-${Date.now()}.heapsnapshot`;
+      await fs.mkdir(path.dirname(target), { recursive: true });
+      const written = writeHeapSnapshot(target);
+      return c.json({ ok: true, written });     // 200
+    } catch (error) {
+      if (error instanceof HTTPException) {
+        return c.json(serializeError(error), error.status);
+      }
+      return c.json(serializeError(error), 500);
+    }
+  });
 
   app.onError((err, c) => {
     logger.error(err);

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/js/remote.py

@@ -25,7 +25,7 @@ from langchain_core.runnables.schema import (
 )
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
-from langgraph.types import Command, Interrupt, PregelTask, Send, StateSnapshot
+from langgraph.types import Command, PregelTask, Send, StateSnapshot
 from langgraph_sdk import Auth
 from pydantic import BaseModel
 from starlette import types
@@ -42,8 +42,8 @@ from starlette.routing import Route
 
 from langgraph_api import store as api_store
 from langgraph_api.auth.custom import DotDict, ProxyUser
-from langgraph_api.config import LANGGRAPH_AUTH_TYPE
-from langgraph_api.js.base import BaseRemotePregel
+from langgraph_api.config import LANGGRAPH_AUTH, LANGGRAPH_AUTH_TYPE
+from langgraph_api.js.base import BaseRemotePregel, RemoteInterrupt
 from langgraph_api.js.errors import RemoteException
 from langgraph_api.js.sse import SSEDecoder, aiter_lines_raw
 from langgraph_api.route import ApiResponse
@@ -226,6 +226,10 @@ class RemotePregel(BaseRemotePregel):
                 if state and isinstance(state, dict) and "config" in state:
                     state = self._convert_state_snapshot(state)
 
+                interrupts: list[RemoteInterrupt] = []
+                if task_interrupts := task.get("interrupts"):
+                    interrupts = [RemoteInterrupt(raw=i) for i in task_interrupts]
+
                 result.append(
                     PregelTask(
                         task["id"],
@@ -233,19 +237,7 @@ class RemotePregel(BaseRemotePregel):
                         tuple(task["path"]) if task.get("path") else tuple(),
                         # TODO: figure out how to properly deserialise errors
                         task.get("error"),
-                        (
-                            tuple(
-                                Interrupt(
-                                    value=interrupt["value"],
-                                    when=interrupt["when"],
-                                    resumable=interrupt.get("resumable", True),
-                                    ns=interrupt.get("ns"),
-                                )
-                                for interrupt in task.get("interrupts")
-                            )
-                            if task.get("interrupts")
-                            else []
-                        ),
+                        tuple(interrupts),
                         state,
                     )
                 )
@@ -339,6 +331,9 @@ class RemotePregel(BaseRemotePregel):
     def config_schema(self) -> type[BaseModel]:
         raise NotImplementedError()
 
+    def get_context_jsonschema(self) -> dict:
+        raise NotImplementedError()
+
     async def invoke(self, input: Any, config: RunnableConfig | None = None):
         raise NotImplementedError()
 
@@ -374,7 +369,7 @@ async def run_js_process(paths_str: str, watch: bool = False):
                 client_file,
                 "--skip-schema-cache",
             )
-            if watch
+            if False
             else ("tsx", "--import", client_preload_file, client_file)
         )
         try:
@@ -388,6 +383,7 @@ async def run_js_process(paths_str: str, watch: bool = False):
                     **os.environ,
                 },
             )
+            logger.info("Started JS graphs process [%d]", process.pid)
             code = await process.wait()
             raise Exception(f"JS process exited with code {code}")
         except asyncio.CancelledError:
@@ -448,6 +444,7 @@ async def run_js_http_process(paths_str: str, http_config: dict, watch: bool = F
             raise
         except Exception:
             if attempt >= 3:
+                logger.exception("JS HTTP process failed")
                 raise
             else:
                 logger.warning(f"Retrying JS HTTP process {3 - attempt} more times...")
@@ -843,11 +840,26 @@ class CustomJsAuthBackend(AuthenticationBackend):
     ls_auth: AuthenticationBackend | None
 
     def __init__(self, disable_studio_auth: bool = False):
+        from langgraph_api.utils.cache import LRUCache
+
         self.ls_auth = None
         if not disable_studio_auth and LANGGRAPH_AUTH_TYPE == "langsmith":
             from langgraph_api.auth.langsmith.backend import LangsmithAuthBackend
 
             self.ls_auth = LangsmithAuthBackend()
+        self.ttl_cache: LRUCache | None = None
+        self.cache_keys: list[str] | None = None
+        if cache := LANGGRAPH_AUTH.get("cache"):
+            keys = cache.get("cache_keys", [])
+            if not isinstance(keys, list):
+                raise ValueError(
+                    f"LANGGRAPH_AUTH.cache.cache_keys must be a list. Got: {keys}"
+                )
+            self.cache_keys = keys
+            self.ttl_cache = LRUCache(
+                max_size=cache.get("max_size", 1000),
+                ttl=cache.get("ttl_seconds", 60),
+            )
 
     async def authenticate(
         self, conn: HTTPConnection
@@ -863,6 +875,16 @@ class CustomJsAuthBackend(AuthenticationBackend):
         headers.pop("content-length", None)
         headers["x-langgraph-auth-url"] = str(conn.url)
         headers["x-langgraph-auth-method"] = conn.scope.get("method")
+        cache_key = None
+        if self.cache_keys:
+            cache_key = tuple(
+                (k, headers.get(k)) for k in self.cache_keys if headers.get(k)
+            )
+            if cache_key:
+                if self.ttl_cache is not None:
+                    cached = self.ttl_cache.get(cache_key)
+                    if cached:
+                        return cached
 
         res = await _client.post("/auth/authenticate", headers=headers)
         data = res.json()
@@ -873,8 +895,11 @@ class CustomJsAuthBackend(AuthenticationBackend):
             message = data.get("message") or "Unauthorized"
 
             raise HTTPException(status_code=status, detail=message, headers=headers)
+        result = AuthCredentials(data["scopes"]), ProxyUser(DotDict(data["user"]))
+        if cache_key:
+            self.ttl_cache.set(cache_key, result)
 
-        return AuthCredentials(data["scopes"]), ProxyUser(DotDict(data["user"]))
+        return result
 
 
 async def handle_js_auth_event(

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/metadata.py

@@ -66,9 +66,10 @@ if LANGSMITH_AUTH_ENDPOINT:
         LANGCHAIN_METADATA_ENDPOINT = (
             LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/metadata/submit"
         )
-    LANGCHAIN_METADATA_ENDPOINT = (
-        LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
-    )
+    else:
+        LANGCHAIN_METADATA_ENDPOINT = (
+            LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
+        )
 
 
 def incr_runs(*, incr: int = 1) -> None:

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/middleware/http_logger.py

@@ -12,6 +12,14 @@ asgi = structlog.stdlib.get_logger("asgi")
 PATHS_IGNORE = {"/ok", "/metrics"}
 
 
+def _get_level(status: int | None) -> int:
+    if status is None or status < 400:
+        return logging.INFO
+    if status < 500:
+        return logging.WARNING
+    return logging.ERROR
+
+
 class AccessLoggerMiddleware:
     def __init__(
         self,
@@ -46,6 +54,7 @@ class AccessLoggerMiddleware:
                     info["response"] = message
                 await send(message)
                 asgi.debug(f"ASGI send {message['type']}", **message)
+
         else:
             inner_receive = receive
 
@@ -74,8 +83,8 @@ class AccessLoggerMiddleware:
 
             if method and route and status:
                 HTTP_METRICS_COLLECTOR.record_request(method, route, status, latency)
-
-            self.logger.info(
+            self.logger.log(
+                _get_level(status),
                 f"{method} {path} {status} {latency}ms",
                 method=method,
                 path=path,

{langgraph_api-0.2.102 → langgraph_api-0.2.108}/langgraph_api/models/run.py

@@ -18,6 +18,7 @@ from langgraph_api.graph import GRAPHS, get_assistant_id
 from langgraph_api.schema import (
     All,
     Config,
+    Context,
     IfNotExists,
     MetadataInput,
     MultitaskStrategy,
@@ -52,6 +53,8 @@ class RunCreateDict(TypedDict):
     """Metadata for the run."""
     config: Config | None
     """Additional configuration for the run."""
+    context: Context | None
+    """Static context for the run."""
     webhook: str | None
     """Webhook to call when the run is complete."""
 
@@ -283,11 +286,13 @@ async def create_valid_run(
             detail="You must provide a thread_id when resuming.",
         )
     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
     )
     # assign custom headers and checkpoint to config
     config = payload.get("config") or {}
+    context = payload.get("context") or {}
     configurable = config.setdefault("configurable", {})
     if checkpoint_id:
         configurable["checkpoint_id"] = str(checkpoint_id)
@@ -321,6 +326,7 @@ async def create_valid_run(
             "input": payload.get("input"),
             "command": payload.get("command"),
             "config": config,
+            "context": context,
             "stream_mode": stream_mode,
             "interrupt_before": payload.get("interrupt_before"),
             "interrupt_after": payload.get("interrupt_after"),
@@ -328,7 +334,7 @@ async def create_valid_run(
             "feedback_keys": payload.get("feedback_keys"),
             "temporary": temporary,
             "subgraphs": payload.get("stream_subgraphs", False),
-            "resumable": payload.get("stream_resumable", False),
+            "resumable": stream_resumable,
             "checkpoint_during": payload.get("checkpoint_during", True),
         },
         metadata=payload.get("metadata"),
@@ -367,6 +373,7 @@ async def create_valid_run(
             temporary=temporary,
             after_seconds=after_seconds,
             if_not_exists=if_not_exists,
+            stream_resumable=stream_resumable,
             run_create_ms=(
                 int(time.time() * 1_000) - request_start_time
                 if request_start_time