langgraph-api 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

langgraph_api/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.15"
+__version__ = "0.1.17"

langgraph_api/config.py

@@ -18,6 +18,11 @@ class CorsConfig(TypedDict, total=False):
     max_age: int
 
 
+class ConfigurableHeaders(TypedDict):
+    includes: list[str] | None
+    excludes: list[str] | None
+
+
 class HttpConfig(TypedDict, total=False):
     app: str
     """Import path for a custom Starlette/FastAPI app to mount"""
@@ -39,6 +44,7 @@ class HttpConfig(TypedDict, total=False):
     """Disable /mcp routes"""
     mount_prefix: str
     """Prefix for mounted routes. E.g., "/my-deployment/api"."""
+    configurable_headers: ConfigurableHeaders | None
 
 
 class ThreadTTLConfig(TypedDict, total=False):

langgraph_api/graph.py

@@ -487,7 +487,7 @@ def _graph_from_spec(spec: GraphSpec) -> GraphValue:
     return graph
 
 
-@functools.lru_cache
+@functools.lru_cache(maxsize=1)
 def _get_init_embeddings() -> Callable[[str, ...], "Embeddings"] | None:
     try:
         from langchain.embeddings import init_embeddings

langgraph_api/js/base.py

@@ -27,3 +27,6 @@ class BaseRemotePregel(Runnable):
 
     # Config passed from get_graph()
     config: Config
+
+    async def get_nodes_executed(self) -> int:
+        return 0

langgraph_api/js/build.mts

@@ -1,26 +1,49 @@
 /// <reference types="./global.d.ts" />
+import "./src/preload.mjs";
 
 import { z } from "zod";
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import {
-  GraphSchema,
+  type GraphSchema,
   resolveGraph,
   runGraphSchemaWorker,
 } from "./src/graph.mts";
 import { build } from "@langchain/langgraph-ui";
+import { checkLangGraphSemver } from "@langchain/langgraph-api/semver";
 import { filterValidExportPath } from "./src/utils/files.mts";
 
 const __dirname = new URL(".", import.meta.url).pathname;
 
 async function main() {
   const specs = Object.entries(
-    z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS))
+    z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS)),
   ).filter(([_, spec]) => filterValidExportPath(spec));
 
   const GRAPH_SCHEMAS: Record<string, Record<string, GraphSchema> | false> = {};
-  let failed = false;
 
