langgraph-api 0.2.100__py3-none-any.whl → 0.2.108__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.2.100"
+__version__ = "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/api/runs.py

@@ -172,6 +172,17 @@ async def wait_run(request: ApiRequest):
     """Create a run, wait for the output."""
     thread_id = request.path_params["thread_id"]
     payload = await request.json(RunCreateStateful)
+
+    # Ensure stream_mode always includes "values" and "updates" while respecting other modes
+    user_stream_mode = payload.get("stream_mode", ["values"])
+    if isinstance(user_stream_mode, str):
+        user_stream_mode = [user_stream_mode]
+
+    # Always include "values" and "updates" if not already present
+    required_modes = {"values", "updates"}
+    final_stream_mode = list(set(user_stream_mode) | required_modes)
+    payload["stream_mode"] = final_stream_mode
+
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid6()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
@@ -207,6 +218,9 @@ async def wait_run(request: ApiRequest):
             async for mode, chunk, _ in stream:
                 if mode == b"values":
                     vchunk = chunk
+                elif mode == b"updates" and b"__interrupt__" in chunk:
+                    # Include the interrupt message in the values
+                    vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
         if vchunk is not None:
@@ -252,6 +266,17 @@ async def wait_run(request: ApiRequest):
 async def wait_run_stateless(request: ApiRequest):
     """Create a stateless run, wait for the output."""
     payload = await request.json(RunCreateStateless)
+
+    # Ensure stream_mode always includes "values" and "updates" while respecting other modes
+    user_stream_mode = payload.get("stream_mode", ["values"])
+    if isinstance(user_stream_mode, str):
+        user_stream_mode = [user_stream_mode]
+
+    # Always include "values" and "updates" if not already present
+    required_modes = {"values", "updates"}
+    final_stream_mode = list(set(user_stream_mode) | required_modes)
+    payload["stream_mode"] = final_stream_mode
+
     on_disconnect = payload.get("on_disconnect", "continue")
     run_id = uuid6()
     sub = asyncio.create_task(Runs.Stream.subscribe(run_id))
@@ -288,6 +313,9 @@ async def wait_run_stateless(request: ApiRequest):
             async for mode, chunk, _ in stream:
                 if mode == b"values":
                     vchunk = chunk
+                elif mode == b"updates" and b"__interrupt__" in chunk:
+                    # Include the interrupt message in the values
+                    vchunk = chunk
                 elif mode == b"error":
                     vchunk = orjson.dumps({"__error__": orjson.Fragment(chunk)})
         if vchunk is not None:

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/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/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/js/base.py

@@ -1,9 +1,14 @@
 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",
@@ -20,6 +25,31 @@ def is_js_path(path: str | None) -> bool:
     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"
 

langgraph_api/js/client.mts

@@ -9,6 +9,7 @@ import { HTTPException } from "hono/http-exception";
 import { fetch } from "undici";
 import pRetry from "p-retry";
 import {
+  getConfig,
   BaseStore,
   Item,
   Operation,
@@ -25,7 +26,6 @@ import {
   type ChannelVersions,
   type ChannelProtocol,
 } from "@langchain/langgraph-checkpoint";
-import { createHash } from "node:crypto";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { serialiseAsDict, serializeError } from "./src/utils/serde.mjs";
@@ -57,10 +57,22 @@ 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();
+  if (config == null) return info;
+
+  const node = config.metadata?.["langgraph_node"];
+  if (node != null) info.langgraph_node = node;
+
+  return info;
+});
 
 const logger = createLogger({
   level: "debug",
   format: format.combine(
+    injectConfigFormatter(),
     format.errors({ stack: true }),
     format.timestamp(),
     format.json(),
@@ -90,6 +102,12 @@ const logger = createLogger({
   ],
 });
 
+const GLOBAL_LOGGER = Symbol.for("langgraph.api.sdk-logger");
+type GLOBAL_LOGGER = typeof GLOBAL_LOGGER;
+
+const maybeGlobal = globalThis as unknown as { [GLOBAL_LOGGER]: typeof logger };
+maybeGlobal[GLOBAL_LOGGER] = logger;
+
 let GRAPH_SCHEMA: Record<string, Record<string, GraphSchema> | false> = {};
 let GRAPH_OPTIONS: {
   checkpointer?: BaseCheckpointSaver<string | number>;
@@ -1041,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 }),
         );
