langgraph-api 0.18.0.dev10__py3-none-any.whl → 0.18.0.dev12__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.18.0.dev10"
+__version__ = "0.18.0.dev12"

langgraph_api/api/threads.py

@@ -7,6 +7,7 @@ from starlette.responses import Response
 from starlette.routing import BaseRoute
 
 from langgraph_api import config as lg_api_config
+from langgraph_api.api.runs import parse_stream_mode_param
 from langgraph_api.config import USE_CUSTOM_CHECKPOINTER
 from langgraph_api.encryption.shared import (
     using_encryption,
@@ -589,24 +590,20 @@ async def join_thread_stream(request: ApiRequest):
         last_event_id, "Invalid last-event-id: must be a valid Redis stream ID"
     )
 
-    # Parse stream_modes parameter - can be single string or comma-separated list
-    stream_modes_param = request.query_params.get("stream_modes")
-    if stream_modes_param:
-        if "," in stream_modes_param:
-            # Handle comma-separated list
-            stream_modes = [mode.strip() for mode in stream_modes_param.split(",")]
-        else:
-            # Handle single value
-            stream_modes = [stream_modes_param]
-        # Validate each mode
-        for mode in stream_modes:
-            if mode not in get_args(ThreadStreamMode):
-                raise HTTPException(
-                    status_code=422, detail=f"Invalid stream mode: {mode}"
-                )
-    else:
-        # Default to run_modes
-        stream_modes = ["run_modes"]
+    # The SDKs send ``stream_mode``: once per mode, or as one JSON array from
+    # JS SDKs before 1.12.
+    params = request.query_params
+    values = params.getlist("stream_modes") or params.getlist("stream_mode")
+    stream_modes = [
+        mode.strip()
+        for value in values
+        if value
+        for item in parse_stream_mode_param(value)
+        for mode in str(item).split(",")
+    ] or ["run_modes"]
+    for mode in stream_modes:
+        if mode not in get_args(ThreadStreamMode):
+            raise HTTPException(status_code=422, detail=f"Invalid stream mode: {mode}")
 
     return EventSourceResponse(
         Threads.Stream.join(

langgraph_api/graph.py

@@ -375,7 +375,10 @@ async def get_graph(
                 CONFIG_KEY_RUNTIME,
             )
 
-            if use_langgraph_runtime:
+            if use_langgraph_runtime or access_context in (
+                "threads.read",
+                "threads.update",
+            ):
                 # xray draw calls runtime.override(), which the SDK ServerRuntime lacks (LSD-1713).
                 from langgraph.runtime import Runtime  # noqa: PLC0415
 

langgraph_api/grpc/client.py

@@ -138,6 +138,14 @@ class GrpcClient:
                 "grpc.http2.initial_window_size",
                 config.GRPC_CLIENT_HTTP2_INITIAL_WINDOW_SIZE,
             ),
+            # The core runs next to the API, so retry a lost connection fast:
+            # gRPC's default backoff grows toward two minutes, which kept API
+            # pods failing for up to 90 seconds after a core restart that took
+            # seconds. Leave grpc.min_reconnect_backoff_ms alone: gRPC uses it
+            # as the minimum connect timeout (20 s), not as a floor between
+            # retries.
+            ("grpc.initial_reconnect_backoff_ms", 100),
+            ("grpc.max_reconnect_backoff_ms", 1000),
         ]
 
         self._channel = aio.insecure_channel(

langgraph_api/grpc/ops/runs.py

@@ -1223,6 +1223,13 @@ class Runs(Authenticated):
                         grpc_code=e.code().name,
                     )
                     raise
