langgraph-api 0.15.0.dev5__py3-none-any.whl → 0.16.0.dev1__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.15.0.dev5"
+__version__ = "0.16.0.dev1"

langgraph_api/api/a2a.py

@@ -55,6 +55,8 @@ MAX_HISTORY_LENGTH_REQUESTED = 10
 LANGGRAPH_HISTORY_QUERY_LIMIT = 500
 HISTORY_SCOPE_EXTENSION_URI = "https://langchain.com/a2a/extensions/history-scope/v1"
 HISTORY_SCOPE_HEADER = "LangGraph-A2A-History-Scope"
+A2A_EXTENSIONS_HEADER = "A2A-Extensions"
+A2UI_EXTENSIONS_HEADER = "X-A2A-Extensions"
 HistoryScope = Literal["context", "task"]
 
 
@@ -123,6 +125,7 @@ class A2UIContext:
     metadata: dict[str, Any]
     extensions: list[str]
     drop_invalid: bool = False
+    mime_type: str = A2UI_MIME_TYPE
 
 
 _A2UI_DISABLED_CONTEXT = A2UIContext(False, False, {}, [])
@@ -170,6 +173,11 @@ def _a2ui_context_for_run(
         active=a2a_metadata.get("a2ui_active") is True,
         metadata={},
         extensions=[],
+        mime_type=(
+            a2a_metadata["a2ui_mime_type"]
+            if is_a2ui_mime_type(a2a_metadata.get("a2ui_mime_type"))
+            else A2UI_MIME_TYPE
+        ),
     )
 
 
@@ -197,26 +205,46 @@ def _a2a_run_metadata(
             **({"task_id": task_id} if task_id else {}),
             **({"task_start_id": task_start_id} if task_start_id else {}),
             **({"a2ui_active": context.active} if context.enabled else {}),
+            **(
+                {"a2ui_mime_type": context.mime_type}
+                if context.enabled and context.active
+                else {}
+            ),
         }
     }
 
 
 def _a2ui_message_context(
-    message: dict[str, Any], assistant: dict[str, Any]
+    params: dict[str, Any],
+    assistant: dict[str, Any],
+    headers: Headers,
+    *,
+    default_mime_type: str = A2UI_MIME_TYPE,
 ) -> A2UIContext:
+    message = params.get("message") or {}
     metadata = message.get("metadata") or {}
-    extensions = message.get("extensions") or []
-    if (
-        not isinstance(metadata, dict)
-        or not isinstance(extensions, list)
-        or not all(isinstance(extension, str) for extension in extensions)
-    ):
-        raise A2UIValidationError("Invalid A2A message metadata or extensions")
+    if not isinstance(metadata, dict):
+        raise A2UIValidationError("Invalid A2A message metadata")
+    extensions: list[str] = []
+    for header in (A2A_EXTENSIONS_HEADER, A2UI_EXTENSIONS_HEADER):
+        for header_value in headers.getlist(header):
+            for value in header_value.split(","):
+                if (extension := value.strip()) and extension not in extensions:
+                    extensions.append(extension)
+    mime_type = default_mime_type
+    for part in message.get("parts") or []:
+        part_metadata = part.get("metadata") if isinstance(part, dict) else None
+        if isinstance(part_metadata, dict) and is_a2ui_mime_type(
+            part_metadata.get("mimeType")
+        ):
+            mime_type = part_metadata["mimeType"]
+            break
     return A2UIContext(
         enabled=_a2ui_enabled(assistant),
         active=A2UI_EXTENSION_URI in extensions,
         metadata=metadata,
         extensions=extensions,
+        mime_type=mime_type,
     )
 
 
@@ -892,7 +920,9 @@ def _process_a2a_message_parts(
                     {
                         "type": "data",
                         "data": part_data,
-                        "metadata": normalize_metadata(part_metadata),
+                        "metadata": normalize_metadata(
+                            part_metadata, mime_type=a2ui.mime_type
+                        ),
                     }
                 )
                 continue