@@ -1077,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/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/metadata.py

@@ -61,9 +61,15 @@ BEACON_ENDPOINT = "https://api.smith.langchain.com/v1/metadata/submit"
 # LangChain auth endpoint for API key submissions
 LANGCHAIN_METADATA_ENDPOINT = None
 if LANGSMITH_AUTH_ENDPOINT:
-    LANGCHAIN_METADATA_ENDPOINT = (
-        LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
-    )
+    if "/api/v1" in LANGSMITH_AUTH_ENDPOINT:
+        # If the endpoint already has /api/v1 (for self-hosted control plane deployments), we assume it's the correct format
+        LANGCHAIN_METADATA_ENDPOINT = (
+            LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/metadata/submit"
+        )
+    else:
+        LANGCHAIN_METADATA_ENDPOINT = (
+            LANGSMITH_AUTH_ENDPOINT.rstrip("/") + "/v1/metadata/submit"
+        )
 
 
 def incr_runs(*, incr: int = 1) -> None:

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/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

langgraph_api/schema.py

@@ -1,6 +1,6 @@
 from collections.abc import Sequence
 from datetime import datetime
-from typing import Any, Literal, Optional
+from typing import Any, Literal, Optional, TypeAlias
 from uuid import UUID
 
 from typing_extensions import TypedDict
@@ -26,6 +26,8 @@ IfNotExists = Literal["create", "reject"]
 
 All = Literal["*"]
 
+Context: TypeAlias = dict[str, Any]
+
 
 class Config(TypedDict, total=False):
     tags: list[str]
@@ -55,17 +57,6 @@ class Checkpoint(TypedDict):
     checkpoint_map: dict[str, Any] | None
 
 
-class GraphSchema(TypedDict):
-    """Graph model."""
-
-    graph_id: str
-    """The ID of the graph."""
-    state_schema: dict
-    """The schema for the graph state."""
-    config_schema: dict
-    """The schema for the graph config."""
-
-
 class Assistant(TypedDict):
     """Assistant model."""
 
@@ -79,6 +70,8 @@ class Assistant(TypedDict):
     """The description of the assistant."""
     config: Config
     """The assistant config."""
+    context: Fragment
+    """The static context of the assistant."""
     created_at: datetime
     """The time the assistant was created."""
     updated_at: datetime
@@ -89,6 +82,31 @@ class Assistant(TypedDict):
     """The assistant version."""
 
 
+class Interrupt(TypedDict):
+    id: str | None
+    """The ID of the interrupt."""
+    value: Any
+    """The value of the interrupt."""
+
+
+class DeprecatedInterrupt(TypedDict, total=False):
+    """We document this old interrupt format internally, but not in API spec.
+
+    Should be dropped with lg-api v1.0.0.
+    """
+
+    id: str | None
+    """The ID of the interrupt."""
+    value: Any
+    """The value of the interrupt."""
+    resumable: bool
+    """Whether the interrupt is resumable."""
+    ns: Sequence[str] | None
+    """The optional namespace of the interrupt."""
+    when: Literal["during"]
+    """When the interrupt occurred, always "during"."""
+
+
 class Thread(TypedDict):
     thread_id: UUID
     """The ID of the thread."""
@@ -104,7 +122,7 @@ class Thread(TypedDict):
     """The status of the thread. One of 'idle', 'busy', 'interrupted', "error"."""
     values: Fragment
     """The current state of the thread."""
-    interrupts: Fragment
+    interrupts: dict[str, list[Interrupt]]
     """The current interrupts of the thread, a map of task_id to list of interrupts."""
 
 
@@ -112,7 +130,7 @@ class ThreadTask(TypedDict):
     id: str
     name: str
     error: str | None
-    interrupts: list[dict]
+    interrupts: list[Interrupt]
     checkpoint: Checkpoint | None
     state: Optional["ThreadState"]
 