+            except asyncio.CancelledError:
+                logger.info(
+                    "Run cancelled, will not signal done",
+                    run_id=run_id,
+                    thread_id=thread_id,
+                )
+                raise
             except BaseException:
                 logger.exception(
                     "Non-retriable exception when marking run as done",

langgraph_api/grpc/ops/threads.py

@@ -960,18 +960,21 @@ class Threads(Authenticated):
             Yields:
                 Tuples of (event_bytes, message_bytes, stream_id_bytes|None)
             """
-            async for (
-                event_bytes,
-                message_bytes,
-                stream_id_bytes,
-                _run_id,
-            ) in Threads.Stream.join_event_streaming(
-                thread_id,
-                stream_modes=stream_modes,
-                last_event_id=last_event_id,
-                ctx=ctx,
-            ):
-                yield (event_bytes, message_bytes, stream_id_bytes)
+            async with aclosing(
+                Threads.Stream.join_event_streaming(
+                    thread_id,
+                    stream_modes=stream_modes,
+                    last_event_id=last_event_id,
+                    ctx=ctx,
+                )
+            ) as events:
+                async for (
+                    event_bytes,
+                    message_bytes,
+                    stream_id_bytes,
+                    _run_id,
+                ) in events:
+                    yield (event_bytes, message_bytes, stream_id_bytes)
 
         @staticmethod
         async def join_event_streaming(
@@ -1006,9 +1009,9 @@ class Threads(Authenticated):
                 request.last_event_id = last_event_id
 
             client = await get_shared_client()
-
+            call = client.threads.Stream(request)
             try:
-                async for event in client.threads.Stream(request):
+                async for event in call:
                     # Convert protobuf StreamEvent to tuple format
                     event_bytes = event.event_type.encode("utf-8")
                     message_bytes = event.message
@@ -1028,6 +1031,8 @@ class Threads(Authenticated):
                 if isinstance(e, AioRpcError):
                     _handle_grpc_error(e)
                 raise
+            finally:
+                call.cancel()
 
         @staticmethod
         async def check_thread_stream_auth(

langgraph_api/js/client.mts

@@ -6,7 +6,7 @@ import { serve } from "@hono/node-server";
 import { zValidator } from "@hono/zod-validator";
 import { streamSSE, stream } from "hono/streaming";
 import { HTTPException } from "hono/http-exception";
-import { fetch } from "undici";
+import { Agent, fetch as undiciFetch } from "undici";
 import pRetry from "p-retry";
 import {
   getConfig,
@@ -26,6 +26,7 @@ import {
   type ChannelVersions,
   type ChannelProtocol,
 } from "@langchain/langgraph-checkpoint";
+import { AsyncLocalStorage } from "node:async_hooks";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { serialiseAsDict, serializeError } from "./src/utils/serde.mjs";
@@ -227,6 +228,44 @@ async function getOrExtractSchema(graphId: string) {
 // Pinned by the Python parent (see remote.py); base ports are the fallback.
 const GRAPH_PORT = Number(process.env.LANGGRAPH_JS_GRAPH_PORT) || 5556;
 const REMOTE_PORT = Number(process.env.LANGGRAPH_JS_REMOTE_PORT) || 5555;
+const REMOTE_SOCKET = process.env.LANGGRAPH_JS_REMOTE_SOCKET;
+
+// Unix: HTTP over a Unix socket (dummy host; undici dials socketPath).
+// Windows: TCP localhost for checkpointer/store only; no loopback client.
+const remoteAgent = REMOTE_SOCKET
+  ? new Agent({ connect: { socketPath: REMOTE_SOCKET } })
+  : undefined;
+const REMOTE_ORIGIN = REMOTE_SOCKET
+  ? "http://loopback"
+  : `http://localhost:${REMOTE_PORT}`;
+
+const LOOPBACK_RUN_HEADER = "x-langgraph-loopback-run";
+const loopbackRun = new AsyncLocalStorage<string>();
+
+function remoteFetch(
+  input: Parameters<typeof undiciFetch>[0],
+  init?: Parameters<typeof undiciFetch>[1],
+) {
+  const token = loopbackRun.getStore();
+  if (token) {
+    const headers = new Headers(init?.headers as HeadersInit | undefined);
+    headers.set(LOOPBACK_RUN_HEADER, token);
+    init = { ...init, headers };
+  }
+  if (remoteAgent) {
+    return undiciFetch(input, { ...init, dispatcher: remoteAgent });
+  }
+  return undiciFetch(input, init);
+}
+
+// Default `new Client()` (no apiUrl) reads these symbols.
+const LOOPBACK_URL = REMOTE_SOCKET ? `${REMOTE_ORIGIN}/loopback` : undefined;
+
+if (LOOPBACK_URL) {
+  const g = globalThis as unknown as Record<symbol, unknown>;
+  g[Symbol.for("langgraph_api:url")] = LOOPBACK_URL;
+  if (remoteAgent) g[Symbol.for("langgraph_api:fetch")] = remoteFetch;
+}
 
 const RunnableConfigSchema = z.object({
   tags: z.array(z.string()).optional(),
@@ -253,10 +292,10 @@ const getRunnableConfig = (
   };
 };
 
-function tryFetch(...args: Parameters<typeof fetch>) {
+function tryFetch(...args: Parameters<typeof remoteFetch>) {
   return pRetry(
     async () => {
-      const response = await fetch(...args).catch((error) => {
+      const response = await remoteFetch(...args).catch((error) => {
         throw new Error(`${args[0]} connecfailed: ${error}`);
       });
 
@@ -264,7 +303,7 @@ function tryFetch(...args: Parameters<typeof fetch>) {
         let errorMessage = `${args[0]} failed: HTTP ${response.status}`;
         try {
           errorMessage += `: ${await response.text()}`;
-        } catch { }
+        } catch {}
         throw new Error(errorMessage);
       }
 
@@ -283,7 +322,7 @@ async function sendRecv<T = any>(
   method: `${"checkpointer" | "store"}_${string}`,
   data: unknown,
 ): Promise<T> {
-  const res = await tryFetch(`http://localhost:${REMOTE_PORT}/${method}`, {
+  const res = await tryFetch(`${REMOTE_ORIGIN}/${method}`, {
     method: "POST",
     headers: { "Content-Type": "application/json" },
     body: JSON.stringify(data),
@@ -655,9 +694,7 @@ const StreamEventsPayload = z.object({
         .nullish(),
     })
     .nullish(),
-  stream_mode: z
-    .union([z.string(), z.array(z.string())])
-    .optional(),
+  stream_mode: z.union([z.string(), z.array(z.string())]).optional(),
   config: RunnableConfigSchema.nullish(),
   context: z.record(z.unknown()).nullish(),
   interrupt_before: z.union([z.array(z.string()), z.literal("*")]).nullish(),
@@ -671,6 +708,7 @@ const StreamEventsPayload = z.object({
   // streaming endpoints.
   stream_protocol: z.enum(["v2", "v3"]).nullish(),
   output_keys: z.union([z.string(), z.array(z.string())]).nullish(),
+  loopback_token: z.string().nullish(),
 });
 
 function reviveCommand(
@@ -697,7 +735,8 @@ async function* streamEventsRequest(
   rawPayload: z.infer<typeof StreamEventsPayload>,
   signal: AbortSignal,
 ) {
-  const { graph_id: graphId, ...payload } = rawPayload;
+  const { graph_id: graphId, loopback_token: token, ...payload } = rawPayload;
+  if (token) loopbackRun.enterWith(token);
   const config = {
     ...getRunnableConfig(payload.config),
     context: payload.context ?? undefined,
@@ -793,47 +832,41 @@ async function* streamEventsRequest(
           options: Record<string, unknown>,
         ) => Promise<AsyncIterable<unknown>>;
       }
-    ).streamEvents(
-      input,
-      {
-        ...config,
-        signal,
-        version: "v3",
-        outputKeys:
-          payload.output_keys === undefined
-            ? graph.outputChannels
-            : (payload.output_keys ?? undefined),
-        interruptBefore,
-        interruptAfter,
-        ...(callbacks ? { callbacks } : {}),
-        ...(payload.durability === undefined
-          ? {}
-          : { durability: payload.durability }),
-      },
-    );
-
-    for await (const event of protocolStream) {
-      yield event;
-    }
-    return;
-  }
-
-  for await (const data of graph.streamEvents(
-    input,
-    {
+    ).streamEvents(input, {
       ...config,
       signal,
-      version: "v2",
-      streamMode,
-      subgraphs: payload.subgraphs,
+      version: "v3",
+      outputKeys:
+        payload.output_keys === undefined
+          ? graph.outputChannels
+          : (payload.output_keys ?? undefined),
       interruptBefore,
       interruptAfter,
       ...(callbacks ? { callbacks } : {}),
       ...(payload.durability === undefined
         ? {}
         : { durability: payload.durability }),
-    },
-  )) {
+    });
+
+    for await (const event of protocolStream) {
+      yield event;
+    }
+    return;
+  }
+
+  for await (const data of graph.streamEvents(input, {
+    ...config,
+    signal,
+    version: "v2",
+    streamMode,
+    subgraphs: payload.subgraphs,
+    interruptBefore,
+    interruptAfter,
+    ...(callbacks ? { callbacks } : {}),
+    ...(payload.durability === undefined
+      ? {}
+      : { durability: payload.durability }),
+  })) {
     // TODO: upstream this fix to LangGraphJS
     if (streamMode.length === 1 && !Array.isArray(data.data.chunk)) {
       data.data.chunk = [streamMode[0], data.data.chunk];
@@ -850,7 +883,11 @@ async function* streamEventsRequest(
     if (userStreamMode.includes("messages")) {
       if (data.event === "on_chain_stream" && data.run_id === config.runId) {
         const newMessages: Array<BaseMessageChunk> = [];
-        const [_, chunk]: [string, any] = data.data.chunk;
+        const tuple: unknown[] = data.data.chunk;
+        // With subgraphs on, chunks are [ns, mode, chunk]; a subgraph's
+        // values are not the root graph's messages.
+        if (tuple.length === 3 && (tuple[0] as string[]).length > 0) continue;
+        const chunk: any = tuple.at(-1);
 
         let chunkMessages: Array<BaseMessageChunk> = [];
         if (
@@ -1140,16 +1177,16 @@ async function main() {
         meta.threshold_ms = GRAPH_ERROR_MS;
         logger.error(
           "Graph import exceeded error threshold. " +
-          "Slow initialization (often due to work executed at import time) can delay readiness, " +
-          "slow scale-out velocity, and may cause deployments to be marked unhealthy.",
+            "Slow initialization (often due to work executed at import time) can delay readiness, " +
+            "slow scale-out velocity, and may cause deployments to be marked unhealthy.",
           meta,
         );
       } else if (durationMs > GRAPH_WARN_MS) {
         meta.threshold_ms = GRAPH_WARN_MS;
         logger.warn(
           "Graph import exceeded warn threshold. " +
-          "Slow initialization (often due to work executed at import time) can delay readiness, " +
-          "slow scale-out velocity, and may cause deployments to be marked unhealthy.",
+            "Slow initialization (often due to work executed at import time) can delay readiness, " +
+            "slow scale-out velocity, and may cause deployments to be marked unhealthy.",
           meta,
         );
       } else {
@@ -1172,14 +1209,14 @@ async function main() {
     totalMeta.threshold_ms = GRAPH_ERROR_MS;
     logger.error(
       "All graphs resolved but exceeded error threshold. " +
-      "Consider reducing the number of graphs or optimizing their imports.",
+        "Consider reducing the number of graphs or optimizing their imports.",
       totalMeta,
     );
   } else if (resolveTotal > GRAPH_WARN_MS) {
     totalMeta.threshold_ms = GRAPH_WARN_MS;
     logger.warn(
       "All graphs resolved but exceeded warn threshold. " +
-      "Consider optimizing graph imports to improve startup time.",
+        "Consider optimizing graph imports to improve startup time.",
       totalMeta,
     );
   } else {

langgraph_api/js/global.d.ts

@@ -4,6 +4,7 @@ declare namespace NodeJS {
     LANGGRAPH_UI?: string;
     LANGGRAPH_UI_CONFIG?: string;
     LANGGRAPH_AUTH?: string;
+    LANGGRAPH_JS_REMOTE_SOCKET?: string;
     PORT: string;
   }
 }

langgraph_api/js/remote.py

@@ -1,13 +1,18 @@
 import asyncio
 import contextlib
+import copy
 import json
 import logging
 import os
 import re
+import secrets
 import shutil
 import ssl
+import sys
+import tempfile
+import time
 from collections import deque
-from collections.abc import AsyncIterator, Callable
+from collections.abc import AsyncIterator, Callable, Iterator, Mapping
 from inspect import signature
 from typing import Any, Literal, Self, cast
 
@@ -24,6 +29,7 @@ from langchain_core.runnables.schema import (
     StandardStreamEvent,
     StreamEvent,
 )
+from langgraph.checkpoint.memory import InMemorySaver
 from langgraph.checkpoint.serde.base import SerializerProtocol
 from langgraph.store.base import GetOp, Item, ListNamespacesOp, PutOp, SearchOp
 from langgraph.types import Command, PregelTask, Send, StateSnapshot
@@ -52,13 +58,17 @@ from langgraph_api.js.sse import SSEDecoder, aiter_lines_raw
 from langgraph_api.route import ApiResponse
 from langgraph_api.schema import Config
 from langgraph_api.serde import json_dumpb
-from langgraph_api.utils import get_auth_ctx, get_user_id
+from langgraph_api.utils import AuthContext, get_auth_ctx, get_user_id
 
 logger = structlog.stdlib.get_logger(__name__)
 
-# Loopback ports between the Python parent and its JS subprocess. Containers
-# colocated in one pod share a network namespace, so each entrypoint gets its
-# own range (via the offset below); LANGGRAPH_JS_*_PORT overrides any port.
+# Loopback IPC between the Python parent and its JS subprocess.
+# GRAPH_* stay on TCP; the remote server (checkpointer/store + /loopback) is a
+# Unix socket except on Windows, where uvicorn cannot bind AF_UNIX.
+# Containers colocated in one pod share a network namespace, so each
+# entrypoint gets its own TCP range (via the offset below); LANGGRAPH_JS_*_PORT
+# overrides any port. The remote socket path includes the pid so API and queue
+# workers in one container do not collide.
 _BASE_REMOTE_PORT = 5555
 _BASE_GRAPH_PORT = 5556
 _BASE_GRAPH_HTTP_PORT = 5557
@@ -90,6 +100,11 @@ GRAPH_PORT = _resolve_js_port(
 GRAPH_HTTP_PORT = _resolve_js_port(
     _BASE_GRAPH_HTTP_PORT, _JS_PORT_OFFSET, os.getenv("LANGGRAPH_JS_GRAPH_HTTP_PORT")
 )
+REMOTE_SOCKET = (
+    None
+    if sys.platform == "win32"
+    else os.path.join(tempfile.gettempdir(), f"lg-js-r{os.getpid()}.sock")
+)
 SSL = ssl.create_default_context(cafile=certifi.where())
 
 if (port := int(os.getenv("PORT", "8080"))) and port in (GRAPH_PORT, REMOTE_PORT):
@@ -97,6 +112,40 @@ if (port := int(os.getenv("PORT", "8080"))) and port in (GRAPH_PORT, REMOTE_PORT
         f"PORT={port} is a reserved port for the JS worker. Please choose a different port."
     )
 
+
+def _js_graph_worker_env(**extra: str | None) -> dict[str, str]:
+    """Env for the Node graph worker. Unix only: path of the remote UDS."""
+    env = {
+        "LANGCHAIN_CALLBACKS_BACKGROUND": "true",
+        "CHOKIDAR_USEPOLLING": "true",
+        **os.environ,
+        "LANGGRAPH_JS_REMOTE_PORT": str(REMOTE_PORT),
+        "LANGGRAPH_JS_GRAPH_PORT": str(GRAPH_PORT),
+        "LANGGRAPH_JS_GRAPH_HTTP_PORT": str(GRAPH_HTTP_PORT),
+        **{key: value for key, value in extra.items() if value is not None},
+    }
+    if REMOTE_SOCKET:
+        env["LANGGRAPH_JS_REMOTE_SOCKET"] = REMOTE_SOCKET
+    else:
+        env.pop("LANGGRAPH_JS_REMOTE_SOCKET", None)
+    return env
+
+
+def _checkpointer_httpx_client() -> httpx.AsyncClient:
+    """Client for the remote server: Unix socket, or TCP localhost on Windows."""
+    if REMOTE_SOCKET:
+        return httpx.AsyncClient(
+            base_url="http://loopback",
+            limits=httpx.Limits(max_connections=1),
+            transport=httpx.AsyncHTTPTransport(uds=REMOTE_SOCKET, verify=SSL),
+        )
+    return httpx.AsyncClient(
+        base_url=f"http://localhost:{REMOTE_PORT}",
+        limits=httpx.Limits(max_connections=1),
+        transport=httpx.AsyncHTTPTransport(verify=SSL),
+    )
+
+
 # Per-graph context schema, prefetched at startup so get_context_jsonschema stays sync.
 _context_jsonschema_cache: dict[str, dict[str, Any] | None] = {}
 
@@ -259,11 +308,14 @@ class RemotePregel(BaseRemotePregel):
             **kwargs,
         }
 
-        async for event in _client_stream("streamEvents", data):
-            if event["event"] == "on_custom_event":
-                yield CustomStreamEvent(**event)
-            else:
-                yield StandardStreamEvent(**event)
+        with loopback_grant() as token:
+            async for event in _client_stream(
+                "streamEvents", {**data, "loopback_token": token}
+            ):
+                if event["event"] == "on_custom_event":
+                    yield CustomStreamEvent(**event)
+                else:
+                    yield StandardStreamEvent(**event)
 
     async def astream_protocol_events(
         self,
@@ -292,8 +344,11 @@ class RemotePregel(BaseRemotePregel):
             **kwargs,
         }
 
-        async for event in _client_stream("streamEvents", data):
-            yield event
+        with loopback_grant() as token:
+            async for event in _client_stream(
+                "streamEvents", {**data, "loopback_token": token}
+            ):
+                yield event
 
     async def fetch_state_schema(self):
         return await _client_invoke(
@@ -540,6 +595,19 @@ class RemotePregel(BaseRemotePregel):
         return config
 
 
+# A crash loop is this many JS process exits within JS_PROCESS_CRASH_LOOP_SECS,
+# and takes the API down. Exits further apart, even many over the server's
+# life, restart the process.
+JS_PROCESS_CRASH_LOOP_EXITS = 4
+JS_PROCESS_CRASH_LOOP_SECS = 600
+
+
+def _is_crash_loop(exits: deque[float]) -> bool:
+    return (
+        len(exits) == exits.maxlen and exits[-1] - exits[0] < JS_PROCESS_CRASH_LOOP_SECS
+    )
+
+
 async def run_js_process(paths_str: str | None, watch: bool = False):
     # check if tsx is available
     tsx_path = shutil.which("tsx")
@@ -548,6 +616,7 @@ async def run_js_process(paths_str: str | None, watch: bool = False):
             "tsx not found in PATH. Please upgrade to latest LangGraph CLI to support running JS graphs."
         )
     attempt = 0
+    exits: deque[float] = deque(maxlen=JS_PROCESS_CRASH_LOOP_EXITS)
     while (current_task := asyncio.current_task()) and not current_task.cancelled():
         client_file = os.path.join(os.path.dirname(__file__), "client.mts")
         client_preload_file = os.path.join(
@@ -570,17 +639,10 @@ async def run_js_process(paths_str: str | None, watch: bool = False):
         try:
             process = await asyncio.create_subprocess_exec(
                 *args,
-                env={
-                    "LANGSERVE_GRAPHS": paths_str,
-                    "LANGCHAIN_CALLBACKS_BACKGROUND": "true",
-                    "NODE_ENV": "development" if watch else "production",
-                    "CHOKIDAR_USEPOLLING": "true",
-                    **os.environ,
-                    # Pin the child to the parent's resolved ports.
-                    "LANGGRAPH_JS_REMOTE_PORT": str(REMOTE_PORT),
-                    "LANGGRAPH_JS_GRAPH_PORT": str(GRAPH_PORT),
-                    "LANGGRAPH_JS_GRAPH_HTTP_PORT": str(GRAPH_HTTP_PORT),
-                },
+                env=_js_graph_worker_env(
+                    LANGSERVE_GRAPHS=paths_str,
+                    NODE_ENV="development" if watch else "production",
+                ),
             )
             logger.info(
                 "Started JS graphs process",
@@ -604,11 +666,11 @@ async def run_js_process(paths_str: str | None, watch: bool = False):
                     await process.wait()
             raise
         except Exception:
-            if attempt >= 3:
+            exits.append(time.monotonic())
+            if _is_crash_loop(exits):
                 raise
-            else:
-                logger.warning(f"Retrying JS process {3 - attempt} more times...")
-                attempt += 1
+            logger.warning("Restarting JS process", recent_exits=len(exits))
+            attempt += 1
 
 
 async def run_js_http_process(
@@ -622,6 +684,7 @@ async def run_js_http_process(
         )
 
     attempt = 0
+    exits: deque[float] = deque(maxlen=JS_PROCESS_CRASH_LOOP_EXITS)
     while (current_task := asyncio.current_task()) and not current_task.cancelled():
         client_file = os.path.join(os.path.dirname(__file__), "client.http.mts")
         args = ("tsx", "watch", client_file) if watch else ("tsx", client_file)
@@ -669,12 +732,12 @@ async def run_js_http_process(
                     await process.wait()
             raise
         except Exception:
-            if attempt >= 3:
+            exits.append(time.monotonic())
+            if _is_crash_loop(exits):
                 logger.exception("JS HTTP process failed")
                 raise
-            else:
-                logger.warning(f"Retrying JS HTTP process {3 - attempt} more times...")
-                attempt += 1
+            logger.warning("Restarting JS HTTP process", recent_exits=len(exits))
+            attempt += 1
 
 
 _BAD_SURROGATE_RE = re.compile(r"\\u[dD][89a-fA-F][0-9a-fA-F]{2}")
@@ -718,6 +781,11 @@ async def _get_passthrough_checkpointer():
     from langgraph_api import _checkpointer as api_checkpointer  # noqa: PLC0415
 
     checkpointer = await api_checkpointer.get_checkpointer()
+    # The in-memory runtime returns the saver Python graphs share, so swap the
+    # serde on a copy; the copy still shares the saved data. Other runtimes
+    # return a fresh saver per call.
+    if isinstance(checkpointer, InMemorySaver):
+        checkpointer = copy.copy(checkpointer)
     # This checkpointer does not attempt to revive LC-objects.
     # Instead, it will pass through the JSON values as-is.
     checkpointer.serde = PassthroughSerialiser()
@@ -975,20 +1043,125 @@ async def run_remote_checkpointer():
         ]
     )
 
-    server = NoSignalServer(
-        uvicorn.Config(
-            remote,
-            port=REMOTE_PORT,
-            # We need to _explicitly_ set these values in order
-            # to avoid reinitialising the logger, which removes
-            # the structlog logger setup before.
-            # See: https://github.com/encode/uvicorn/blob/8f4c8a7f34914c16650ebd026127b96560425fde/uvicorn/config.py#L357-L393
-            log_config=None,
-            log_level=None,
-            access_log=True,
+    log_kwargs = {
+        # We need to _explicitly_ set these values in order
+        # to avoid reinitialising the logger, which removes
+        # the structlog logger setup before.
+        # See: https://github.com/encode/uvicorn/blob/8f4c8a7f34914c16650ebd026127b96560425fde/uvicorn/config.py#L357-L393
+        "log_config": None,
+        "log_level": None,
+        "access_log": True,
+    }
+    if REMOTE_SOCKET:
+        with contextlib.suppress(FileNotFoundError):
+            os.unlink(REMOTE_SOCKET)
+        server = NoSignalServer(
+            uvicorn.Config(loopback_to_api(remote), uds=REMOTE_SOCKET, **log_kwargs)
         )
-    )
-    await server.serve()
+    else:
+        # Windows: checkpointer/store over TCP, no /loopback client.
+        server = NoSignalServer(
+            uvicorn.Config(remote, host="127.0.0.1", port=REMOTE_PORT, **log_kwargs)
+        )
+    try:
+        await server.serve()
+    finally:
+        if REMOTE_SOCKET:
+            with contextlib.suppress(FileNotFoundError):
+                os.unlink(REMOTE_SOCKET)
+
+
+LOOPBACK_PREFIX = "/loopback"
+"""Path on the Unix remote socket under which JS graphs reach this server's API."""
+
+LOOPBACK_RUN_HEADER = b"x-langgraph-loopback-run"
+"""Header the JS worker sends so loopback calls run as the stream's user."""
+
+_LOOPBACK_GRANTS: dict[str, Auth.types.BaseAuthContext | None] = {}
+"""Live JS graph streams, and the auth context each stream's loopback calls use."""
+
+_MISSING = object()
+
+
+@contextlib.contextmanager
+def loopback_grant() -> Iterator[str]:
+    """Map one JS graph stream to the run's auth context.
+
+    Python graphs' in-process calls keep the run's AuthContext ContextVar
+    because they stay on the same asyncio task. A JS graph's call arrives on
+    the Unix-socket uvicorn task, where that var is empty, so the stream
+    carries this token and loopback_to_api restores the context.
+    """
+    token = secrets.token_urlsafe(32)
+    _LOOPBACK_GRANTS[token] = get_auth_ctx()
+    try:
+        yield token
+    finally:
+        _LOOPBACK_GRANTS.pop(token, None)
+
+
+def _loopback_api_path(path: str) -> str | None:
+    """Return the API path for a `/loopback/...` request, or `None` if it isn't one."""
+    if path == LOOPBACK_PREFIX:
+        return "/"
+    if not path.startswith(f"{LOOPBACK_PREFIX}/"):
+        return None
+    return path.removeprefix(LOOPBACK_PREFIX) or "/"
+
+
+def _loopback_grant(
+    scope: types.Scope, grants: Mapping[str, Auth.types.BaseAuthContext | None]
+) -> Auth.types.BaseAuthContext | None | object:
+    """The run's auth context, or _MISSING if this isn't a live loopback call."""
+    token: str | None = None
+    for name, value in scope.get("headers") or ():
+        if name == LOOPBACK_RUN_HEADER:
+            token = value.decode()
+            break
+    if token is None or token not in grants:
+        return _MISSING
+    return grants[token]
+
+
+def loopback_to_api(
+    remote: types.ASGIApp,
+    grants: Mapping[str, Auth.types.BaseAuthContext | None] | None = None,
+) -> types.ASGIApp:
+    """Serve JS graphs' SDK calls in process, the way Python graphs' `get_client()` does.
+
+    A Python graph's SDK client reaches the API in memory at `root_path="/noauth"`,
+    with its run's auth context still set. A JS graph sends the same calls over
+    the Unix remote socket; a live grant header restores that run's user
+    before the API handler runs. Unix only. Windows does not mount this.
+    """
+    if grants is None:
+        grants = _LOOPBACK_GRANTS
+
+    async def app(scope: types.Scope, receive: types.Receive, send: types.Send) -> None:
+        api_path = (
+            _loopback_api_path(scope.get("path", ""))
+            if scope["type"] == "http"
+            else None
+        )
+        ctx = _loopback_grant(scope, grants) if api_path is not None else _MISSING
+        if api_path is None or ctx is _MISSING:
+            await remote(scope, receive, send)
+            return
+        from langgraph_api.server import app as api  # noqa: PLC0415
+
+        scope = {
+            **scope,
+            "root_path": "/noauth",
+            "path": api_path,
+            "raw_path": api_path.encode(),
+        }
+        reset = AuthContext.set(cast("Auth.types.BaseAuthContext | None", ctx))
+        try:
+            await api(scope, receive, send)
+        finally:
+            AuthContext.reset(reset)
+
+    return app
 
 
 class DisableHttpxLoggingContextManager(contextlib.AbstractContextManager):
@@ -1023,11 +1196,7 @@ async def wait_until_js_ready(
                 limits=httpx.Limits(max_connections=1),
                 transport=httpx.AsyncHTTPTransport(verify=SSL),
             ) as graph_client,
-            httpx.AsyncClient(
-                base_url=f"http://localhost:{REMOTE_PORT}",
-                limits=httpx.Limits(max_connections=1),
-                transport=httpx.AsyncHTTPTransport(verify=SSL),
-            ) as checkpointer_client,
+            _checkpointer_httpx_client() as checkpointer_client,
         ):
             attempt = 0
             graph_ready = False