+  const semver = await checkLangGraphSemver();
+  const invalidPackages = semver.filter(
+    (s) => !s.satisfies && s.version !== "0.0.0",
+  );
+  if (invalidPackages.length > 0) {
+    console.error(
+      `Some LangGraph.js dependencies required by the LangGraph API server are not up to date. \n` +
+        `Please make sure to upgrade them to the required version:\n` +
+        invalidPackages
+          .map(
+            (i) =>
+              `- ${i.name}@${i.version} is not up to date. Required: ${i.required}`,
+          )
+          .join("\n") +
+        "\n" +
+        "Visit https://langchain-ai.github.io/langgraphjs/cloud/deployment/setup_javascript/ for more information.",
+    );
+
+    process.exit(1);
+  }
+
+  let failed = false;
   try {
     await Promise.all(
       specs.map(async ([graphId, rawSpec]) => {
@@ -38,13 +61,13 @@ async function main() {
           console.error(`[${graphId}]: Error extracting schema: ${error}`);
           GRAPH_SCHEMAS[graphId] = false;
         }
-      })
+      }),
     );
 
     await fs.writeFile(
       path.resolve(__dirname, "client.schemas.json"),
       JSON.stringify(GRAPH_SCHEMAS),
-      { encoding: "utf-8" }
+      { encoding: "utf-8" },
     );
   } catch (error) {
     console.error(`Error resolving graphs: ${error}`);

langgraph_api/js/client.mts

@@ -76,7 +76,7 @@ const logger = createLogger({
       }
 
       return JSON.stringify({ timestamp, level, event, ...rest });
-    })
+    }),
   ),
   transports: [
     new transports.Console({
@@ -91,6 +91,20 @@ let GRAPH_OPTIONS: {
   checkpointer?: BaseCheckpointSaver<string | number>;
   store?: BaseStore;
 } = {};
+let nodesExecuted = 0;
+function incrementNodes() {
+  nodesExecuted++;
+}
+
+const version = await (async () => {
+  try {
+    const packageJson = await import("@langchain/langgraph/package.json");
+    return packageJson["version"];
+  } catch (error) {
+    logger.error(error);
+  }
+  return undefined;
+})();
 
 const GRAPH_RESOLVED: Record<
   string,
@@ -101,7 +115,7 @@ const GRAPH_SPEC: Record<string, GraphSpec> = {};
 async function getGraph(
   graphId: string,
   config: { configurable?: Record<string, unknown> },
-  name: string | null | undefined
+  name: string | null | undefined,
 ) {
   if (!GRAPH_RESOLVED[graphId])
     throw new HTTPException(404, { message: `Graph "${graphId}" not found` });
@@ -145,7 +159,7 @@ async function getOrExtractSchema(graphId: string) {
       try {
         timeoutMs = Number.parseInt(
           process.env.LANGGRAPH_SCHEMA_RESOLVE_TIMEOUT_MS || "30000",
-          10
+          10,
         );
         if (Number.isNaN(timeoutMs) || timeoutMs <= 0) timeoutMs = undefined;
       } catch {
@@ -178,7 +192,7 @@ const RunnableConfigSchema = z.object({
 });
 
 const getRunnableConfig = (
-  userConfig: z.infer<typeof RunnableConfigSchema> | null | undefined
+  userConfig: z.infer<typeof RunnableConfigSchema> | null | undefined,
 ) => {
   if (!userConfig) return {};
   return {
@@ -214,13 +228,13 @@ function tryFetch(...args: Parameters<typeof fetch>) {
       factor: 2,
       minTimeout: 1000,
       onFailedAttempt: (error) => void logger.error(error),
-    }
+    },
   );
 }
 
 async function sendRecv<T = any>(
   method: `${"checkpointer" | "store"}_${string}`,
-  data: unknown
+  data: unknown,
 ): Promise<T> {
   const res = await tryFetch(`http://localhost:${REMOTE_PORT}/${method}`, {
     method: "POST",
@@ -240,7 +254,7 @@ const HEARTBEAT_MS = 5_000;
 const handleInvoke = <T extends z.ZodType<any>>(
   name: string,
   _schema: T,
-  handler: (rawPayload: z.infer<T>) => Promise<any>
+  handler: (rawPayload: z.infer<T>) => Promise<any>,
 ) => {
   return async (c: Context<any, any, { in: z.infer<T>; out: any }>) => {
     const graphId = c.req.param("graphId");
@@ -262,7 +276,7 @@ const handleInvoke = <T extends z.ZodType<any>>(
       let interval = setInterval(() => enqueueWrite(" "), HEARTBEAT_MS);
 
       const response = JSON.stringify(
-        await handler({ graph_id: graphId, ...body })
+        await handler({ graph_id: graphId, ...body }),
       );
 
       clearInterval(interval);
@@ -274,7 +288,7 @@ 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>) => AsyncGenerator<any, void, unknown>,
 ) => {
   return (c: Context<any, any, { in: z.infer<T>; out: any }>) => {
     const graphId = c.req.param("graphId");
@@ -333,7 +347,7 @@ class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
       limit?: number;
       before?: RunnableConfig;
       filter?: Record<string, any>;
-    }
+    },
   ): AsyncGenerator<CheckpointTuple> {
     const result = await sendRecv("checkpointer_list", { config, ...options });
 
@@ -352,7 +366,7 @@ class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
     config: RunnableConfig,
     checkpoint: Checkpoint,
     metadata: CheckpointMetadata,
-    newVersions: ChannelVersions
+    newVersions: ChannelVersions,
   ): Promise<RunnableConfig> {
     return await sendRecv<RunnableConfig>("checkpointer_put", {
       config,
@@ -365,14 +379,14 @@ class RemoteCheckpointer extends BaseCheckpointSaver<number | string> {
   async putWrites(
     config: RunnableConfig,
     writes: [string, unknown][],
-    taskId: string
+    taskId: string,
   ): Promise<void> {
     await sendRecv("checkpointer_put_writes", { config, writes, taskId });
   }
 
   getNextVersion(
     current: number | string | undefined,
-    _channel: ChannelProtocol
+    _channel: ChannelProtocol,
   ): string {
     let currentVersion = 0;
 
@@ -402,7 +416,7 @@ function camelToSnake(operation: Operation) {
       Object.entries(obj).map(([key, value]) => {
         const snakeKey = key.replace(
           /[A-Z]/g,
-          (letter) => `_${letter.toLowerCase()}`
+          (letter) => `_${letter.toLowerCase()}`,
         );
         if (
           typeof value === "object" &&
@@ -412,7 +426,7 @@ function camelToSnake(operation: Operation) {
           return [snakeKey, snakeCaseKeys(value)];
         }
         return [snakeKey, value];
-      })
+      }),
     );
   };
 
@@ -459,7 +473,7 @@ function pyItemToJs(item?: PyItem): Item | undefined {
 
 export class RemoteStore extends BaseStore {
   async batch<Op extends Operation[]>(
-    operations: Op
+    operations: Op,
   ): Promise<OperationResults<Op>> {
     const results = await sendRecv<PyResult[]>("store_batch", {
       operations: operations.map(camelToSnake),
@@ -493,7 +507,7 @@ export class RemoteStore extends BaseStore {
       filter?: Record<string, any>;
       limit?: number;
       offset?: number;
-    }
+    },
   ): Promise<Item[]> {
     return await sendRecv<Item[]>("store_search", {
       namespace_prefix: namespacePrefix,
@@ -504,7 +518,7 @@ export class RemoteStore extends BaseStore {
   async put(
     namespace: string[],
     key: string,
-    value: Record<string, any>
+    value: Record<string, any>,
   ): Promise<void> {
     await sendRecv("store_put", { namespace, key, value });
   }
@@ -522,7 +536,7 @@ export class RemoteStore extends BaseStore {
   }): Promise<string[][]> {
     const data = await sendRecv<{ namespaces: string[][] }>(
       "store_list_namespaces",
-      { max_depth: options?.maxDepth, ...options }
+      { max_depth: options?.maxDepth, ...options },
     );
     return data.namespaces;
   }
@@ -569,7 +583,7 @@ const StreamEventsPayload = z.object({
 });
 
 function reviveCommand(
-  command: z.infer<typeof StreamEventsPayload>["command"]
+  command: z.infer<typeof StreamEventsPayload>["command"],
 ): Command | undefined {
   if (command == null) return undefined;
   let { goto, update, resume, graph } = command;
@@ -589,12 +603,17 @@ function reviveCommand(
 }
 
 async function* streamEventsRequest(
-  rawPayload: z.infer<typeof StreamEventsPayload>
+  rawPayload: z.infer<typeof StreamEventsPayload>,
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const config = getRunnableConfig(payload.config);
   const graph = await getGraph(graphId, config, payload.graph_name);
   const input = reviveCommand(payload.command) ?? payload.input;
+  // TODO Check if it's a remote graph and don't set in that case
+  config.configurable = {
+    ...config.configurable,
+    ["__pregel_node_finished"]: incrementNodes,
+  };
 
   const userStreamMode =
     payload.stream_mode == null
@@ -635,6 +654,11 @@ async function* streamEventsRequest(
 
   const streamMode = [...graphStreamMode];
 
+  if (version != null) {
+    config.metadata ??= {};
+    config.metadata.langgraph_version = version;
+  }
+
   for await (const data of graph.streamEvents(input, {
     ...config,
     version: "v2",
@@ -731,7 +755,7 @@ async function getGraphRequest(rawPayload: z.infer<typeof GetGraphPayload>) {
   const graph = await getGraph(
     graphId,
     getRunnableConfig(payload.graph_config),
-    payload.graph_name
+    payload.graph_name,
   );
 
   const drawable = await graph.getGraphAsync({
@@ -750,7 +774,7 @@ const GetSubgraphsPayload = z.object({
 });
 
 async function getSubgraphsRequest(
-  rawPayload: z.infer<typeof GetSubgraphsPayload>
+  rawPayload: z.infer<typeof GetSubgraphsPayload>,
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const graphConfig = getRunnableConfig(payload.graph_config);
@@ -764,7 +788,7 @@ async function getSubgraphsRequest(
 
   for await (const [name] of graph.getSubgraphsAsync(
     payload.namespace ?? undefined,
-    payload.recurse ?? undefined
+    payload.recurse ?? undefined,
   )) {
     const schema =
       graphSchema[`${rootGraphId}|${name}`] || graphSchema[rootGraphId];
@@ -806,7 +830,7 @@ const UpdateStatePayload = z.object({
 });
 
 async function updateStateRequest(
-  rawPayload: z.infer<typeof UpdateStatePayload>
+  rawPayload: z.infer<typeof UpdateStatePayload>,
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const graphConfig = getRunnableConfig(payload.graph_config);
@@ -815,7 +839,7 @@ async function updateStateRequest(
   const config = await graph.updateState(
     getRunnableConfig(payload.config),
     payload.values,
-    payload.as_node ?? undefined
+    payload.as_node ?? undefined,
   );
 
   return config;
@@ -850,7 +874,7 @@ const GetStateHistoryPayload = z.object({
 });
 
 async function* getStateHistoryRequest(
-  rawPayload: z.infer<typeof GetStateHistoryPayload>
+  rawPayload: z.infer<typeof GetStateHistoryPayload>,
 ) {
   const { graph_id: graphId, ...payload } = rawPayload;
   const config = getRunnableConfig(payload.graph_config);
@@ -862,7 +886,7 @@ async function* getStateHistoryRequest(
       limit: payload.limit ?? undefined,
       before: payload.before ? getRunnableConfig(payload.before) : undefined,
       filter: payload.filter ?? undefined,
-    }
+    },
   )) {
     yield item;
   }
@@ -879,7 +903,9 @@ async function main() {
   };
 
   const specs = Object.entries(
-    z.record(z.string()).parse(JSON.parse(process.env.LANGSERVE_GRAPHS ?? "{}"))
+    z
+      .record(z.string())
+      .parse(JSON.parse(process.env.LANGSERVE_GRAPHS ?? "{}")),
   ).filter(([_, spec]) => filterValidExportPath(spec));
 
   if (!process.argv.includes("--skip-schema-cache")) {
@@ -887,7 +913,7 @@ async function main() {
       GRAPH_SCHEMA = JSON.parse(
         await fs.readFile(path.resolve(__dirname, "client.schemas.json"), {
           encoding: "utf-8",
-        })
+        }),
       );
     } catch {
       // pass
@@ -901,43 +927,43 @@ async function main() {
 
       GRAPH_RESOLVED[graphId] = resolved;
       GRAPH_SPEC[graphId] = spec;
-    })
+    }),
   );
 
   app.post(
     "/:graphId/streamEvents",
     zValidator("json", StreamEventsPayload),
-    handleStream("streamEvents", StreamEventsPayload, streamEventsRequest)
+    handleStream("streamEvents", StreamEventsPayload, streamEventsRequest),
   );
 
   app.post(
     "/:graphId/getGraph",
     zValidator("json", GetGraphPayload),
-    handleInvoke("getGraph", GetGraphPayload, getGraphRequest)
+    handleInvoke("getGraph", GetGraphPayload, getGraphRequest),
   );
 
   app.post(
     "/:graphId/getSubgraphs",
     zValidator("json", GetSubgraphsPayload),
-    handleInvoke("getSubgraphs", GetSubgraphsPayload, getSubgraphsRequest)
+    handleInvoke("getSubgraphs", GetSubgraphsPayload, getSubgraphsRequest),
   );
 
   app.post(
     "/:graphId/getState",
     zValidator("json", GetStatePayload),
-    handleInvoke("getState", GetStatePayload, getStateRequest)
+    handleInvoke("getState", GetStatePayload, getStateRequest),
   );
 
   app.post(
     "/:graphId/updateState",
     zValidator("json", UpdateStatePayload),
-    handleInvoke("updateState", UpdateStatePayload, updateStateRequest)
+    handleInvoke("updateState", UpdateStatePayload, updateStateRequest),
   );
 
   app.post(
     "/:graphId/getSchema",
     zValidator("json", GetSchemaPayload),
-    handleInvoke("getSchema", GetSchemaPayload, getSchemaRequest)
+    handleInvoke("getSchema", GetSchemaPayload, getSchemaRequest),
   );
 
   app.post(
@@ -946,8 +972,26 @@ async function main() {
     handleStream(
       "getStateHistory",
       GetStateHistoryPayload,
-      getStateHistoryRequest
-    )
+      getStateHistoryRequest,
+    ),
+  );
+  app.post(
+    "/:graphId/getNodesExecuted",
+    zValidator("json", GetNodesExecutedPayload),
+    handleInvoke(
+      "getNodesExecuted",
+      GetNodesExecutedPayload,
+      getNodesExecutedRequest,
+    ),
+  );
+  app.post(
+    "/:graphId/getNodesExecuted",
+    zValidator("json", GetNodesExecutedPayload),
+    handleInvoke(
+      "getNodesExecuted",
+      GetNodesExecutedPayload,
+      getNodesExecutedRequest,
+    ),
   );
 
   // Load LANGGRAPH_AUTH
@@ -972,7 +1016,7 @@ async function main() {
         headers.delete("x-langgraph-auth-method");
 
         const context = await authenticate(
-          new Request(authUrl, { headers, method })
+          new Request(authUrl, { headers, method }),
         );
 
         return c.json(context);
@@ -984,7 +1028,7 @@ async function main() {
               status: error.res?.status ?? error.status,
               headers: error.res?.headers,
             },
-            error.status as StatusCode
+            error.status as StatusCode,
           );
         }
 
@@ -1018,7 +1062,7 @@ async function main() {
   });
 
   serve({ fetch: app.fetch, hostname: "localhost", port: GRAPH_PORT }, (c) =>
-    logger.info(`Listening to ${c.address}:${c.port}`)
+    logger.info(`Listening to ${c.address}:${c.port}`),
   );
 }
 
@@ -1027,5 +1071,17 @@ process.on("uncaughtExceptionMonitor", (error) => {
   gracefulExit();
 });
 
+const GetNodesExecutedPayload = z.object({
+  graph_id: z.string(),
+});
+
+async function getNodesExecutedRequest(
+  _payload: z.infer<typeof GetNodesExecutedPayload>,
+) {
+  const value = nodesExecuted;
+  nodesExecuted = 0;
+  return { nodesExecuted: value };
+}
+
 asyncExitHook(() => awaitAllCallbacks(), { wait: 3_000 });
 main();

langgraph_api/js/package.json

@@ -24,8 +24,8 @@
     "undici": "^6.21.1",
     "uuid": "^10.0.0",
     "winston": "^3.17.0",
-    "@langchain/langgraph-api": "~0.0.21",
-    "@langchain/langgraph-ui": "~0.0.21",
+    "@langchain/langgraph-api": "~0.0.29",
+    "@langchain/langgraph-ui": "~0.0.29",
     "zod": "^3.23.8"
   },
   "resolutions": {

langgraph_api/js/remote.py

@@ -315,26 +315,30 @@ class RemotePregel(BaseRemotePregel):
         *,
         xray: int | bool = False,
     ) -> dict[str, Any]:
-        raise Exception("Not implemented")
+        raise NotImplementedError()
 
     def get_input_schema(self, config: RunnableConfig | None = None) -> type[BaseModel]:
-        raise Exception("Not implemented")
+        raise NotImplementedError()
 
     def get_output_schema(
         self, config: RunnableConfig | None = None
     ) -> type[BaseModel]:
-        raise Exception("Not implemented")
+        raise NotImplementedError()
 
     def config_schema(self) -> type[BaseModel]:
-        raise Exception("Not implemented")
+        raise NotImplementedError()
 
     async def invoke(self, input: Any, config: RunnableConfig | None = None):
-        raise Exception("Not implemented")
+        raise NotImplementedError()
 
     def copy(self, update: dict[str, Any] | None = None) -> Self:
         attrs = {**self.__dict__, **(update or {})}
         return self.__class__(**attrs)
 
+    async def fetch_nodes_executed(self):
+        result = await _client_invoke("getNodesExecuted", {"graph_id": self.graph_id})
+        return result["nodesExecuted"]
+
 
 async def run_js_process(paths_str: str, watch: bool = False):
     # check if tsx is available
@@ -346,9 +350,22 @@ async def run_js_process(paths_str: str, watch: bool = False):
     attempt = 0
     while not asyncio.current_task().cancelled():
         client_file = os.path.join(os.path.dirname(__file__), "client.mts")
-        args = ("tsx", client_file)
-        if watch:
-            args = ("tsx", "watch", client_file, "--skip-schema-cache")
+        client_preload_file = os.path.join(
+            os.path.dirname(__file__), "src", "preload.mjs"
+        )
+
+        args = (
+            (
+                "tsx",
+                "watch",
+                "--import",
+                client_preload_file,
+                client_file,
+                "--skip-schema-cache",
+            )
+            if watch
+            else ("tsx", "--import", client_preload_file, client_file)
+        )
         try:
             process = await asyncio.create_subprocess_exec(
                 *args,
@@ -843,12 +860,14 @@ async def handle_js_auth_event(
                 "resource": ctx.resource,
                 "action": ctx.action,
                 "value": value,
-                "context": {
-                    "user": cast(DotDict, ctx.user).dict(),
-                    "scopes": ctx.permissions,
-                }
-                if ctx
-                else None,
+                "context": (
+                    {
+                        "user": cast(DotDict, ctx.user).dict(),
+                        "scopes": ctx.permissions,
+                    }
+                    if ctx
+                    else None
+                ),
             }
         ),
     )

langgraph_api/js/src/graph.mts

@@ -5,9 +5,6 @@ import type { CompiledGraph, Graph } from "@langchain/langgraph";
 import * as path from "node:path";
 import type { JSONSchema7 } from "json-schema";
 
-// enforce API @langchain/langgraph precedence
-register("./hooks.mjs", import.meta.url);
-
 export interface GraphSchema {
   state: JSONSchema7 | undefined;
   input: JSONSchema7 | undefined;