@@ -1114,7 +1144,7 @@ def _content_to_a2a_parts(
                 {
                     "kind": "data",
                     "data": data,
-                    "metadata": normalize_metadata(metadata),
+                    "metadata": normalize_metadata(metadata, mime_type=a2ui.mime_type),
                 }
             )
         elif (
@@ -2095,6 +2125,7 @@ async def handle_message_send(
             task_id = None
             task_start_id = str(uuid7())
             task_ids_by_start_id: dict[str, str] = {}
+            a2ui_mime_type = A2UI_MIME_TYPE
         else:
             task = await _resolve_task(
                 client,
@@ -2121,10 +2152,16 @@ async def handle_message_send(
             task_id = task.task_id
             task_start_id = None
             task_ids_by_start_id = task.task_ids_by_start_id
+            a2ui_mime_type = _a2ui_context_for_run(task.run).mime_type
 
         # Process A2A message parts into LangChain messages format
         try:
-            a2ui = _a2ui_message_context(message, assistant)
+            a2ui = _a2ui_message_context(
+                params,
+                assistant,
+                request.headers,
+                default_mime_type=a2ui_mime_type,
+            )
             message_role = _normalize_input_role(message.get("role", "ROLE_USER"))
             input_content = _process_a2a_message_parts(
                 parts,
@@ -3352,6 +3389,7 @@ async def handle_message_stream(
                 context_id = context_id_from_message or str(uuid.uuid4())
                 task_id = None
                 task_start_id = str(uuid7())
+                a2ui_mime_type = A2UI_MIME_TYPE
             else:
                 task = await _resolve_task(
                     client,
@@ -3389,10 +3427,16 @@ async def handle_message_stream(
                 context_id = task.context_id
                 task_id = task.task_id
                 task_start_id = None
+                a2ui_mime_type = _a2ui_context_for_run(task.run).mime_type
 
             # Process A2A message parts into LangChain messages format
             try:
-                a2ui = _a2ui_message_context(message, assistant)
+                a2ui = _a2ui_message_context(
+                    params,
+                    assistant,
+                    request.headers,
+                    default_mime_type=a2ui_mime_type,
+                )
                 message_role = _normalize_input_role(message.get("role", "ROLE_USER"))
                 input_content = _process_a2a_message_parts(
                     parts,

langgraph_api/api/a2ui.py

@@ -9,8 +9,8 @@ import jsonschema_rs
 import orjson
 
 A2UI_EXTENSION_URI = "https://a2ui.org/a2a-extension/a2ui/v0.9"
-A2UI_MIME_TYPE = "application/a2ui+json"
-_COMPAT_A2UI_MIME_TYPE = "application/json+a2ui"
+A2UI_MIME_TYPE = "application/json+a2ui"
+_COMPAT_A2UI_MIME_TYPE = "application/a2ui+json"
 _SCHEMA_DIR = Path(__file__).with_name("a2ui_schemas")
 
 
@@ -52,9 +52,11 @@ def is_a2ui_mime_type(value: Any) -> bool:
     return value in {A2UI_MIME_TYPE, _COMPAT_A2UI_MIME_TYPE}
 
 
-def normalize_metadata(metadata: dict[str, Any]) -> dict[str, Any]:
+def normalize_metadata(
+    metadata: dict[str, Any], *, mime_type: str = A2UI_MIME_TYPE
+) -> dict[str, Any]:
     if is_a2ui_mime_type(metadata.get("mimeType")):
-        return {**metadata, "mimeType": A2UI_MIME_TYPE}
+        return {**metadata, "mimeType": mime_type}
     return metadata
 
 
@@ -70,9 +72,17 @@ def validate_client_metadata(metadata: dict[str, Any]) -> None:
         raise A2UIValidationError("Invalid A2UI message metadata") from exc
 
 
-def validate_payload(data: Any, *, direction: Literal["client", "server"]) -> None:
-    if not isinstance(data, list):
-        raise A2UIValidationError("A2UI DataPart data must be an array")
+def validate_payload(
+    data: Any,
+    *,
+    direction: Literal["client", "server"],
+) -> None:
+    if isinstance(data, list):
+        messages = data
+    elif isinstance(data, dict):
+        messages = (data,)
+    else:
+        raise A2UIValidationError("A2UI DataPart data must be an array or object")
 
     validator = (
         _CLIENT_MESSAGE_VALIDATOR
@@ -80,7 +90,7 @@ def validate_payload(data: Any, *, direction: Literal["client", "server"]) -> No
         else _SERVER_MESSAGE_VALIDATOR
     )
     try:
-        for message in data:
+        for message in messages:
             validator.validate(message)
     except ValueError as exc:
         raise A2UIValidationError(f"Invalid A2UI {direction} message") from exc

langgraph_api/api/mcp/_handlers.py

@@ -287,7 +287,9 @@ async def handle_tools_list(
             schemas = await client.assistants.get_schemas(
                 assistant["assistant_id"], headers=request.headers
             )
-            input_schema = schemas.get("input_schema") or {}
+            input_schema = schemas.get("input_schema", {})
+            if input_schema is None:
+                raise ValueError("Input schema generation failed")
             if input_schema:
                 _sanitizers.simplify_mcp_schema_inplace(input_schema)
             # MCP spec requires inputSchema to be a JSON Schema with type "object"

langgraph_api/auth/langsmith/backend.py

@@ -21,6 +21,7 @@ class AuthDict(TypedDict):
     organization_id: str
     tenant_id: str
     user_id: NotRequired[str]
+    ls_user_id: NotRequired[str]
     user_email: NotRequired[str]
 
 
@@ -94,6 +95,7 @@ class LangsmithAuthBackend(AuthenticationBackend):
 
         credentials = AuthCredentials(["authenticated"])
         user = StudioUser(auth_dict.get("user_id"), is_authenticated=True)
+        user.ls_user_id = auth_dict.get("ls_user_id")
 
         # Cache the result
         self._cache.set(cache_key, AuthCacheEntry(credentials=credentials, user=user))

langgraph_api/auth/studio_user.py

@@ -5,14 +5,19 @@ from starlette.authentication import BaseUser
 class StudioUser(StudioUserBase, BaseUser):
     """StudioUser class."""
 
+    ls_user_id: str | None = None
+
     def dict(self):
-        return {
+        user = {
             "kind": "StudioUser",
             "is_authenticated": self.is_authenticated,
             "display_name": self.display_name,
             "identity": self.identity,
             "permissions": self.permissions,
         }
+        if self.ls_user_id is not None:
+            user["ls_user_id"] = self.ls_user_id
+        return user
 
     def __getitem__(self, key):
         return self.dict()[key]

langgraph_api/config/__init__.py

@@ -1,4 +1,5 @@
 import os
+from enum import StrEnum
 from os import environ, getenv
 from typing import TYPE_CHECKING, Annotated, Literal, TypeVar, cast
 
@@ -398,6 +399,35 @@ if THREAD_TTL is None and CHECKPOINTER_CONFIG is not None:
     THREAD_TTL = CHECKPOINTER_CONFIG.get("ttl")
 
 N_JOBS_PER_WORKER = env("N_JOBS_PER_WORKER", cast=int, default=10)
+
+
+class DispatchMode(StrEnum):
+    """How background runs are dispatched.
+
+    single-process: Python queue loop in the API process (default).
+    multi-process: Go queue worker claims runs and dispatches to Python runners.
+    """
+
+    SINGLE_PROCESS = "single-process"
+    MULTI_PROCESS = "multi-process"
+
+
+def _parse_dispatch_mode(value: str) -> DispatchMode:
+    try:
+        return DispatchMode(value)
+    except ValueError:
+        allowed = ", ".join(repr(mode.value) for mode in DispatchMode)
+        raise ValueError(
+            f"Invalid DISPATCH_MODE={value!r}; expected one of: {allowed}"
+        ) from None
+
+
+# Not in public docs: infrastructure dispatch mode
+DISPATCH_MODE: DispatchMode = env(
+    "DISPATCH_MODE",
+    cast=_parse_dispatch_mode,
+    default=DispatchMode.SINGLE_PROCESS,
+)
 BG_JOB_TIMEOUT_SECS = env("BG_JOB_TIMEOUT_SECS", cast=float, default=86400)
 STREAM_PUBLISH_RETRY_MAX_DURATION_SECS = env(
     "LSD_STREAM_PUBLISH_RETRY_MAX_DURATION_SECS",
@@ -620,7 +650,9 @@ EXPOSE_INTERNAL_METRICS_PROMETHEUS = env(
 
 # These are only set for internal agents (polly/insights/engine/etc..) deployed in byoc so we can fetch logs (see api/langgraph_api/self_hosted_logs.py)
 DATA_PLANE_ID: str | None = env("DATA_PLANE_ID", cast=str, default=None)
+DATA_PLANE_NAME: str | None = env("DATA_PLANE_NAME", cast=str, default=None)
 DATA_PLANE_ORG_ID: str | None = env("DATA_PLANE_ORG_ID", cast=str, default=None)
+DATA_PLANE_ORG_NAME: str | None = env("DATA_PLANE_ORG_NAME", cast=str, default=None)
 DATA_PLANE_JWT_SECRET: str | None = env("DATA_PLANE_JWT_SECRET", cast=str, default=None)
 BYOC_HOST = env("BYOC_HOST", cast=str, default="byoc")
 BYOC_ENV = env("BYOC_ENV", cast=str, default="byoc")
@@ -687,8 +719,11 @@ __all__ = [
     "DATADOG_METRICS_ENABLED",
     "DATA_PLANE_ID",
     "DATA_PLANE_JWT_SECRET",
+    "DATA_PLANE_NAME",
     "DATA_PLANE_ORG_ID",
+    "DATA_PLANE_ORG_NAME",
     "DB_MIGRATION_BY_CORE_API",
+    "DISPATCH_MODE",
     "EXPOSE_INTERNAL_METRICS_PROMETHEUS",
     "FF_CRONS_ENABLED",
     "FF_LOG_DROPPED_EVENTS",
@@ -769,6 +804,7 @@ __all__ = [
     "AuthConfig",
     "CheckpointerConfig",
     "CorsConfig",
+    "DispatchMode",
     "HttpConfig",
     "SerdeConfig",
     "StoreConfig",

langgraph_api/cron_scheduler.py

@@ -15,7 +15,7 @@ from langgraph_api.schema import Cron
 from langgraph_api.serde import json_loads
 from langgraph_api.utils import next_cron_date
 from langgraph_api.utils.config import run_in_executor
-from langgraph_api.worker import set_auth_ctx_for_run
+from langgraph_api.worker_runtime import set_auth_ctx_for_run
 from langgraph_runtime.database import connect
 from langgraph_runtime.retry import retry_db
 

langgraph_api/encryption/middleware.py

@@ -18,6 +18,7 @@ from starlette.middleware.base import BaseHTTPMiddleware
 from starlette.requests import Request  # noqa: TC002
 
 from langgraph_api.auth.noop import UnauthenticatedUser
+from langgraph_api.auth.studio_user import StudioUser
 from langgraph_api.config import LANGGRAPH_ENCRYPTION
 from langgraph_api.encryption.aes_json import (
     AesEncryptionInstance,
@@ -74,6 +75,9 @@ def _serialize_user_for_encryption(user: BaseUser) -> dict[str, Any]:
     if hasattr(user, "model_dump") and callable(user.model_dump):
         return cast("dict[str, Any]", user.model_dump())
 
+    if isinstance(user, StudioUser):
+        return user.dict()
+
     # Plain BaseUser subclasses - extract the required properties
     return {
         "identity": user.identity,

langgraph_api/graph.py

@@ -502,8 +502,14 @@ def _load_graph_config_from_env() -> dict | None:
     return config_per_id
 
 
-async def collect_graphs_from_env(register: bool = False) -> None:
-    """Return graphs from env."""
+async def collect_graphs_from_env(
+    register: bool = False, *, allow_js: bool = True
+) -> None:
+    """Return graphs from env.
+
+    When ``allow_js`` is False (Python process runner), raise if any JS graph
+    specs are configured instead of starting the JS sidecar.
+    """
 
     # Not in public docs: LANGSERVE_GRAPHS is internal, set by CLI from langgraph.json "graphs" field
     paths_str = os.getenv("LANGSERVE_GRAPHS")
@@ -595,6 +601,12 @@ async def collect_graphs_from_env(register: bool = False) -> None:
     js_specs = list(filter(is_js_spec, specs))
     py_specs = list(filterfalse(is_js_spec, specs))
 
+    if js_specs and not allow_js:
+        raise NotImplementedError(
+            "JS graphs are not supported in the Python process runner. "
+            f"Configured JS graph ids: {[s.id for s in js_specs]}"
+        )
+
     if js_specs:
         if lg_api_config.API_VARIANT == "local_dev":
             raise NotImplementedError(

langgraph_api/js/client.mts

@@ -346,7 +346,10 @@ const handleInvoke = <T extends z.ZodType<any>>(
 const handleStream = <T extends z.ZodType<any>>(
   name: string,
   _schema: T,
-  handler: (rawPayload: z.infer<T>) => AsyncGenerator<any, void, unknown>,
+  handler: (
+    rawPayload: z.infer<T>,
+    signal: AbortSignal,
+  ) => AsyncGenerator<any, void, unknown>,
 ) => {
   return (c: Context<any, any, { in: z.infer<T>; out: any }>) => {
     const graphId = c.req.param("graphId");
@@ -370,18 +373,24 @@ const handleStream = <T extends z.ZodType<any>>(
 
       try {
         timer = setTimeout(sendHeartbeat, HEARTBEAT_MS);
-        for await (const data of handler({ graph_id: graphId, ...body })) {
+        for await (const data of handler(
+          { graph_id: graphId, ...body },
+          c.req.raw.signal,
+        )) {
           await sendSSE(name, data);
         }
       } catch (error) {
         // Still print out the error, as the stack
         // trace is not carried over in Python
         logger.error(error);
-        await sendSSE("error", serializeError(error));
+        // The socket is already gone once the request aborts, so skip the frame.
+        if (!c.req.raw.signal.aborted) {
+          await sendSSE("error", serializeError(error));
+        }
+      } finally {
+        clearTimeout(timer);
+        await resolve;
       }
-
-      clearTimeout(timer);
-      await resolve;
     });
   };
 };
@@ -682,6 +691,7 @@ function reviveCommand(
 
 async function* streamEventsRequest(
   rawPayload: z.infer<typeof StreamEventsPayload>,
+  signal: AbortSignal,
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const config = {
@@ -783,6 +793,7 @@ async function* streamEventsRequest(
       input,
       {
         ...config,
+        signal,
         version: "v3",
         interruptBefore,
         interruptAfter,
@@ -803,6 +814,7 @@ async function* streamEventsRequest(
     input,
     {
       ...config,
+      signal,
       version: "v2",
       streamMode,
       subgraphs: payload.subgraphs,

langgraph_api/js/package.json

@@ -17,9 +17,10 @@
     "@types/json-schema": "^7.0.15",
     "dedent": "^1.7.2",
     "exit-hook": "^5.1.0",
-    "hono": "^4.12.34",
+    "hono": "^4.13.7",
     "p-queue": "^9.3.1",
     "p-retry": "^7.1.1",
+    "typescript": "^5.9.3",
     "undici": "^7.28.0",
     "uuid": "^14.0.1",
     "winston": "^3.19.0",
@@ -40,9 +41,8 @@
     "jose": "^6.2.3",
     "postgres": "^3.4.9",
     "prettier": "^3.9.5",
-    "typescript": "^5.9.3",
     "vite": "^8.1.4",
-    "vitest": "^4.1.10"
+    "vitest": "^5.0.0"
   },
   "packageManager": "yarn@1.22.22+sha512.a6b2f7906b721bba3d67d4aff083df04dad64c399707841b7acf00f6b133b7ac24255f2652fa22ae3534329dc6180534e98d17432037ff6fd140556e2bb3137e"
 }