@@ -1088,11 +1257,7 @@ async def js_healthcheck():
                 limits=httpx.Limits(max_connections=1),
                 transport=httpx.AsyncHTTPTransport(verify=SSL),
             ) as graph_client,
-            httpx.AsyncClient(
-                base_url=f"http://localhost:{REMOTE_PORT}",
-                limits=httpx.Limits(max_connections=1),
-                transport=httpx.AsyncHTTPTransport(verify=SSL),
-            ) as checkpointer_client,
+            _checkpointer_httpx_client() as checkpointer_client,
         ):
             graph_passed = False
             try:

langgraph_api/metadata.py

@@ -155,6 +155,12 @@ def _lang_usage_metadata() -> tuple[dict[str, str], dict[str, int]]:
     return tags, measures
 
 
+def _billing_channel() -> str:
+    # A self-hosted LangSmith bills API-key usage under its own license unless the
+    # server already reports it under a license key.
+    return "license_key" if LANGGRAPH_CLOUD_LICENSE_KEY else "api_key"
+
+
 def incr_runs(*, incr: int = 1) -> None:
     global RUN_COUNTER
     RUN_COUNTER += incr
@@ -283,6 +289,7 @@ async def metadata_loop() -> None:
             langchain_payload = {
                 **base_payload,
                 "api_key": LANGSMITH_CONTROL_PLANE_API_KEY,
+                "billing_channel": _billing_channel(),
             }
             submissions_attempted.append("langchain")
             try:

