langgraph-api 0.18.0.dev11__tar.gz → 0.18.0.dev12__tar.gz

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: langgraph-api
-Version: 0.18.0.dev11
+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

langgraph_api-0.18.0.dev12/langgraph_api/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.18.0.dev12"

{langgraph_api-0.18.0.dev11 → langgraph_api-0.18.0.dev12}/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-0.18.0.dev11 → langgraph_api-0.18.0.dev12}/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-0.18.0.dev11 → langgraph_api-0.18.0.dev12}/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-0.18.0.dev11 → langgraph_api-0.18.0.dev12}/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-0.18.0.dev11 → langgraph_api-0.18.0.dev12}/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;
   }
 }