@@ -133,6 +151,8 @@ class ThreadState(TypedDict):
     """The parent checkpoint. If missing, this is the root checkpoint."""
     tasks: Sequence[ThreadTask]
     """Tasks to execute in this step. If already attempted, may contain an error."""
+    interrupts: list[Interrupt]
+    """The interrupts for this state."""
 
 
 class Run(TypedDict):

langgraph_api/state.py

@@ -4,7 +4,10 @@ import typing
 
 from langgraph.types import Interrupt, StateSnapshot
 
-from langgraph_api.schema import Checkpoint, ThreadState
+from langgraph_api.feature_flags import USE_NEW_INTERRUPTS
+from langgraph_api.js.base import RemoteInterrupt
+from langgraph_api.schema import Checkpoint, DeprecatedInterrupt, ThreadState
+from langgraph_api.schema import Interrupt as InterruptSchema
 
 if typing.TYPE_CHECKING:
     from langchain_core.runnables.config import RunnableConfig
@@ -38,21 +41,48 @@ def runnable_config_to_checkpoint(
     return checkpoint
 
 
-def state_interrupt_to_thread_interrupt(interrupt: Interrupt | dict) -> dict:
-    # Sometimes the interrupt received in StateSnapshot is a dict.
-    # Let's convert it toan Interrupt object to gain access to dynamic `interrupt_id`.
-    if isinstance(interrupt, dict):
-        interrupt = Interrupt(**interrupt)
+def patch_interrupt(
+    interrupt: Interrupt | RemoteInterrupt | dict,
+) -> InterruptSchema | DeprecatedInterrupt:
+    """Convert a langgraph interrupt (v0 or v1) to standard interrupt schema.
 
-    return {
-        "interrupt_id": interrupt.interrupt_id
-        if hasattr(interrupt, "interrupt_id")
-        else None,
-        "value": interrupt.value,
-        "resumable": interrupt.resumable,
-        "ns": interrupt.ns,
-        "when": interrupt.when,
-    }
+    In v0.4 and v0.5, interrupt_id is a property on the langgraph.types.Interrupt object,
+    so we reconstruct the type in order to access the id, with compatibility for the new
+    v0.6 interrupt format as well.
+    """
+
+    # This is coming from JS, which already contains the interrupt ID.
+    # Stay on the safe side and pass-through the interrupt ID if it exists.
+    if isinstance(interrupt, RemoteInterrupt):
+        id = interrupt.raw.pop("interrupt_id", None) or interrupt.raw.pop("id", None)
+        if id is None:
+            return interrupt.raw
+        return {"id": id, **interrupt.raw}
+
+    if USE_NEW_INTERRUPTS:
+        interrupt = Interrupt(**interrupt) if isinstance(interrupt, dict) else interrupt
+
+        return {
+            "id": interrupt.id,
+            "value": interrupt.value,
+        }
+    else:
+        if isinstance(interrupt, dict):
+            # interrupt_id is a deprecated property on Interrupt and should not be used for initialization
+            # 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)
+
+        return {
+            "id": interrupt.interrupt_id
+            if hasattr(interrupt, "interrupt_id")
+            else None,
+            "value": interrupt.value,
+            "resumable": interrupt.resumable,
+            "ns": interrupt.ns,
+            "when": interrupt.when,
+        }
 
 
 def state_snapshot_to_thread_state(state: StateSnapshot) -> ThreadState:
@@ -65,9 +95,7 @@ def state_snapshot_to_thread_state(state: StateSnapshot) -> ThreadState:
                 "name": t.name,
                 "path": t.path,
                 "error": t.error,
-                "interrupts": [
-                    state_interrupt_to_thread_interrupt(i) for i in t.interrupts
-                ],
+                "interrupts": [patch_interrupt(i) for i in t.interrupts],
                 "checkpoint": t.state["configurable"]
                 if t.state is not None and not isinstance(t.state, StateSnapshot)
                 else None,
@@ -82,6 +110,7 @@ def state_snapshot_to_thread_state(state: StateSnapshot) -> ThreadState:
         "created_at": state.created_at,
         "checkpoint": runnable_config_to_checkpoint(state.config),
         "parent_checkpoint": runnable_config_to_checkpoint(state.parent_config),
+        "interrupts": [patch_interrupt(i) for i in getattr(state, "interrupts", [])],
         # below are deprecated
         "checkpoint_id": state.config["configurable"].get("checkpoint_id")
         if state.config

langgraph_api/stream.py

@@ -28,6 +28,7 @@ from langgraph_api import __version__
 from langgraph_api import store as api_store
 from langgraph_api.asyncio import ValueEvent, wait_if_not_done
 from langgraph_api.command import map_cmd
+from langgraph_api.feature_flags import USE_RUNTIME_CONTEXT_API
 from langgraph_api.graph import get_graph
 from langgraph_api.js.base import BaseRemotePregel
 from langgraph_api.metadata import HOST, PLAN, USER_API_URL, incr_nodes
@@ -95,6 +96,7 @@ async def astream_state(
     kwargs.pop("resumable", False)
     subgraphs = kwargs.get("subgraphs", False)
     temporary = kwargs.pop("temporary", False)
+    context = kwargs.pop("context", None)
     config = kwargs.pop("config")
     stack = AsyncExitStack()
     graph = await stack.enter_async_context(
@@ -234,6 +236,8 @@ async def astream_state(
                     yield "events", event
     else:
         output_keys = kwargs.pop("output_keys", graph.output_channels)
+        if USE_RUNTIME_CONTEXT_API:
+            kwargs["context"] = context
         async with (
             stack,
             aclosing(

{langgraph_api-0.2.100.dist-info → langgraph_api-0.2.108.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.2.100
+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.100.dist-info → langgraph_api-0.2.108.dist-info}/RECORD

@@ -1,27 +1,27 @@
-langgraph_api/__init__.py,sha256=FVK2BY4OOypnNECf-q4oePvVgv4gODqx5yLmPTR8KwA,24
+langgraph_api/__init__.py,sha256=wDb60-m4UuCYILmUqUWjUPEIIRh_kcoP0eCTtbgSAkQ,24
 langgraph_api/asgi_transport.py,sha256=eqifhHxNnxvI7jJqrY1_8RjL4Fp9NdN4prEub2FWBt8,5091
 langgraph_api/asyncio.py,sha256=Wv4Rwm-a-Cf6JpfgJmVuVlXQ7SlwrjbTn0eq1ux8I2Q,9652
-langgraph_api/cli.py,sha256=-R0fvxg4KNxTkSe7xvDZruF24UMhStJYjpAYlUx3PBk,16018
+langgraph_api/cli.py,sha256=xQojITwmmKSJw48Lr2regcnRPRq2FJqWlPpeyr5TgbU,16158
 langgraph_api/command.py,sha256=3O9v3i0OPa96ARyJ_oJbLXkfO8rPgDhLCswgO9koTFA,768
 langgraph_api/config.py,sha256=Nxhx6fOsxk_u-Aae54JAGn46JQ1wKXPjeu_KX_3d4wQ,11918
 langgraph_api/cron_scheduler.py,sha256=CiwZ-U4gDOdG9zl9dlr7mH50USUgNB2Fvb8YTKVRBN4,2625
 langgraph_api/errors.py,sha256=zlnl3xXIwVG0oGNKKpXf1an9Rn_SBDHSyhe53hU6aLw,1858
-langgraph_api/feature_flags.py,sha256=ZoId5X1FpWGvHcKAduqDMRNEKks5Bt8Eswww_xoch5M,305
-langgraph_api/graph.py,sha256=Q9tRf1WBaxFBOgs_orlMAlBVJM0-cpZVduknU_fbzRM,24235
+langgraph_api/feature_flags.py,sha256=GjwmNjfg0Jhs3OzR2VbK2WgrRy3o5l8ibIYiUtQkDPA,363
+langgraph_api/graph.py,sha256=Yq7Y1x_SFmzmWWY73YidrANPOIDqjZv0Gj4O3lR7H6I,24457
 langgraph_api/http.py,sha256=L0leP5fH4NIiFgJd1YPMnTRWqrUUYq_4m5j558UwM5E,5612
 langgraph_api/http_metrics.py,sha256=VgM45yU1FkXuI9CIOE_astxAAu2G-OJ42BRbkcos_CQ,5555
 langgraph_api/logging.py,sha256=4K1Fnq8rrGC9CqJubZtP34Y9P2zh7VXf_41q7bH3OXU,4849
-langgraph_api/metadata.py,sha256=lfovneEMLA5vTNa61weMkQkiZCtwo-qdwFwqNSj5qVs,6638
+langgraph_api/metadata.py,sha256=fVsbwxVitAj4LGVYpCcadYeIFANEaNtcx6LBxQLcTqg,6949
 langgraph_api/patch.py,sha256=Dgs0PXHytekX4SUL6KsjjN0hHcOtGLvv1GRGbh6PswU,1408
 langgraph_api/queue_entrypoint.py,sha256=hC8j-A4cUxibusiiPJBlK0mkmChNZxNcXn5GVwL0yic,4889
 langgraph_api/route.py,sha256=4VBkJMeusfiZtLzyUaKm1HwLHTq0g15y2CRiRhM6xyA,4773
-langgraph_api/schema.py,sha256=IdloGYognffSCZOFPujXE0QfNNlxQGd3BJbinYy5Q1c,5708
+langgraph_api/schema.py,sha256=WoA7uu1VA_ZRVSR4gpAnm1n7sKDfWUEojx7CFDiOH7Q,6341
 langgraph_api/serde.py,sha256=0ALETUn582vNF-m0l_WOZGF_scL1VPA39fDkwMJQPrg,5187
 langgraph_api/server.py,sha256=Z_VL-kIphybTRDWBIqHMfRhgCmAFyTRqAGlgnHQF0Zg,6973
 langgraph_api/sse.py,sha256=SLdtZmTdh5D8fbWrQjuY9HYLd2dg8Rmi6ZMmFMVc2iE,4204
-langgraph_api/state.py,sha256=Fn38_E8K0LmK6x6RsZCWr-cnu8RH-2qLBXqkA3TgfdY,3045
+langgraph_api/state.py,sha256=P2mCo-0bqPu2v9FSFGJtUCjPPNvv6wLUKQh8SdxAtc8,4387
 langgraph_api/store.py,sha256=srRI0fQXNFo_RSUs4apucr4BEp_KrIseJksZXs32MlQ,4635
-langgraph_api/stream.py,sha256=EorM9BD7oiCvkRXlMqnOkBd9P1X3mEagS_oHp-_9aRQ,13669
+langgraph_api/stream.py,sha256=f22caNhIPeF67wBD3xtoaodyimya0fiBlmVOAznEkOY,13851
 langgraph_api/thread_ttl.py,sha256=-Ox8NFHqUH3wGNdEKMIfAXUubY5WGifIgCaJ7npqLgw,1762
 langgraph_api/traceblock.py,sha256=2aWS6TKGTcQ0G1fOtnjVrzkpeGvDsR0spDbfddEqgRU,594
 langgraph_api/utils.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -29,11 +29,11 @@ langgraph_api/validation.py,sha256=zMuKmwUEBjBgFMwAaeLZmatwGVijKv2sOYtYg7gfRtc,4
 langgraph_api/webhook.py,sha256=VCJp4dI5E1oSJ15XP34cnPiOi8Ya8Q1BnBwVGadOpLI,1636
 langgraph_api/worker.py,sha256=LVvjvigurlDgpNjFcbAvRH7744fE01Lirrg2ZlHtORE,14245
 langgraph_api/api/__init__.py,sha256=WHy6oNLWtH1K7AxmmsU9RD-Vm6WP-Ov16xS8Ey9YCmQ,6090
-langgraph_api/api/assistants.py,sha256=w7nXjEknDVHSuP228S8ZLh4bG0nRGnSwVP9pECQOK90,16247
+langgraph_api/api/assistants.py,sha256=2ZIdtfiI1KJAHpDhu0a8kJtLebVBZwUZl8ky1k54-aA,15928
 langgraph_api/api/mcp.py,sha256=qe10ZRMN3f-Hli-9TI8nbQyWvMeBb72YB1PZVbyqBQw,14418
 langgraph_api/api/meta.py,sha256=fmc7btbtl5KVlU_vQ3Bj4J861IjlqmjBKNtnxSV-S-Q,4198
 langgraph_api/api/openapi.py,sha256=KToI2glOEsvrhDpwdScdBnL9xoLOqkTxx5zKq2pMuKQ,11957
-langgraph_api/api/runs.py,sha256=WlZ_gzS7S4YOBMzKOZSlJm-2Qullj61u47-3lFDK8U0,20291
+langgraph_api/api/runs.py,sha256=DxmGkRnZsQgr5bmflguDKXEvY3J9Q-bt7YwbuSFAMxU,21579
 langgraph_api/api/store.py,sha256=TSeMiuMfrifmEnEbL0aObC2DPeseLlmZvAMaMzPgG3Y,5535
 langgraph_api/api/threads.py,sha256=nQMlGnsrFD1F4S-ID_q0HZrF2GZ0Pm7aV04Sh1eYgds,9588
 langgraph_api/api/ui.py,sha256=17QrRy2XVzP7x_0RdRw7pmSv-n1lmnb54byHCGGeNhM,2490
@@ -48,14 +48,14 @@ langgraph_api/auth/langsmith/client.py,sha256=eKchvAom7hdkUXauD8vHNceBDDUijrFgdT
 langgraph_api/js/.gitignore,sha256=l5yI6G_V6F1600I1IjiUKn87f4uYIrBAYU1MOyBBhg4,59
 langgraph_api/js/.prettierrc,sha256=0es3ovvyNIqIw81rPQsdt1zCQcOdBqyR_DMbFE4Ifms,19
 langgraph_api/js/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/js/base.py,sha256=gjY6K8avI03OrI-Hy6a311fQ_EG5r_x8hUYlc7uqxdE,534
+langgraph_api/js/base.py,sha256=GORqRDbGAOQX2ygT6dMcqBDCA9tdAp8EpG4bfqUPMg4,1198
 langgraph_api/js/build.mts,sha256=bRQo11cglDFXlLN7Y48CQPTSMLenp7MqIWuP1DkSIo0,3139
 langgraph_api/js/client.http.mts,sha256=AGA-p8J85IcNh2oXZjDxHQ4PnQdJmt-LPcpZp6j0Cws,4687
-langgraph_api/js/client.mts,sha256=5PjWSfNHGRNbrlFH4zlFM0lfGlvK0hBARa6qcl3gC5o,30958
+langgraph_api/js/client.mts,sha256=wizpsqiM95KWnPw4ByT9_3nELrGHVvquQB2pABw597w,31957
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
 langgraph_api/js/global.d.ts,sha256=j4GhgtQSZ5_cHzjSPcHgMJ8tfBThxrH-pUOrrJGteOU,196
 langgraph_api/js/package.json,sha256=BpNAO88mbE-Gv4WzQfj1TLktCWGqm6XBqI892ObuOUw,1333
-langgraph_api/js/remote.py,sha256=B_0cP34AGTW9rL_hJyKIh3P6Z4TvNYNNyc7S2_SOWt4,36880
+langgraph_api/js/remote.py,sha256=hN-yVXln3qk0E3JXM6It89sIgRkbT_FpW0JDqQ2KN-g,37832
 langgraph_api/js/schema.py,sha256=M4fLtr50O1jck8H1hm_0W4cZOGYGdkrB7riLyCes4oY,438
 langgraph_api/js/sse.py,sha256=lsfp4nyJyA1COmlKG9e2gJnTttf_HGCB5wyH8OZBER8,4105
 langgraph_api/js/traceblock.mts,sha256=QtGSN5VpzmGqDfbArrGXkMiONY94pMQ5CgzetT_bKYg,761
@@ -70,11 +70,11 @@ langgraph_api/js/src/utils/importMap.mts,sha256=pX4TGOyUpuuWF82kXcxcv3-8mgusRezO
 langgraph_api/js/src/utils/pythonSchemas.mts,sha256=98IW7Z_VP7L_CHNRMb3_MsiV3BgLE2JsWQY_PQcRR3o,685
 langgraph_api/js/src/utils/serde.mts,sha256=D9o6MwTgwPezC_DEmsWS5NnLPnjPMVWIb1I1D4QPEPo,743
 langgraph_api/middleware/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/middleware/http_logger.py,sha256=uroMCag49-uPHTt8K3glkl-0RnWL20YEgm8WVkqpF4k,3477
+langgraph_api/middleware/http_logger.py,sha256=L7ZhypmQjlHBfm93GqZaqUXzu0r-ieaoO1lY7t1jGb0,3701
 langgraph_api/middleware/private_network.py,sha256=eYgdyU8AzU2XJu362i1L8aSFoQRiV7_aLBPw7_EgeqI,2111
 langgraph_api/middleware/request_id.py,sha256=SDj3Yi3WvTbFQ2ewrPQBjAV8sYReOJGeIiuoHeZpR9g,1242
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=ZedBLmzeXFHbpYvNWJ50xhKakDnQwgZmeZBjNlMJqWA,14614
+langgraph_api/models/run.py,sha256=M4NfATGKkXIuB5MLh0CUSp3bP6iG83ZZVvlqE2A_n1E,14855
 langgraph_api/tunneling/cloudflare.py,sha256=iKb6tj-VWPlDchHFjuQyep2Dpb-w2NGfJKt-WJG9LH0,3650
 langgraph_api/utils/__init__.py,sha256=92mSti9GfGdMRRWyESKQW5yV-75Z9icGHnIrBYvdypU,3619
 langgraph_api/utils/cache.py,sha256=SrtIWYibbrNeZzLXLUGBFhJPkMVNQnVxR5giiYGHEfI,1810
@@ -93,9 +93,9 @@ langgraph_runtime/retry.py,sha256=V0duD01fO7GUQ_btQkp1aoXcEOFhXooGVP6q4yMfuyY,11
 langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,114
 LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
 logging.json,sha256=3RNjSADZmDq38eHePMm1CbP6qZ71AmpBtLwCmKU9Zgo,379
-openapi.json,sha256=p5tn_cNRiFA0HN3L6JfC9Nm16Hgv-BxvAQcJymKhVWI,143296
-langgraph_api-0.2.100.dist-info/METADATA,sha256=92AMCejq8YhdWxgw2yVASFanhQPIt4EnUlETG1ou2GY,3892
-langgraph_api-0.2.100.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-langgraph_api-0.2.100.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.2.100.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
-langgraph_api-0.2.100.dist-info/RECORD,,
+openapi.json,sha256=jyQZW5U4V15zWciiIvaDPasYZd3k1iMiQ2vkPxf3zb4,145614
+langgraph_api-0.2.108.dist-info/METADATA,sha256=P6idskl_R8E9Oyv8ae9Ne9jQlZLNobIwbXmzN3ZxGoE,3890
+langgraph_api-0.2.108.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+langgraph_api-0.2.108.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.2.108.dist-info/licenses/LICENSE,sha256=ZPwVR73Biwm3sK6vR54djCrhaRiM4cAD2zvOQZV8Xis,3859
+langgraph_api-0.2.108.dist-info/RECORD,,

openapi.json

@@ -3035,6 +3035,11 @@
             "title": "Config",
             "description": "The assistant config."
           },
+          "context": {
+            "type": "object",
+            "title": "Context",
+            "description": "Static context added to the assistant."
+          },
           "created_at": {
             "type": "string",
             "format": "date-time",
@@ -3100,6 +3105,11 @@
             "title": "Config",
             "description": "Configuration to use for the graph. Useful when graph is configurable and you want to create different assistants based on different configurations."
           },
+          "context": {
+            "type": "object",
+            "title": "Context",
+            "description": "Static context added to the assistant."
+          },
           "metadata": {
             "type": "object",
             "title": "Metadata",
@@ -3148,6 +3158,11 @@
             "title": "Config",
             "description": "Configuration to use for the graph. Useful when graph is configurable and you want to update the assistant's configuration."
           },
+          "context": {
+            "type": "object",
+            "title": "Context",
+            "description": "Static context added to the assistant."
+          },
           "metadata": {
             "type": "object",
             "title": "Metadata",
@@ -3326,6 +3341,11 @@
             "title": "Config",
             "description": "The configuration for the assistant."
           },
+          "context": {
+            "type": "object",
+            "title": "Context",
+            "description": "Static context added to the assistant."
+          },
           "webhook": {
             "type": "string",
             "maxLength": 65536,
@@ -3466,13 +3486,17 @@
             "type": "object",
             "title": "Config Schema",
             "description": "The schema for the graph config. Missing if unable to generate JSON schema from graph."
+          },
+          "context_schema": {
+            "type": "object",
+            "title": "Context Schema",
+            "description": "The schema for the graph context. Missing if unable to generate JSON schema from graph."
           }
         },
         "type": "object",
         "required": [
           "graph_id",
-          "state_schema",
-          "config_schema"
+          "state_schema"
         ],
         "title": "GraphSchema",
         "description": "Defines the structure and properties of a graph."
@@ -3498,14 +3522,18 @@
             "type": "object",
             "title": "Config Schema",
             "description": "The schema for the graph config. Missing if unable to generate JSON schema from graph."
+          },
+          "context_schema": {
+            "type": "object",
+            "title": "Context Schema",
+            "description": "The schema for the graph context. Missing if unable to generate JSON schema from graph."
           }
         },
         "type": "object",
         "required": [
           "input_schema",
           "output_schema",
-          "state_schema",
-          "config_schema"
+          "state_schema"
         ],
         "title": "GraphSchemaNoId",
         "description": "Defines the structure and properties of a graph without an ID."
@@ -3516,7 +3544,7 @@
           "$ref": "#/components/schemas/GraphSchemaNoId"
         },
         "title": "Subgraphs",
-        "description": "Map of graph name to graph schema metadata (`input_schema`, `output_schema`, `state_schema`, `config_schema`)."
+        "description": "Map of graph name to graph schema metadata (`input_schema`, `output_schema`, `state_schema`, `config_schema`, `context_schema`)."
       },
       "Run": {
         "properties": {
@@ -3766,6 +3794,11 @@
             "title": "Config",
             "description": "The configuration for the assistant."
           },
+          "context": {
+            "type": "object",
+            "title": "Context",
+            "description": "Static context added to the assistant."
+          },
           "webhook": {
             "type": "string",
             "maxLength": 65536,
@@ -4005,6 +4038,11 @@
             "title": "Config",
             "description": "The configuration for the assistant."
           },
+          "context": {
+            "type": "object",
+            "title": "Context",
+            "description": "Static context added to the assistant."
+          },
           "webhook": {
             "type": "string",
             "maxLength": 65536,
@@ -4312,6 +4350,11 @@
             "title": "Metadata",
             "description": "The thread metadata."
           },
+          "config": {
+            "type": "object",
+            "title": "Config",
+            "description": "The thread config."
+          },
           "status": {
             "type": "string",
             "enum": [
@@ -4327,6 +4370,11 @@
             "type": "object",
             "title": "Values",
             "description": "The current state of the thread."
+          },
+          "interrupts": {
+            "type": "object",
+            "title": "Interrupts",
+            "description": "The current interrupts of the thread."
           }
         },
         "type": "object",
@@ -4476,7 +4524,9 @@
                 },
                 "interrupts": {
                   "type": "array",
-                  "items": {}
+                  "items": {
+                    "$ref": "#/components/schemas/Interrupt"
+                  }
                 },
                 "checkpoint": {
                   "$ref": "#/components/schemas/CheckpointConfig",
@@ -4509,6 +4559,12 @@
           "parent_checkpoint": {
             "type": "object",
             "title": "Parent Checkpoint"
+          },
+          "interrupts": {
+            "type": "array",
+            "items": {
+              "$ref": "#/components/schemas/Interrupt"
+            }
           }
         },
         "type": "object",
@@ -4954,6 +5010,24 @@
             }
           }
         }
+      },
+      "Interrupt": {
+        "type": "object",
+        "properties": {
+          "id": {
+            "type": [
+              "string",
+              "null"
+            ]
+          },
+          "value": {
+            "type": "object"
+          }
+        },
+        "title": "Interrupt",
+        "required": [
+          "value"
+        ]
       }
     }
   }