langgraph_api/models/run.py

@@ -233,15 +233,12 @@ async def create_valid_run(
             detail="Cannot specify both configurable and context. Prefer setting context alone. Context was introduced in LangGraph 0.6.0 and is the long term planned replacement for configurable.",
         )
 
-    # ``tools`` and ``lifecycle`` are emitted only by the protocol v2
-    # streaming pipeline (``stream_v2.py`` / ``StreamMessagesHandlerV2``
-    # plus the registered stream transformers). Accepting them on legacy
-    # streaming routes would either no-op (``lifecycle``, never emitted
-    # without a transformer) or leak v2-shaped events into v1 consumers
-    # (``tools``). Reject up front so callers get a clear 422 instead of
-    # a silently empty stream.
+    # ``lifecycle`` is emitted only by the protocol v2 streaming pipeline
+    # (``stream_v2.py`` plus the registered stream transformers), so legacy
+    # routes reject it up front instead of returning a silently empty stream.
+    # ``tools`` is accepted on legacy routes and dropped in ``stream.py``.
     if not configurable.get(EVENT_STREAMING_V2_CONFIG_KEY):
-        v2_only = {"tools", "lifecycle"}.intersection(stream_mode)
+        v2_only = {"lifecycle"}.intersection(stream_mode)
         if v2_only:
             raise HTTPException(
                 status_code=422,

langgraph_api/stream.py

@@ -265,6 +265,11 @@ async def astream_state(
         # ``capabilities.py`` documents this behavior — keep them in sync.
         stream_modes_set.discard("tools")
         stream_modes_set.discard("lifecycle")
+    elif not event_streaming_v2_run:
+        # The v1 React ``useStream`` hook asks for ``tools`` whenever an app
+        # listens for tool events, but it cannot parse the events graphs emit
+        # for this mode and throws on the first one.
+        stream_modes_set.discard("tools")
     if "debug" not in stream_modes_set:
         stream_modes_set.add("debug")
     if "messages-tuple" in stream_modes_set and not is_remote_pregel:
@@ -738,23 +743,42 @@ async def _consume_inline(
     This preserves natural backpressure: each event must be published before the
     next one is consumed.
     """
+    publishing = True
     async with aclosing(stream):
         try:
             async for mode, payload in stream:
+                if not publishing:
+                    continue
                 event_type = get_stream_event_type(mode)
                 payload_bytes = await run_in_executor(None, json_dumpb, payload)
-                is_resumable = resumable and mode.split("|")[0] in stream_modes
-                with reporter.track_latency_ms(
-                    LATENCY_STREAM_PUBLISH,
-                    attributes={"stream_event_type": event_type},
-                ):
-                    await Runs.Stream.publish(
-                        run_id,
-                        mode,
-                        payload_bytes,
-                        thread_id=thread_id,
-                        resumable=is_resumable,
+                is_resumable = resumable and event_type.split("/")[0] in stream_modes
+                try:
+                    with reporter.track_latency_ms(
+                        LATENCY_STREAM_PUBLISH,
+                        attributes={"stream_event_type": event_type},
+                    ):
+                        await Runs.Stream.publish(
+                            run_id,
+                            mode,
+                            payload_bytes,
+                            thread_id=thread_id,
+                            resumable=is_resumable,
+                        )
+                except StreamPublishException as e:
+                    # Stop publishing for the rest of the run: transient errors
+                    # were already retried for up to a minute, and retrying every
+                    # later event would stall the graph again each time. The run
+                    # still finishes, and the worker records its real outcome.
+                    publishing = False
+                    await logger.aerror(
+                        "Stream publish failed, finishing the run without streaming",
+                        run_id=str(run_id),
+                        thread_id=str(thread_id),
+                        error_type=type(e).__name__,
+                        error=str(e),
                     )
+                    reporter.inc_counter(COUNTER_STREAMING_DATA_LOSS)
+                    continue
                 reporter.record_histogram(
                     HISTOGRAM_STREAM_DATA_SIZE,
                     float(len(payload_bytes)),
@@ -763,26 +787,6 @@ async def _consume_inline(
         except Exception as e:
             if isinstance(e, ExceptionGroup):
                 e = e.exceptions[0]
-            if isinstance(e, StreamPublishException):
-                # We swallow this and report the run as complete, so the worker
-                # never sees it and cannot surface it. Emit it to the client here.
-                with suppress(Exception):
-                    await Runs.Stream.publish(
-                        run_id,
-                        "error",
-                        await run_in_executor(None, json_dumpb, e),
-                        thread_id=thread_id,
-                        resumable=resumable,
-                    )
-                await logger.aerror(
-                    "Suppressing stream consume exception",
-                    run_id=str(run_id),
-                    thread_id=str(thread_id),
-                    error_type=type(e).__name__,
-                    error=str(e),
-                )
-                reporter.inc_counter(COUNTER_STREAMING_DATA_LOSS)
-                return
             raise e
 
 
@@ -858,7 +862,7 @@ async def _consume_async_queue(
             async for mode, payload in stream:
                 event_type = get_stream_event_type(mode)
                 payload_bytes = await run_in_executor(None, json_dumpb, payload)
-                is_resumable = resumable and mode.split("|")[0] in stream_modes
+                is_resumable = resumable and event_type.split("/")[0] in stream_modes
                 await _enqueue((mode, payload_bytes, event_type, is_resumable))
 
     except Exception as e:

langgraph_api/worker.py

@@ -296,6 +296,15 @@ async def worker(
                     "Background run timed out. To increase the timeout, set the BG_JOB_TIMEOUT_SECS environment variable (integer, defaults to 86400).",
                     **log_info,
                 )
+                # Without it, every stream shows a timed-out run as a success.
+                with suppress(Exception):
+                    await Runs.Stream.publish(
+                        run_id,
+                        "error",
+                        json_dumpb(exception),
+                        thread_id=run["thread_id"],
+                        resumable=resumable,
+                    )
                 if not temporary:
                     await Threads.set_joint_status(
                         conn,

{langgraph_api-0.18.0.dev10.dist-info → langgraph_api-0.18.0.dev12.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev10
+Version: 0.18.0.dev12
 Author-email: Will Fu-Hinthorn <will@langchain.dev>, Josh Rogers <josh@langchain.dev>, Parker Rule <parker@langchain.dev>
 License: Elastic-2.0
 License-File: LICENSE
@@ -24,7 +24,7 @@ Requires-Dist: langsmith[otel]>=0.6.3
 Requires-Dist: mcp<3,>=2.3.0
 Requires-Dist: opentelemetry-api>=0.0.1
 Requires-Dist: opentelemetry-exporter-otlp-proto-http>=0.0.1
-Requires-Dist: opentelemetry-exporter-prometheus<0.64,>=0.63b1
+Requires-Dist: opentelemetry-exporter-prometheus<0.67,>=0.63b1
 Requires-Dist: opentelemetry-sdk>=0.0.1
 Requires-Dist: orjson>=3.9.7
 Requires-Dist: packaging>=23.2

{langgraph_api-0.18.0.dev10.dist-info → langgraph_api-0.18.0.dev12.dist-info}/RECORD

@@ -1,4 +1,4 @@
-langgraph_api/__init__.py,sha256=-bIIVjTdPEAZN8A072q6cjv1tdFUQmeHn9FYvYC-Q14,29
+langgraph_api/__init__.py,sha256=4-U3UVsECE8ZPJ6VZOCr58LOX8rIvYtmAXI_APYqlGo,29
 langgraph_api/_factory_utils.py,sha256=_FqW0olMu2PGLsnRq0ylt3a4jDCe12YIFHExMXI6Nyo,5976
 langgraph_api/asgi_transport.py,sha256=XApY3lIWBZTMbbsl8dDJzl0cLGirmAGE0SifqZUnXvs,11896
 langgraph_api/asyncio.py,sha256=-p-Vx89TnErypdPcWb-2EdbsSvhdIdHfriCFG7UP7ls,12444
@@ -10,12 +10,12 @@ langgraph_api/cron_scheduler.py,sha256=H1jPymC68A1MYyjfdApX4-hELiGBlJpGgSOsN8qhc
 langgraph_api/drain.py,sha256=MLUm3fDq3R8yxrZ-1W3TeCfhNzgNSzUA7TvB-D6K2_s,6108
 langgraph_api/errors.py,sha256=x6yhf0JrgSNweFRJw7l3ZK8De4T76d2v6MRvoDU_C-U,3312
 langgraph_api/feature_flags.py,sha256=NB1X5jO19c40hI3WDxGk9qwD6EZUROO0ooFSd1QTniM,3985
-langgraph_api/graph.py,sha256=uQaC_yOWRFZIZwQt5WGdjnVW5iB0WaaBniUcUV82Y5Q,40594
+langgraph_api/graph.py,sha256=aWj1o4bYU2prIWpAVAWOH7CHbjvZKYfWV2CtF-hzPko,40697
 langgraph_api/http.py,sha256=7hPxKbj-xoAKcm7iucBpT5nM_hXOgGVCPbBsCD693Cw,6977
 langgraph_api/http_metrics.py,sha256=etxbZNmYxdb58DVLNkHP7S-N6njXPTiQh2OWKMaIZi8,5336
 langgraph_api/http_metrics_utils.py,sha256=sjxF7SYGTzY0Wz_G0dzatsYNnWr31S6ujej4JmBG2yo,866
 langgraph_api/logging.py,sha256=PeApafcPxox03rcpjEU5rlSzDkxJ3gff52XC34uZjl0,6972
-langgraph_api/metadata.py,sha256=OjFF_N4eoGjzCwsq7SS8aUVF39K1Jw2N1UBnpQ9f-X4,11681
+langgraph_api/metadata.py,sha256=j4FJvZRJP5tPi6uBcmLPaI4LrrhIZ7Df1ccoTYY_no4,11976
 langgraph_api/metrics_collector.py,sha256=ALUyirKew3uqtXVrCwpBc7wCM_viNhT13wZVMUVyva0,8495
 langgraph_api/metrics_otlp.py,sha256=JucxN4i4qn79jP4td0A_T6ycFpLP1G7GThvQTczfpAA,30850
 langgraph_api/operator_routes.py,sha256=s4HfkNUdMvgyYPb8L8yM3Z8UJQbGkJrVFMiH5HJp_S4,8389
@@ -32,13 +32,13 @@ langgraph_api/server.py,sha256=_DG7dCL2wtlaXdppTce2e0k8PunCcSRj79ncQfqmK_Q,10305
 langgraph_api/sse.py,sha256=cChZ7raQUHp8p5BreE_5wMBR8lFO0n7746sV8_HQOrc,4822
 langgraph_api/state.py,sha256=Py8HG8k7u0FRAj4Ok89_uR9GerkyeFm90gSMTbWWQX0,8356
 langgraph_api/store.py,sha256=OXcdQSVCDKOzfS8S2aJHXbfuI5iYRoQBiW9WYKnCyx8,7122
-langgraph_api/stream.py,sha256=SMrditrbTJ7QtKW-ThpYAPiVsQD-ot_tQeGJIp9PKGI,36519
+langgraph_api/stream.py,sha256=XnXqtf628r5EUltaV9JtKlka_40YO38kkYUNUTz4hcQ,36891
 langgraph_api/stream_v2.py,sha256=AieeCAXQsthy9n6crCibMB7unbN1W_o1xkpJ2v11RSY,10822
 langgraph_api/traceblock.py,sha256=GhgAtLhAQ8Z8LHtRQq3par-rfPpRBQp2Q7WBACJq1NI,677
 langgraph_api/tracing_session.py,sha256=gmfv-BW1XRar6suVur1P4rTVKWkjElDEb2hhkBduWOs,728
 langgraph_api/validation.py,sha256=_fmqjbETfsrc4KKJLtfhVjELD-1WzEVrK6G1pfDrmtk,14930
 langgraph_api/webhook.py,sha256=qXEtkE6orek2POeOQmPRsEarJgXIYp-LBrZB-OwITxc,9572
-langgraph_api/worker.py,sha256=o-gpQDRnAlNXnH5F69DOVQgI57nCPwt5oL2B22vrj_k,22058
+langgraph_api/worker.py,sha256=GjHJ1ig--xdCBg065W1JAfXSzgt3Ec-0iX7lbU31CIM,22457
 langgraph_api/worker_runtime.py,sha256=zzVW7A4vHyJE6DRxdjRZIa2U334Eh5oO157SyWmQ3G8,11861
 langgraph_api/_checkpointer/__init__.py,sha256=ofJTJLGy7Hsuzhj-2dpfDvrDloM0BzlhTzvZOdR9K8U,2223
 langgraph_api/_checkpointer/_adapter.py,sha256=idGYL-FwyVtUXcmhvfYboARfQAkoj0aFD40L5h9N7F8,22289
@@ -53,7 +53,7 @@ langgraph_api/api/openapi.py,sha256=hS4yhfJfWAYilm0Pv8iC08bK7CMDG4PIVc-77y9Y7Ts,
 langgraph_api/api/profile.py,sha256=CA1ZkHALOuP8orYTICnEhcG_JnnA2wnyjbWyeb117jA,3455
 langgraph_api/api/runs.py,sha256=0ogQnEQyKeVTuEUY6UD4KMShUA6Qq7_Zyp0Z70zGSzs,32577
 langgraph_api/api/store.py,sha256=5d1GOxsVDK-8PPngYG2rjYF_B2qNevDvPos-nB8YPCI,7710
-langgraph_api/api/threads.py,sha256=OQSoveEmKE-mErF4AbvivHpTexLE_BJ_raGDgH8YZ44,23031
+langgraph_api/api/threads.py,sha256=JT7TpAs7zJBokxzGl_DmUNEnfAVfTRdJRiLwuP4D1EM,22916
 langgraph_api/api/ui.py,sha256=A1cRxaMK_4pb192mrZ_LMxLSFb8NriYwwvjeDdNDD7k,2803
 langgraph_api/api/a2ui_schemas/README.md,sha256=fZCc9rSK-qeUHsbJ17EYxMZjS3yUrYQdoQLX7ltgP8M,298
 langgraph_api/api/a2ui_schemas/client_capabilities.json,sha256=3YAHlRfeOn9dUH6uAek1loCL4caeSUuQzhrtWKWW9nU,1906
@@ -100,15 +100,15 @@ langgraph_api/event_streaming/types.py,sha256=RyZqfqgH-jmmmmAFQj5f6nH9M1rGK93zVG
 langgraph_api/executor/__init__.py,sha256=mZBT8HSqe9pMlBpE7sw6DMI4ULB4xwNPWGkN9zp1B7k,302
 langgraph_api/executor/__main__.py,sha256=fKZs36-aLdXMZrRrXOneBJNV88maiNwuToRCIoyHzmQ,12091
 langgraph_api/grpc/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/grpc/client.py,sha256=ypSgZWclK7OCKLGW8gD_LZwwgsgQEahJqc8mBWF8Rug,15578
+langgraph_api/grpc/client.py,sha256=L-FM_NrfO-pJHIk71g-rbIcR10tzCzJPv9VOszZoIkc,16100
 langgraph_api/grpc/server.py,sha256=Fknr6BJbdSK38wF7B1vPDplK25KB_UfMB9Fp1er6DPU,8366
 langgraph_api/grpc/generated/core_api_pb2.pyi,sha256=0PEzVh8s6rqHq52ekhqPaMI_TOsP4_xuUUv9_XS7r1w,54758
 langgraph_api/grpc/ops/__init__.py,sha256=KQL4w0xjvkCVz4j770QQVuP7MQh6qPaTZnxlO3KmoiA,18754
 langgraph_api/grpc/ops/assistants.py,sha256=hLDZrAahpGSjzWNzr8nQidTW_4MoCR6sZy5VWB7oRxo,14080
 langgraph_api/grpc/ops/cache.py,sha256=MoPAmSuOwbt2Cud1YZJm_YJeaDHPFy1IiV4m0PDImgg,1399
 langgraph_api/grpc/ops/crons.py,sha256=aDlvNVYIfSP8gtr5NptLiAj-bfMtJOuMWYIA2NifWm0,19713
-langgraph_api/grpc/ops/runs.py,sha256=GPTNBqW97zX00MDeS1QtRaSB8bz8GZ_vfYRZxY7LEIg,44500
-langgraph_api/grpc/ops/threads.py,sha256=J0QUNZqHW-7ZHVgay1IbNUj5vTDv9iFcnJbZajvbqd4,51950
+langgraph_api/grpc/ops/runs.py,sha256=LM4tbxTUZM_HvTuBQ7AkhWa95Zza4jWw2ULcnNgeUoY,44747
+langgraph_api/grpc/ops/threads.py,sha256=4XPd4jzfKp77KY5BY6W0nbgXj2cK7wKY7uhON12zMUg,52153
 langgraph_api/grpc/servicers/__init__.py,sha256=l8yqTA_gMbIj0xHw5-RZYo0JbjL-EpFD8RxPMgW_-bA,422
 langgraph_api/grpc/servicers/checkpointer.py,sha256=kn9J3HQEmqggtOGiDxpEAeBVkVi4qDCJikj2bXo5k4g,10543
 langgraph_api/grpc/servicers/encryption.py,sha256=ddAjRZ9btWBf4MPa7yd793japdCEi-DfEPi1Ynt8gzk,10563
@@ -119,11 +119,11 @@ langgraph_api/js/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,
 langgraph_api/js/base.py,sha256=CJihwc51MwOVkis80f8zudRa1fQz_5jrom4rY8trww8,1133
 langgraph_api/js/build.mts,sha256=--Kfm4NKDhMljmv8fVvRR0VeUsBKiWch6qXpBoKmrvU,3445
 langgraph_api/js/client.http.mts,sha256=ARlTJURLJamgvyaPlBCYEAHFnXQnPpzzUXWKwXiebnw,6011
-langgraph_api/js/client.mts,sha256=vEXetaza6XmCH2lFyXueb-iYbrHhWrETf8UpZp5vdwM,40316
+langgraph_api/js/client.mts,sha256=oM3ctxVJ8YoxEDmjWAlZqVDv28k9TVUSD0dezsA58y0,41978
 langgraph_api/js/errors.py,sha256=Cm1TKWlUCwZReDC5AQ6SgNIVGD27Qov2xcgHyf8-GXo,361
-langgraph_api/js/global.d.ts,sha256=j4GhgtQSZ5_cHzjSPcHgMJ8tfBThxrH-pUOrrJGteOU,196
+langgraph_api/js/global.d.ts,sha256=LHCvS5NFvr0KKJUFzqIGL-CdBC4CgFIqif1im1r9xAg,237
 langgraph_api/js/package.json,sha256=e2FzqGICzYOtz3CsncKR8o4trBP6GMCZUU8RdbWMvSI,1372
-langgraph_api/js/remote.py,sha256=eYYbTmZprmNc5cF_qCrwQZ2LpTWUGAMVn84hS2--w60,53492
+langgraph_api/js/remote.py,sha256=WR2hss2HL2j3FMWqfUTqleK_LXGSCNets1LH6ub8xMQ,59394
 langgraph_api/js/schema.py,sha256=M4fLtr50O1jck8H1hm_0W4cZOGYGdkrB7riLyCes4oY,438
 langgraph_api/js/sse.py,sha256=IfcEpknyZeqqjYTOWRdijc6o2EBfatbWCZarGQQ0SQI,4088
 langgraph_api/js/traceblock.mts,sha256=QtGSN5VpzmGqDfbArrGXkMiONY94pMQ5CgzetT_bKYg,761
@@ -149,7 +149,7 @@ langgraph_api/middleware/http_logger.py,sha256=79iMlqKdSP5sS6G-iuEAHl2h0Z2ygYDxs
 langgraph_api/middleware/private_network.py,sha256=eQEzWI8epBNUCiNsMu9O27ofHBQ45M0p2OZy5YdUYos,2097
 langgraph_api/middleware/request_id.py,sha256=-p230Q5jDJAJLmSZRqQvB4dFFkJS9B4Vwg6pUgQtI24,1259
 langgraph_api/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-langgraph_api/models/run.py,sha256=MW7Q17G3veh3WCPwwyDVA9qkk-ih8MPo3QKqY-_Wyho,15795
+langgraph_api/models/run.py,sha256=XHlx9m3Odr61CGuHjNdAqJEU_B325rxRn-98AeAgV4M,15625
 langgraph_api/timing/__init__.py,sha256=UDMuNBmc5NqX0m5T-9PUFioCa1lNvd4Wv4juPIBRb-w,877
 langgraph_api/timing/profiler.py,sha256=_n0qJYJMjCGo95RDuH5z8FIzePGNSNbnm3cvGmcgn6A,6186
 langgraph_api/timing/startup.py,sha256=1Jp4-tquBhiE5glWQhXGX5XS2_006myJXHHZMOi15ng,6161
@@ -182,11 +182,11 @@ langgraph_runtime/store.py,sha256=7mowndlsIroGHv3NpTSOZDJR0lCuaYMBoTnTrewjslw,11
 LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
 hatch_build.py,sha256=Nn9N-EFfVqmH5q3iCUrhqX6zc7qT1jLI3gWSBN2xgYQ,1738
 logging.json,sha256=sBy8HDDPuucpLbLUD6e8t5fsiQjJoklZsbVHi2qQ7aQ,367
-openapi.json,sha256=-3ATf5OgeAsoctzGUcZRXFyPBAHz49VCNqKaWt8yvQc,228738
+openapi.json,sha256=AX8OyPP9M3JCJ4J09DU0KdmPxTTlHl12YLm8e-u7Fg4,229573
 langgraph_grpc_common/__init__.py,sha256=sO7jFHekQxt6zZPhTPZAWLYLB_S8w7-VuJ7NyWFlFNo,97
 langgraph_grpc_common/checkpointer.py,sha256=FwY4a4zIdRFy_Fw2jd_dxIhBpWBIMi5kJqye2VkzzUg,16505
 langgraph_grpc_common/serde.py,sha256=8q290nZ6TdxbEhCTzwEs44XGi2b-3pfrUeMYY5WGlTY,6179
-langgraph_grpc_common/store.py,sha256=ae34gPQS260oBh2hcNLzI7-c1xKMs6FVvsJExqFRbhk,4743
+langgraph_grpc_common/store.py,sha256=yyckUNGX9-2ZoU1XiuhPHpK600MNPUWV-NYoK1BUzHA,5063
 langgraph_grpc_common/conversion/__init__.py,sha256=pLsOrRtmF9YkgmCPhcfym6lYOB7PCJTRItyo1YK_AT8,208
 langgraph_grpc_common/conversion/_compat.py,sha256=MIEo69I7tfaPskunPGwBCKheksLwxpw-z-4O3hvO9og,4010
 langgraph_grpc_common/conversion/checkpoint.py,sha256=aBiQ_73PA4HUFFzgnJ9FKhWuqUhPHjyN9aPKrqd7LNs,13760
@@ -260,8 +260,8 @@ langgraph_grpc_common/proto/store_pb2.py,sha256=VWJ7wtzL9pVmZZKbxMzOzCoiFn58bB2g
 langgraph_grpc_common/proto/store_pb2.pyi,sha256=atXejijuYEb9tE0stGQdZcfA9ucMFj-ytTMwvkxwviM,29322
 langgraph_grpc_common/proto/store_pb2_grpc.py,sha256=Kyt8eV2NXkjh3be_BYytGdD19kNf74961cruonMvCrw,3300
 langgraph_grpc_common/proto/store_pb2_grpc.pyi,sha256=oS1h2cDoq2OjyM8xazcmc8LwRDC5oCAD0zto2QUmPQw,2027
-langgraph_api-0.18.0.dev10.dist-info/METADATA,sha256=p4UUfXDSWLBDQK7btVt4IGOL7teL42UEJs6_uJ2Hxpo,5940
-langgraph_api-0.18.0.dev10.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
-langgraph_api-0.18.0.dev10.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
-langgraph_api-0.18.0.dev10.dist-info/licenses/LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
-langgraph_api-0.18.0.dev10.dist-info/RECORD,,
+langgraph_api-0.18.0.dev12.dist-info/METADATA,sha256=R4amunHvob9GwNDTv0iaNt8y_qlFejxLKP_JLQDCL0s,5940
+langgraph_api-0.18.0.dev12.dist-info/WHEEL,sha256=W3fkpkm7-wf9vBI5Z-7s0eWkeM-spu78I8Neb98DeEg,87
+langgraph_api-0.18.0.dev12.dist-info/entry_points.txt,sha256=hGedv8n7cgi41PypMfinwS_HfCwA7xJIfS0jAp8htV8,78
+langgraph_api-0.18.0.dev12.dist-info/licenses/LICENSE,sha256=SCVQGLQfwOllsRFa9-Z3m8IYu4pnR9Vh2oANUCJiKqI,3860
+langgraph_api-0.18.0.dev12.dist-info/RECORD,,

langgraph_grpc_common/store.py

@@ -62,8 +62,15 @@ class GrpcStore(AsyncBatchedBaseStore):
         if self._stub is None:
             with self._channel_lock:
                 if self._stub is None:
-                    # Internal loopback to core-server; matches langgraph_api.grpc.client.
-                    self._channel = grpc.aio.insecure_channel(self._address)
+                    # Internal loopback to core-server, reconnecting as fast as
+                    # langgraph_api.grpc.client does (which explains the values).
+                    self._channel = grpc.aio.insecure_channel(
+                        self._address,
+                        options=[
+                            ("grpc.initial_reconnect_backoff_ms", 100),
+                            ("grpc.max_reconnect_backoff_ms", 1000),
+                        ],
+                    )
                     self._stub = StoreStub(self._channel)
         return self._stub
 

openapi.json

@@ -1666,6 +1666,28 @@
             },
             "name": "stream_modes",
             "in": "query"
+          },
+          {
+            "required": false,
+            "schema": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "enum": ["lifecycle", "run_modes", "state_update"]
+                },
+                {
+                  "type": "array",
+                  "items": {
+                    "type": "string",
+                    "enum": ["lifecycle", "run_modes", "state_update"]
+                  }
+                }
+              ],
+              "title": "Stream Mode",
+              "description": "Alias of `stream_modes`, the name the SDKs send. Ignored when `stream_modes` is set."
+            },
+            "name": "stream_mode",
+            "in": "query"
           }
         ],
         "responses": {
@@ -5308,7 +5330,8 @@
                     "updates",
                     "events",
                     "debug",
-                    "custom"
+                    "custom",
+                    "tools"
                   ]
                 },
                 "type": "array"
@@ -5324,7 +5347,8 @@
                   "updates",
                   "events",
                   "debug",
-                  "custom"
+                  "custom",
+                  "tools"
                 ]
               }
             ],
@@ -5506,7 +5530,8 @@
                     "updates",
                     "events",
                     "debug",
-                    "custom"
+                    "custom",
+                    "tools"
                   ]
                 },
                 "type": "array"
@@ -5522,7 +5547,8 @@
                   "updates",
                   "events",
                   "debug",
-                  "custom"
+                  "custom",
+                  "tools"
                 ]
               }
             ],