@langchain/langgraph-api 0.0.16 → 0.0.18

package/dist/api/threads.mjs

@@ -15,6 +15,9 @@ api.post("/threads", zValidator("json", schemas.ThreadCreate), async (c) => {
         metadata: payload.metadata,
         if_exists: payload.if_exists ?? "raise",
     });
+    if (payload.supersteps?.length) {
+        await Threads.State.bulk({ configurable: { thread_id: thread.thread_id } }, payload.supersteps);
+    }
     return jsonExtra(c, thread);
 });
 api.post("/threads/search", zValidator("json", schemas.ThreadSearchRequest), async (c) => {

package/dist/cli/entrypoint.mjs

@@ -37,5 +37,5 @@ logger.info(`Server running at ${host}`);
 let queryParams = `?baseUrl=http://${options.host}:${options.port}`;
 if (organizationId)
     queryParams += `&organizationId=${organizationId}`;
-asyncExitHook(cleanup, { wait: 1000 });
+asyncExitHook(cleanup, { wait: 3_000 });
 sendToParent?.({ queryParams });

package/dist/command.mjs

@@ -0,0 +1,15 @@
+import { Command, Send } from "@langchain/langgraph";
+export const getLangGraphCommand = (command) => {
+    let goto = command.goto != null && !Array.isArray(command.goto)
+        ? [command.goto]
+        : command.goto;
+    return new Command({
+        goto: goto?.map((item) => {
+            if (typeof item !== "string")
+                return new Send(item.node, item.input);
+            return item;
+        }),
+        update: command.update,
+        resume: command.resume,
+    });
+};

package/dist/graph/load.hooks.mjs

@@ -8,6 +8,7 @@ const OVERRIDE_RESOLVE = [
     new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
 ];
 let parentURL;
+let langgraphPackageURL;
 export async function initialize(args) {
     parentURL = args.parentURL;
 }
@@ -15,12 +16,37 @@ export async function resolve(specifier, context, nextResolve) {
     // HACK: @tailwindcss/node internally uses an ESM loader cache, which does not play nicely with `tsx`.
     //       Node.js crashes with "TypeError [ERR_INVALID_URL_SCHEME]: The URL must be of scheme file".
     //       As it already is a valid URI, we can just short-circuit the resolution and avoid `tsx`.
-    if (specifier.includes("@tailwindcss/node/dist/esm-cache.loader.mjs") &&
+    if (specifier.includes("@tailwindcss/node/dist/esm-cache.loader") &&
         specifier.startsWith("file://")) {
-        return { shortCircuit: true, url: specifier, format: "module" };
+        return {
+            shortCircuit: true,
+            // Node 18.x will for some reason attempt to load `.mts` instead of `.mjs`
+            url: specifier.replace(".mts", ".mjs"),
+            format: "module",
+        };
+    }
+    if (specifier === "@langchain/langgraph-checkpoint") {
+        // resolve relative to @langchain/langgraph package instead
+        // This is done to avoid adding a direct dependency on @langchain/langgraph-checkpoint
+        // in project, which if not present will cause `pnpm` to not find the package.
+        if (!langgraphPackageURL) {
+            const main = await nextResolve("@langchain/langgraph", {
+                ...context,
+                parentURL,
+            });
+            langgraphPackageURL = main.url.toString();
+        }
+        return await nextResolve(specifier, {
+            ...context,
+            parentURL: langgraphPackageURL,
+        });
     }
     if (OVERRIDE_RESOLVE.some((regex) => regex.test(specifier))) {
-        return await nextResolve(specifier, { ...context, parentURL });
+        const resolved = await nextResolve(specifier, { ...context, parentURL });
+        // If @langchain/langgraph is resolved first, cache it!
+        if (specifier === "@langchain/langgraph" && !langgraphPackageURL) {
+            langgraphPackageURL = resolved.url.toString();
+        }
     }
     return nextResolve(specifier, context);
 }

package/dist/schemas.mjs

@@ -140,35 +140,31 @@ export const Run = z.object({
     kwargs: z.object({}).catchall(z.any()),
     multitask_strategy: z.enum(["reject", "rollback", "interrupt", "enqueue"]),
 });
+export const CommandSchema = z.object({
+    goto: z
+        .union([
+        z.union([
+            z.string(),
+            z.object({ node: z.string(), input: z.unknown().optional() }),
+        ]),
+        z.array(z.union([
+            z.string(),
+            z.object({ node: z.string(), input: z.unknown().optional() }),
+        ])),
+    ])
+        .optional(),
+    update: z
+        .union([z.record(z.unknown()), z.array(z.tuple([z.string(), z.unknown()]))])
+        .optional(),
+    resume: z.unknown().optional(),
+});
 export const RunCreate = z
     .object({
     assistant_id: z.union([z.string().uuid(), z.string()]),
     checkpoint_id: z.string().optional(),
     checkpoint: CheckpointSchema.optional(),
     input: z.union([z.unknown(), z.null()]).optional(),
-    command: z
-        .object({
-        goto: z
-            .union([
-            z.union([
-                z.string(),
-                z.object({ node: z.string(), input: z.unknown().optional() }),
-            ]),
-            z.array(z.union([
-                z.string(),
-                z.object({ node: z.string(), input: z.unknown().optional() }),
-            ])),
-        ])
-            .optional(),
-        update: z
-            .union([
-            z.record(z.unknown()),
-            z.array(z.tuple([z.string(), z.unknown()])),
-        ])
-            .optional(),
-        resume: z.unknown().optional(),
-    })
-        .optional(),
+    command: CommandSchema.optional(),
     metadata: z
         .object({})
         .catchall(z.any())
@@ -301,6 +297,16 @@ export const Thread = z.object({
 });
 export const ThreadCreate = z
     .object({
+    supersteps: z
+        .array(z.object({
+        updates: z.array(z.object({
+            values: z.unknown().nullish(),
+            command: CommandSchema.nullish(),
+            as_node: z.string(),
+        })),
+    }))
+        .describe("The supersteps to apply to the thread.")
+        .optional(),
     thread_id: z
         .string()
         .uuid()

package/dist/storage/ops.mjs

@@ -6,6 +6,7 @@ import { store } from "./store.mjs";
 import { logger } from "../logging.mjs";
 import { serializeError } from "../utils/serde.mjs";
 import { FileSystemPersistence } from "./persist.mjs";
+import { getLangGraphCommand } from "../command.mjs";
 export const conn = new FileSystemPersistence(".langgraphjs_ops.json", () => ({
     runs: {},
     threads: {},
@@ -487,6 +488,41 @@ export class Threads {
             });
             return { checkpoint: nextConfig.configurable };
         }
+        static async bulk(config, supersteps) {
+            const threadId = config.configurable?.thread_id;
+            if (!threadId)
+                return [];
+            const thread = await Threads.get(threadId);
+            const graphId = thread.metadata?.graph_id;
+            if (graphId == null) {
+                throw new HTTPException(400, {
+                    message: `Thread ${threadId} has no graph ID`,
+                });
+            }
+            config.configurable ??= {};
+            config.configurable.graph_id ??= graphId;
+            const graph = await getGraph(graphId, { checkpointer, store });
+            const updateConfig = structuredClone(config);
+            updateConfig.configurable ??= {};
+            updateConfig.configurable.checkpoint_ns ??= "";
+            const nextConfig = await graph.bulkUpdateState(updateConfig, supersteps.map((i) => ({
+                updates: i.updates.map((j) => ({
+                    values: j.command != null ? getLangGraphCommand(j.command) : j.values,
+                    asNode: j.as_node,
+                })),
+            })));
+            const state = await Threads.State.get(config, { subgraphs: false });
+            // update thread values
+            await conn.with(async (STORE) => {
+                for (const thread of Object.values(STORE.threads)) {
+                    if (thread.thread_id === threadId) {
+                        thread.values = state.values;
+                        break;
+                    }
+                }
+            });
+            return { checkpoint: nextConfig.configurable };
+        }
         static async list(config, options) {
             const threadId = config.configurable?.thread_id;
             if (!threadId)
@@ -513,7 +549,7 @@ export class Threads {
 }
 export class Runs {
     static async *next() {
-        yield* conn.withGenerator(async function* (STORE) {
+        yield* conn.withGenerator(async function* (STORE, options) {
             const now = new Date();
             const pendingRuns = Object.values(STORE.runs)
                 .filter((run) => run.status === "pending" && run.created_at < now)
@@ -533,6 +569,7 @@ export class Runs {
                     continue;
                 try {
                     const signal = StreamManager.lock(runId);
+                    options.schedulePersist();
                     STORE.retry_counter[runId] ??= 0;
                     STORE.retry_counter[runId] += 1;
                     yield { run, attempt: STORE.retry_counter[runId], signal };

package/dist/storage/persist.mjs

@@ -67,12 +67,15 @@ export class FileSystemPersistence {
         if (this.filepath == null || this.data == null) {
             throw new Error(`${this.name} not initialized`);
         }
+        let shouldPersist = false;
+        let schedulePersist = () => void (shouldPersist = true);
         try {
-            const gen = typeof fn === "function" ? fn(this.data) : fn;
+            const gen = typeof fn === "function" ? fn(this.data, { schedulePersist }) : fn;
             yield* gen;
         }
         finally {
-            this.schedulePersist();
+            if (shouldPersist)
+                this.schedulePersist();
         }
     }
 }

package/dist/stream.mjs

@@ -1,22 +1,8 @@
 import { getGraph } from "./graph/load.mjs";
 import { Client as LangSmithClient } from "langsmith";
-import { Command, Send, } from "@langchain/langgraph";
 import { runnableConfigToCheckpoint, taskRunnableConfigToCheckpoint, } from "./utils/runnableConfig.mjs";
-import { BaseMessageChunk, isBaseMessage } from "@langchain/core/messages";
-const getLangGraphCommand = (command) => {
-    let goto = command.goto != null && !Array.isArray(command.goto)
-        ? [command.goto]
-        : command.goto;
-    return new Command({
-        goto: goto?.map((item) => {
-            if (typeof item !== "string")
-                return new Send(item.node, item.input);
-            return item;
-        }),
-        update: command.update,
-        resume: command.resume,
-    });
-};
+import { isBaseMessage } from "@langchain/core/messages";
+import { getLangGraphCommand } from "./command.mjs";
 const isRunnableConfig = (config) => {
     if (typeof config !== "object" || config == null)
         return false;

package/dist/ui/bundler.d.mts

@@ -1,9 +1,15 @@
 import { type BuildOptions } from "esbuild";
-export declare function build(agentName: string, uiUserPath: string): Promise<{
+export declare function build(agentName: string, args: {
+    cwd: string;
+    userPath: string;
+}): Promise<{
     basename: string;
     contents: Uint8Array;
 }[]>;
-export declare function watch(agentName: string, uiUserPath: string, onResult: (result: {
+export declare function watch(agentName: string, args: {
+    cwd: string;
+    userPath: string;
+}, onResult: (result: {
     basename: string;
     contents: Uint8Array;
 }[]) => void): Promise<import("esbuild").BuildContext<BuildOptions>>;

package/dist/ui/bundler.mjs

@@ -4,19 +4,27 @@ import * as fs from "node:fs";
 import { build as runBuild, context as runContext, } from "esbuild";
 import tailwind from "esbuild-plugin-tailwindcss";
 const renderTemplate = await fs.promises.readFile(url.fileURLToPath(new URL("./render.template.mts", import.meta.url)), "utf-8");
-function entrypointPlugin(uiUserPath) {
-    const projectDir = path.dirname(uiUserPath);
+function entrypointPlugin(paths) {
+    const fullPath = path.resolve(paths.cwd, paths.userPath);
+    let relativeUiPath = path
+        .relative(paths.cwd, fullPath)
+        .replaceAll(path.sep, "/");
+    if (relativeUiPath.startsWith("../")) {
+        throw new Error(`UI path must be relative to the project root. Received: "${relativeUiPath}"`);
+    }
+    if (!relativeUiPath.startsWith("./"))
+        relativeUiPath = `./${relativeUiPath}`;
     return {
         name: "entrypoint",
         setup(build) {
-            build.onResolve({ filter: /^entrypoint$/ }, (args) => ({
-                path: path.resolve(projectDir, "ui.entrypoint.tsx"),
+            build.onResolve({ filter: /^entrypoint$/ }, () => ({
+                path: path.resolve(path.dirname(fullPath), "ui.entrypoint.tsx"),
                 namespace: "entrypoint-ns",
             }));
             build.onLoad({ filter: /.*/, namespace: "entrypoint-ns" }, () => ({
-                resolveDir: projectDir,
+                resolveDir: paths.cwd,
                 contents: [
-                    `import ui from "${uiUserPath}"`,
+                    `import ui from "${relativeUiPath}"`,
                     renderTemplate,
                     `export const render = createRenderer(ui)`,
                 ].join("\n"),
@@ -46,10 +54,10 @@ function registerPlugin(onEnd) {
         },
     };
 }
-function setup(agentName, uiUserPath, onResult) {
+function setup(agentName, args, onResult) {
     return {
         write: false,
-        outdir: path.resolve(path.dirname(uiUserPath), "dist"),
+        outdir: path.resolve(args.cwd, "dist"),
         entryPoints: ["entrypoint"],
         bundle: true,
         platform: "browser",
@@ -61,21 +69,17 @@ function setup(agentName, uiUserPath, onResult) {
             "@langchain/langgraph-sdk",
             "@langchain/langgraph-sdk/react-ui",
         ],
-        plugins: [
-            tailwind(),
-            entrypointPlugin(uiUserPath),
-            registerPlugin(onResult),
-        ],
+        plugins: [tailwind(), entrypointPlugin(args), registerPlugin(onResult)],
         globalName: `__LGUI_${agentName}`,
     };
 }
-export async function build(agentName, uiUserPath) {
+export async function build(agentName, args) {
     let results = [];
-    await runBuild(setup(agentName, uiUserPath, (result) => (results = result)));
+    await runBuild(setup(agentName, args, (result) => (results = result)));
     return results;
 }
-export async function watch(agentName, uiUserPath, onResult) {
-    const ctx = await runContext(setup(agentName, uiUserPath, onResult));
+export async function watch(agentName, args, onResult) {
+    const ctx = await runContext(setup(agentName, args, onResult));
     await ctx.watch();
     return ctx;
 }

package/dist/ui/load.mjs

@@ -6,9 +6,8 @@ import * as path from "node:path";
 import { watch } from "./bundler.mjs";
 const GRAPH_UI = {};
 export async function registerGraphUi(defs, options) {
-    const result = await Promise.all(Object.entries(defs).map(async ([agentName, uiUserPath]) => {
-        const userPath = path.resolve(options.cwd, uiUserPath);
-        const ctx = await watch(agentName, userPath, (result) => {
+    const result = await Promise.all(Object.entries(defs).map(async ([agentName, userPath]) => {
+        const ctx = await watch(agentName, { cwd: options.cwd, userPath }, (result) => {
             GRAPH_UI[agentName] = result;
         });
         return [agentName, ctx];

package/dist/utils/hono.mjs

@@ -1,6 +1,5 @@
 import { serialiseAsDict } from "./serde.mjs";
 import { stream } from "hono/streaming";
-import { StreamingApi } from "hono/utils/stream";
 export function jsonExtra(c, object) {
     return new Response(serialiseAsDict(object), {
         ...c.res,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.16",
+  "version": "0.0.18",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -47,13 +47,13 @@
     "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "@langchain/core": "^0.3.40",
-    "@langchain/langgraph": "^0.2.49",
-    "@langchain/langgraph-checkpoint": "^0.0.15",
+    "@langchain/core": "^0.3.42",
+    "@langchain/langgraph": "^0.2.57",
+    "@langchain/langgraph-checkpoint": "^0.0.16",
     "typescript": "^5.5.4"
   },
   "devDependencies": {
-    "@langchain/langgraph-sdk": "^0.0.33",
+    "@langchain/langgraph-sdk": "^0.0.60",
     "@types/babel__code-frame": "^7.0.6",
     "@types/react": "^19.0.8",
     "@types/react-dom": "^19.0.3",