@langchain/langgraph-api 0.0.34 → 0.0.36

package/dist/api/runs.mjs

@@ -75,6 +75,7 @@ const createValidRun = async (threadId, payload, kwargs) => {
         feedback_keys: feedbackKeys,
         temporary: threadId == null && (run.on_completion ?? "delete") === "delete",
         subgraphs: run.stream_subgraphs ?? false,
+        resumable: run.stream_resumable ?? false,
     }, {
         threadId,
         userId,
@@ -139,7 +140,11 @@ api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
         try {
-            for await (const { event, data } of Runs.Stream.join(run.run_id, undefined, { cancelOnDisconnect, ignore404: true }, c.var.auth)) {
+            for await (const { event, data } of Runs.Stream.join(run.run_id, undefined, {
+                cancelOnDisconnect,
+                lastEventId: run.kwargs.resumable ? "-1" : undefined,
+                ignore404: true,
+            }, c.var.auth)) {
                 await stream.writeSSE({ data: serialiseAsDict(data), event });
             }
         }
@@ -148,6 +153,25 @@ api.post("/runs/stream", zValidator("json", schemas.RunCreate), async (c) => {
         }
     });
 });
+// TODO: port to Python API
+api.get("/runs/:run_id/stream", zValidator("param", z.object({ run_id: z.string().uuid() })), zValidator("query", z.object({ cancel_on_disconnect: schemas.coercedBoolean.optional() })), async (c) => {
+    const { run_id } = c.req.valid("param");
+    const query = c.req.valid("query");
+    const lastEventId = c.req.header("Last-Event-ID") || undefined;
+    return streamSSE(c, async (stream) => {
+        const cancelOnDisconnect = query.cancel_on_disconnect
+            ? getDisconnectAbortSignal(c, stream)
+            : undefined;
+        try {
+            for await (const { id, event, data } of Runs.Stream.join(run_id, undefined, { cancelOnDisconnect, lastEventId, ignore404: true }, c.var.auth)) {
+                await stream.writeSSE({ id, data: serialiseAsDict(data), event });
+            }
+        }
+        catch (error) {
+            logError(error, { prefix: "Error streaming run" });
+        }
+    });
+});
 api.post("/runs/wait", zValidator("json", schemas.RunCreate), async (c) => {
     // Wait Stateless Run
     const payload = c.req.valid("json");
@@ -198,6 +222,7 @@ api.post("/threads/:thread_id/runs", zValidator("param", z.object({ thread_id: z
         auth: c.var.auth,
         headers: c.req.raw.headers,
     });
+    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
     return jsonExtra(c, run);
 });
 api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ thread_id: z.string().uuid() })), zValidator("json", schemas.RunCreate), async (c) => {
@@ -208,13 +233,17 @@ api.post("/threads/:thread_id/runs/stream", zValidator("param", z.object({ threa
         auth: c.var.auth,
         headers: c.req.raw.headers,
     });
+    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
     return streamSSE(c, async (stream) => {
         const cancelOnDisconnect = payload.on_disconnect === "cancel"
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
         try {
-            for await (const { event, data } of Runs.Stream.join(run.run_id, thread_id, { cancelOnDisconnect }, c.var.auth)) {
-                await stream.writeSSE({ data: serialiseAsDict(data), event });
+            for await (const { id, event, data } of Runs.Stream.join(run.run_id, thread_id, {
+                cancelOnDisconnect,
+                lastEventId: run.kwargs.resumable ? "-1" : undefined,
+            }, c.var.auth)) {
+                await stream.writeSSE({ id, data: serialiseAsDict(data), event });
             }
         }
         catch (error) {
@@ -230,6 +259,7 @@ api.post("/threads/:thread_id/runs/wait", zValidator("param", z.object({ thread_
         auth: c.var.auth,
         headers: c.req.raw.headers,
     });
+    c.header("Content-Location", `/threads/${thread_id}/runs/${run.run_id}`);
     return waitKeepAlive(c, Runs.join(run.run_id, thread_id, c.var.auth));
 });
 api.get("/threads/:thread_id/runs/:run_id", zValidator("param", z.object({ thread_id: z.string().uuid(), run_id: z.string().uuid() })), async (c) => {
@@ -257,12 +287,13 @@ api.get("/threads/:thread_id/runs/:run_id/stream", zValidator("param", z.object(
     // Stream Run Http
     const { thread_id, run_id } = c.req.valid("param");
     const { cancel_on_disconnect } = c.req.valid("query");
+    const lastEventId = c.req.header("Last-Event-ID") || undefined;
     return streamSSE(c, async (stream) => {
         const signal = cancel_on_disconnect
             ? getDisconnectAbortSignal(c, stream)
             : undefined;
-        for await (const { event, data } of Runs.Stream.join(run_id, thread_id, { cancelOnDisconnect: signal }, c.var.auth)) {
-            await stream.writeSSE({ data: serialiseAsDict(data), event });
+        for await (const { id, event, data } of Runs.Stream.join(run_id, thread_id, { cancelOnDisconnect: signal, lastEventId }, c.var.auth)) {
+            await stream.writeSSE({ id, data: serialiseAsDict(data), event });
         }
     });
 });

package/dist/graph/parser/index.d.mts

@@ -10,8 +10,14 @@ export interface GraphSpec {
     sourceFile: string;
     exportSymbol: string;
 }
+type GraphSchemaWithSubgraphs = Record<string, GraphSchema>;
 export declare function getStaticGraphSchema(spec: GraphSpec, options?: {
     mainThread?: boolean;
     timeoutMs?: number;
-}): Promise<Record<string, GraphSchema>>;
+}): Promise<GraphSchemaWithSubgraphs>;
+export declare function getStaticGraphSchema(specMap: Record<string, GraphSpec>, options?: {
+    mainThread?: boolean;
+    timeoutMs?: number;
+}): Promise<Record<string, GraphSchemaWithSubgraphs>>;
 export declare function getRuntimeGraphSchema(graph: Pregel<any, any, any, any, any>): Promise<GraphSchema | undefined>;
+export {};

package/dist/graph/parser/index.mjs

@@ -1,25 +1,42 @@
 import { fileURLToPath } from "node:url";
 import { Worker } from "node:worker_threads";
-export async function getStaticGraphSchema(spec, options) {
-    if (options?.mainThread) {
-        const { SubgraphExtractor } = await import("./parser.mjs");
-        return SubgraphExtractor.extractSchemas(spec.sourceFile, spec.exportSymbol, { strict: false });
-    }
-    return await new Promise((resolve, reject) => {
-        const worker = new Worker(fileURLToPath(new URL("./parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
-        // Set a timeout to reject if the worker takes too long
-        const timeoutId = setTimeout(() => {
-            worker.terminate();
-            reject(new Error("Schema extract worker timed out"));
-        }, options?.timeoutMs ?? 30000);
-        worker.on("message", (result) => {
-            worker.terminate();
-            clearTimeout(timeoutId);
-            resolve(result);
+const isGraphSpec = (spec) => {
+    if (typeof spec !== "object" || spec == null)
+        return false;
+    if (!("sourceFile" in spec) || typeof spec.sourceFile !== "string")
+        return false;
+    if (!("exportSymbol" in spec) || typeof spec.exportSymbol !== "string")
+        return false;
+    return true;
+};
+export async function getStaticGraphSchema(input, options) {
+    async function execute(specs) {
+        if (options?.mainThread) {
+            const { SubgraphExtractor } = await import("./parser.mjs");
+            return SubgraphExtractor.extractSchemas(specs, { strict: false });
+        }
+        return await new Promise((resolve, reject) => {
+            const worker = new Worker(fileURLToPath(new URL("./parser.worker.mjs", import.meta.url)), { argv: process.argv.slice(-1) });
+            // Set a timeout to reject if the worker takes too long
+            const timeoutId = setTimeout(() => {
+                worker.terminate();
+                reject(new Error("Schema extract worker timed out"));
+            }, options?.timeoutMs ?? 30000);
+            worker.on("message", (result) => {
+                worker.terminate();
+                clearTimeout(timeoutId);
+                resolve(result);
+            });
+            worker.on("error", reject);
+            worker.postMessage(specs);
         });
-        worker.on("error", reject);
-        worker.postMessage(spec);
-    });
+    }
+    const specs = isGraphSpec(input) ? [input] : Object.values(input);
+    const results = await execute(specs);
+    if (isGraphSpec(input)) {
+        return results[0];
+    }
+    return Object.fromEntries(Object.keys(input).map((graphId, idx) => [graphId, results[idx]]));
 }
 export async function getRuntimeGraphSchema(graph) {
     try {

package/dist/graph/parser/parser.d.mts

@@ -35,8 +35,15 @@ export declare class SubgraphExtractor {
             node: ts.Node;
         };
     }[];
-    getAugmentedSourceFile: (name: string) => {
-        files: [filePath: string, contents: string][];
+    getAugmentedSourceFile: (suffix: string, name: string) => {
+        inferFile: {
+            fileName: string;
+            contents: string;
+        };
+        sourceFile: {
+            fileName: string;
+            contents: string;
+        };
         exports: {
             typeName: string;
             valueName: string;
@@ -53,11 +60,15 @@ export declare class SubgraphExtractor {
     protected isGraphOrPregelType: (type: ts.Type) => boolean;
     protected getText(node: ts.Node): string;
     protected reduceChildren<Acc>(node: ts.Node, fn: (acc: Acc, node: ts.Node) => Acc, initial: Acc): Acc;
-    static extractSchemas(target: string | {
-        contents: string;
-        files?: [fileName: string, contents: string][];
-    }, name: string, options?: {
+    static extractSchemas(target: {
+        sourceFile: string | {
+            name: string;
+            contents: string;
+            main?: boolean;
+        }[];
+        exportSymbol: string;
+    }[], options?: {
         strict?: boolean;
-    }): Record<string, GraphSchema>;
+    }): Record<string, GraphSchema>[];
 }
 export {};

package/dist/graph/parser/parser.mjs

@@ -11,6 +11,7 @@ const OVERRIDE_RESOLVE = [
     new RegExp(`^@langchain\/langgraph(\/.+)?$`),
     new RegExp(`^@langchain\/langgraph-checkpoint(\/.+)?$`),
 ];
+const INFER_TEMPLATE_PATH = path.resolve(__dirname, "./schema/types.template.mts");
 const compilerOptions = {
     noEmit: true,
     strict: true,
@@ -144,7 +145,7 @@ export class SubgraphExtractor {
             return this.findSubgraphs(varDecl.initializer, [name]);
         });
     };
-    getAugmentedSourceFile = (name) => {
+    getAugmentedSourceFile = (suffix, name) => {
         const vars = this.getSubgraphsVariables(name);
         const typeExports = [
             { typeName: `__langgraph__${name}`, valueName: name, graphName: name },
@@ -156,14 +157,14 @@ export class SubgraphExtractor {
                 graphName: [...namespace, node].join("|"),
             });
         }
-        const sourceFilePath = "__langgraph__source.mts";
+        const sourceFilePath = `__langgraph__source_${suffix}.mts`;
         const sourceContents = [
             this.getText(this.sourceFile),
             ...typeExports.map(({ typeName, valueName }) => `export type ${typeName} = typeof ${valueName}`),
         ].join("\n\n");
-        const inferFilePath = "__langgraph__infer.mts";
+        const inferFilePath = `__langgraph__infer_${suffix}.mts`;
         const inferContents = [
-            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source.mts"`),
+            ...typeExports.map(({ typeName }) => `import type { ${typeName}} from "./__langgraph__source_${suffix}.mts"`),
             this.inferFile.getText(this.inferFile),
             ...typeExports.flatMap(({ typeName }) => {
                 return [
@@ -181,10 +182,8 @@ export class SubgraphExtractor {
             }),
         ].join("\n\n");
         return {
-            files: [
-                [sourceFilePath, sourceContents],
-                [inferFilePath, inferContents],
-            ],
+            inferFile: { fileName: inferFilePath, contents: inferContents },
+            sourceFile: { fileName: sourceFilePath, contents: sourceContents },
             exports: typeExports,
         };
     };
@@ -228,11 +227,34 @@ export class SubgraphExtractor {
         ts.forEachChild(node, it.bind(this));
         return acc;
     }
-    static extractSchemas(target, name, options) {
-        const dirname = typeof target === "string" ? path.dirname(target) : __dirname;
+    static extractSchemas(target, options) {
+        if (!target.length)
+            throw new Error("No graphs found");
+        function getCommonPath(a, b) {
+            const aSeg = path.normalize(a).split(path.sep);
+            const bSeg = path.normalize(b).split(path.sep);
+            const maxIter = Math.min(aSeg.length, bSeg.length);
+            const result = [];
+            for (let i = 0; i < maxIter; ++i) {
+                if (aSeg[i] !== bSeg[i])
+                    break;
+                result.push(aSeg[i]);
+            }
+            return result.join(path.sep);
+        }
+        const isTestTarget = (check) => {
+            return check.every((x) => typeof x.sourceFile === "string");
+        };
+        const projectDirname = isTestTarget(target)
+            ? target.reduce((acc, item) => {
+                if (!acc)
+                    return path.dirname(item.sourceFile);
+                return getCommonPath(acc, path.dirname(item.sourceFile));
+            }, "")
+            : __dirname;
         // This API is not well made for Windows, ensure that the paths are UNIX slashes
         const fsMap = new Map();
-        const system = vfs.createFSBackedSystem(fsMap, dirname, ts);
+        const system = vfs.createFSBackedSystem(fsMap, projectDirname, ts);
         // TODO: investigate if we should create a PR in @typescript/vfs
         const oldReadFile = system.readFile.bind(system);
         system.readFile = (fileName) => oldReadFile(fileName) ?? "// Non-existent file";
@@ -243,17 +265,24 @@ export class SubgraphExtractor {
         };
         const vfsHost = vfs.createVirtualCompilerHost(system, compilerOptions, ts);
         const host = vfsHost.compilerHost;
-        const targetPath = typeof target === "string"
-            ? target
-            : path.resolve(dirname, "./__langgraph__target.mts");
-        const inferTemplatePath = path.resolve(__dirname, "./schema/types.template.mts");
-        if (typeof target !== "string") {
-            fsMap.set(vfsPath(targetPath), target.contents);
-            for (const [name, contents] of target.files ?? []) {
-                fsMap.set(vfsPath(path.resolve(dirname, name)), contents);
+        const targetPaths = [];
+        for (const item of target) {
+            if (typeof item.sourceFile === "string") {
+                targetPaths.push({ ...item, sourceFile: item.sourceFile });
+            }
+            else {
+                for (const { name, contents, main } of item.sourceFile ?? []) {
+                    fsMap.set(vfsPath(path.resolve(projectDirname, name)), contents);
+                    if (main) {
+                        targetPaths.push({
+                            ...item,
+                            sourceFile: path.resolve(projectDirname, name),
+                        });
+                    }
+                }
             }
         }
-        const moduleCache = ts.createModuleResolutionCache(dirname, (x) => x);
+        const moduleCache = ts.createModuleResolutionCache(projectDirname, (x) => x);
         host.resolveModuleNameLiterals = (entries, containingFile, redirectedReference, options) => entries.flatMap((entry) => {
             const specifier = entry.text;
             // Force module resolution to use @langchain/langgraph from the local project
@@ -263,7 +292,7 @@ export class SubgraphExtractor {
                 // check if we're not already importing from node_modules
                 if (!containingFile.split(path.sep).includes("node_modules")) {
                     // Doesn't matter if the file exists, only used to nudge `ts.resolveModuleName`
-                    targetFile = path.resolve(dirname, "__langgraph__resolve.mts");
+                    targetFile = path.resolve(projectDirname, "__langgraph__resolve.mts");
                 }
             }
             return [
@@ -271,17 +300,24 @@ export class SubgraphExtractor {
             ];
         });
         const research = ts.createProgram({
-            rootNames: [inferTemplatePath, targetPath],
+            rootNames: [INFER_TEMPLATE_PATH, ...targetPaths.map((i) => i.sourceFile)],
             options: compilerOptions,
             host,
         });
-        const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath), research.getSourceFile(inferTemplatePath), options);
-        const { files, exports } = extractor.getAugmentedSourceFile(name);
-        for (const [name, source] of files) {
-            system.writeFile(vfsPath(path.resolve(dirname, name)), source);
+        const researchTargets = [];
+        for (const targetPath of targetPaths) {
+            const extractor = new SubgraphExtractor(research, research.getSourceFile(targetPath.sourceFile), research.getSourceFile(INFER_TEMPLATE_PATH), options);
+            const { sourceFile, inferFile, exports } = extractor.getAugmentedSourceFile(path.basename(targetPath.sourceFile), targetPath.exportSymbol);
+            for (const { fileName, contents } of [sourceFile, inferFile]) {
+                system.writeFile(vfsPath(path.resolve(projectDirname, fileName)), contents);
+            }
+            researchTargets.push({
+                rootName: path.resolve(projectDirname, inferFile.fileName),
+                exports,
+            });
         }
         const extract = ts.createProgram({
-            rootNames: [path.resolve(dirname, "./__langgraph__infer.mts")],
+            rootNames: researchTargets.map((i) => i.rootName),
             options: compilerOptions,
             host,
         });
@@ -295,7 +331,7 @@ export class SubgraphExtractor {
             }
             return undefined;
         };
-        return Object.fromEntries(exports.map(({ typeName, graphName }) => [
+        return researchTargets.map(({ exports }) => Object.fromEntries(exports.map(({ typeName, graphName }) => [
             graphName,
             {
                 state: trySymbol(schemaGenerator, `${typeName}__update`),
@@ -303,6 +339,6 @@ export class SubgraphExtractor {
                 output: trySymbol(schemaGenerator, `${typeName}__output`),
                 config: trySymbol(schemaGenerator, `${typeName}__config`),
             },
-        ]));
+        ])));
     }
 }

package/dist/graph/parser/parser.worker.mjs

@@ -2,6 +2,6 @@ import { tsImport } from "tsx/esm/api";
 import { parentPort } from "node:worker_threads";
 parentPort?.on("message", async (payload) => {
     const { SubgraphExtractor } = await tsImport("./parser.mjs", import.meta.url);
-    const result = SubgraphExtractor.extractSchemas(payload.sourceFile, payload.exportSymbol, { strict: false });
+    const result = SubgraphExtractor.extractSchemas(payload, { strict: false });
     parentPort?.postMessage(result);
 });

package/dist/http/middleware.mjs

@@ -1,7 +1,11 @@
 import { cors as honoCors } from "hono/cors";
 export const cors = (cors) => {
-    if (cors == null)
-        return honoCors();
+    if (cors == null) {
+        return honoCors({
+            origin: "*",
+            exposeHeaders: ["content-location"],
+        });
+    }
     const originRegex = cors.allow_origin_regex
         ? new RegExp(cors.allow_origin_regex)
         : undefined;
@@ -13,6 +17,11 @@ export const cors = (cors) => {
             return undefined;
         }
         : (cors.allow_origins ?? []);
+    if (!!cors.expose_headers?.length &&
+        cors.expose_headers.some((i) => i.toLocaleLowerCase() === "content-location")) {
+        console.warn("Adding missing `Content-Location` header in `cors.expose_headers`.");
+        cors.expose_headers.push("content-location");
+    }
     // TODO: handle `cors.allow_credentials`
     return honoCors({
         origin,

package/dist/queue.mjs

@@ -45,17 +45,24 @@ const worker = async (run, attempt, abortSignal) => {
         if (attempt > MAX_RETRY_ATTEMPTS) {
             throw new Error(`Run ${run.run_id} exceeded max attempts`);
         }
+        const runId = run.run_id;
+        const resumable = run.kwargs?.resumable ?? false;
         try {
             const stream = streamState(run, attempt, {
                 signal: abortSignal,
                 ...(!temporary ? { onCheckpoint, onTaskResult } : undefined),
             });
             for await (const { event, data } of stream) {
-                await Runs.Stream.publish(run.run_id, event, data);
+                await Runs.Stream.publish({ runId, resumable, event, data });
             }
         }
         catch (error) {
-            await Runs.Stream.publish(run.run_id, "error", serializeError(error));
+            await Runs.Stream.publish({
+                runId,
+                resumable,
+                event: "error",
+                data: serializeError(error),
+            });
             throw error;
         }
         endedAt = new Date();

package/dist/schemas.d.mts

@@ -687,6 +687,7 @@ export declare const RunCreate: z.ZodObject<{
     multitask_strategy: z.ZodOptional<z.ZodEnum<["reject", "rollback", "interrupt", "enqueue"]>>;
     stream_mode: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodEnum<["values", "messages", "messages-tuple", "updates", "events", "debug", "custom"]>, "many">, z.ZodEnum<["values", "messages", "messages-tuple", "updates", "events", "debug", "custom"]>]>>;
     stream_subgraphs: z.ZodOptional<z.ZodBoolean>;
+    stream_resumable: z.ZodOptional<z.ZodBoolean>;
     after_seconds: z.ZodOptional<z.ZodNumber>;
     if_not_exists: z.ZodOptional<z.ZodEnum<["reject", "create"]>>;
     on_completion: z.ZodOptional<z.ZodEnum<["delete", "keep"]>>;
@@ -736,6 +737,7 @@ export declare const RunCreate: z.ZodObject<{
     if_not_exists?: "reject" | "create" | undefined;
     after_seconds?: number | undefined;
     stream_subgraphs?: boolean | undefined;
+    stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
 }, {
     assistant_id: string;
@@ -782,6 +784,7 @@ export declare const RunCreate: z.ZodObject<{
     after_seconds?: number | undefined;
     on_disconnect?: "cancel" | "continue" | undefined;
     stream_subgraphs?: boolean | undefined;
+    stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
 }>;
 export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
@@ -892,6 +895,7 @@ export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     multitask_strategy: z.ZodOptional<z.ZodEnum<["reject", "rollback", "interrupt", "enqueue"]>>;
     stream_mode: z.ZodOptional<z.ZodUnion<[z.ZodArray<z.ZodEnum<["values", "messages", "messages-tuple", "updates", "events", "debug", "custom"]>, "many">, z.ZodEnum<["values", "messages", "messages-tuple", "updates", "events", "debug", "custom"]>]>>;
     stream_subgraphs: z.ZodOptional<z.ZodBoolean>;
+    stream_resumable: z.ZodOptional<z.ZodBoolean>;
     after_seconds: z.ZodOptional<z.ZodNumber>;
     if_not_exists: z.ZodOptional<z.ZodEnum<["reject", "create"]>>;
     on_completion: z.ZodOptional<z.ZodEnum<["delete", "keep"]>>;
@@ -941,6 +945,7 @@ export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     if_not_exists?: "reject" | "create" | undefined;
     after_seconds?: number | undefined;
     stream_subgraphs?: boolean | undefined;
+    stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
 }, {
     assistant_id: string;
@@ -987,6 +992,7 @@ export declare const RunBatchCreate: z.ZodArray<z.ZodObject<{
     after_seconds?: number | undefined;
     on_disconnect?: "cancel" | "continue" | undefined;
     stream_subgraphs?: boolean | undefined;
+    stream_resumable?: boolean | undefined;
     on_completion?: "delete" | "keep" | undefined;
 }>, "many">;
 export declare const SearchResult: z.ZodObject<{

package/dist/schemas.mjs

@@ -205,6 +205,7 @@ export const RunCreate = z
     ])
         .optional(),
     stream_subgraphs: z.boolean().optional(),
+    stream_resumable: z.boolean().optional(),
     after_seconds: z.number().optional(),
     if_not_exists: z.enum(["reject", "create"]).optional(),
     on_completion: z.enum(["delete", "keep"]).optional(),

package/dist/server.d.mts

@@ -40,19 +40,19 @@ export declare const StartServerSchema: z.ZodObject<{
             max_age: z.ZodOptional<z.ZodNumber>;
         }, "strip", z.ZodTypeAny, {
             allow_origin_regex?: string | undefined;
+            expose_headers?: string[] | undefined;
             allow_origins?: string[] | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            expose_headers?: string[] | undefined;
             max_age?: number | undefined;
         }, {
             allow_origin_regex?: string | undefined;
+            expose_headers?: string[] | undefined;
             allow_origins?: string[] | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            expose_headers?: string[] | undefined;
             max_age?: number | undefined;
         }>>;
     }, "strip", z.ZodTypeAny, {
@@ -63,22 +63,22 @@ export declare const StartServerSchema: z.ZodObject<{
         disable_meta: boolean;
         cors?: {
             allow_origin_regex?: string | undefined;
+            expose_headers?: string[] | undefined;
             allow_origins?: string[] | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            expose_headers?: string[] | undefined;
             max_age?: number | undefined;
         } | undefined;
         app?: string | undefined;
     }, {
         cors?: {
             allow_origin_regex?: string | undefined;
+            expose_headers?: string[] | undefined;
             allow_origins?: string[] | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            expose_headers?: string[] | undefined;
             max_age?: number | undefined;
         } | undefined;
         app?: string | undefined;
@@ -110,11 +110,11 @@ export declare const StartServerSchema: z.ZodObject<{
         disable_meta: boolean;
         cors?: {
             allow_origin_regex?: string | undefined;
+            expose_headers?: string[] | undefined;
             allow_origins?: string[] | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            expose_headers?: string[] | undefined;
             max_age?: number | undefined;
         } | undefined;
         app?: string | undefined;
@@ -136,11 +136,11 @@ export declare const StartServerSchema: z.ZodObject<{
     http?: {
         cors?: {
             allow_origin_regex?: string | undefined;
+            expose_headers?: string[] | undefined;
             allow_origins?: string[] | undefined;
             allow_methods?: string[] | undefined;
             allow_headers?: string[] | undefined;
             allow_credentials?: boolean | undefined;
-            expose_headers?: string[] | undefined;
             max_age?: number | undefined;
         } | undefined;
         app?: string | undefined;

package/dist/storage/ops.d.mts

@@ -46,6 +46,7 @@ export interface RunKwargs {
     interrupt_after?: "*" | string[] | undefined;
     config?: RunnableConfig;
     subgraphs?: boolean;
+    resumable?: boolean;
     temporary?: boolean;
     webhook?: unknown;
     feedback_keys?: string[] | undefined;
@@ -75,13 +76,19 @@ interface Message {
     data: unknown;
 }
 declare class Queue {
-    private buffer;
+    private log;
     private listeners;
+    private nextId;
+    private resumable;
+    constructor(options: {
+        resumable: boolean;
+    });
     push(item: Message): void;
     get(options: {
         timeout: number;
+        lastEventId?: string;
         signal?: AbortSignal;
-    }): Promise<Message>;
+    }): Promise<[id: string, message: Message]>;
 }
 declare class CancellationAbortController extends AbortController {
     abort(reason: "rollback" | "interrupt"): void;
@@ -91,10 +98,8 @@ declare class StreamManagerImpl {
     control: Record<string, CancellationAbortController>;
     getQueue(runId: string, options: {
         ifNotFound: "create";
+        resumable: boolean;
     }): Queue;
-    getQueue(runId: string, options: {
-        ifNotFound: "ignore";
-    }): Queue | undefined;
     getControl(runId: string): CancellationAbortController | undefined;
     isLocked(runId: string): boolean;
     lock(runId: string): AbortSignal;
@@ -272,11 +277,18 @@ export declare class Runs {
         join(runId: string, threadId: string | undefined, options: {
             ignore404?: boolean;
             cancelOnDisconnect?: AbortSignal;
+            lastEventId: string | undefined;
         }, auth: AuthContext | undefined): AsyncGenerator<{
+            id?: string;
             event: string;
             data: unknown;
         }>;
-        publish(runId: string, topic: string, data: unknown): Promise<void>;
+        publish(payload: {
+            runId: string;
+            event: string;
+            data: unknown;
+            resumable: boolean;
+        }): Promise<void>;
     };
 }
 export declare class Crons {

package/dist/storage/ops.mjs

@@ -20,28 +20,58 @@ class TimeoutError extends Error {
 class AbortError extends Error {
 }
 class Queue {
-    buffer = [];
+    log = [];
     listeners = [];
+    nextId = 0;
+    resumable = false;
+    constructor(options) {
+        this.resumable = options.resumable;
+    }
     push(item) {
-        this.buffer.push(item);
-        for (const listener of this.listeners) {
-            listener();
-        }
+        this.log.push(item);
+        for (const listener of this.listeners)
+            listener(this.nextId);
+        this.nextId += 1;
     }
     async get(options) {
-        if (this.buffer.length > 0) {
-            return this.buffer.shift();
+        if (this.resumable) {
+            const lastEventId = options.lastEventId;
+            // Generator stores internal state of the read head index,
+            let targetId = lastEventId != null ? +lastEventId + 1 : null;
+            if (targetId == null ||
+                isNaN(targetId) ||
+                targetId < 0 ||
+                targetId >= this.log.length) {
+                targetId = null;
+            }
+            if (targetId != null)
+                return [String(targetId), this.log[targetId]];
+        }
+        else {
+            if (this.log.length) {
+                const nextId = this.nextId - this.log.length;
+                const nextItem = this.log.shift();
+                return [String(nextId), nextItem];
+            }
         }
         let timeout = undefined;
         let resolver = undefined;
         const clean = new AbortController();
+        // listen to new item
         return await new Promise((resolve, reject) => {
             timeout = setTimeout(() => reject(new TimeoutError()), options.timeout);
             resolver = resolve;
             options.signal?.addEventListener("abort", () => reject(new AbortError()), { signal: clean.signal });
             this.listeners.push(resolver);
         })
-            .then(() => this.buffer.shift())
+            .then((idx) => {
+            if (this.resumable) {
+                return [String(idx), this.log[idx]];
+            }
+            const nextId = this.nextId - this.log.length;
+            const nextItem = this.log.shift();
+            return [String(nextId), nextItem];
+        })
             .finally(() => {
             this.listeners = this.listeners.filter((l) => l !== resolver);
             clearTimeout(timeout);
@@ -59,12 +89,7 @@ class StreamManagerImpl {
     control = {};
     getQueue(runId, options) {
         if (this.readers[runId] == null) {
-            if (options?.ifNotFound === "create") {
-                this.readers[runId] = new Queue();
-            }
-            else {
-                return undefined;
-            }
+            this.readers[runId] = new Queue(options);
         }
         return this.readers[runId];
     }
@@ -883,7 +908,7 @@ export class Runs {
         });
     }
     static async wait(runId, threadId, auth) {
-        const runStream = Runs.Stream.join(runId, threadId, { ignore404: threadId == null }, auth);
+        const runStream = Runs.Stream.join(runId, threadId, { ignore404: threadId == null, lastEventId: undefined }, auth);
         const lastChunk = new Promise(async (resolve, reject) => {
             try {
                 let lastChunk = null;
@@ -1012,7 +1037,10 @@ export class Runs {
             yield* conn.withGenerator(async function* (STORE) {
                 // TODO: what if we're joining an already completed run? Should we check before?
                 const signal = options?.cancelOnDisconnect;
-                const queue = StreamManager.getQueue(runId, { ifNotFound: "create" });
+                const queue = StreamManager.getQueue(runId, {
+                    ifNotFound: "create",
+                    resumable: options.lastEventId != null,
+                });
                 const [filters] = await handleAuthEvent(auth, "threads:read", {
                     thread_id: threadId,
                 });
@@ -1027,16 +1055,22 @@ export class Runs {
                         return;
                     }
                 }
+                let lastEventId = options?.lastEventId;
                 while (!signal?.aborted) {
                     try {
-                        const message = await queue.get({ timeout: 500, signal });
+                        const [id, message] = await queue.get({
+                            timeout: 500,
+                            signal,
+                            lastEventId,
+                        });
+                        lastEventId = id;
                         if (message.topic === `run:${runId}:control`) {
                             if (message.data === "done")
                                 break;
                         }
                         else {
                             const streamTopic = message.topic.substring(`run:${runId}:stream:`.length);
-                            yield { event: streamTopic, data: message.data };
+                            yield { id, event: streamTopic, data: message.data };
                         }
                     }
                     catch (error) {
@@ -1058,9 +1092,15 @@ export class Runs {
                 }
             });
         }
-        static async publish(runId, topic, data) {
-            const queue = StreamManager.getQueue(runId, { ifNotFound: "create" });
-            queue.push({ topic: `run:${runId}:stream:${topic}`, data });
+        static async publish(payload) {
+            const queue = StreamManager.getQueue(payload.runId, {
+                ifNotFound: "create",
+                resumable: payload.resumable,
+            });
+            queue.push({
+                topic: `run:${payload.runId}:stream:${payload.event}`,
+                data: payload.data,
+            });
         }
     };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph-api",
-  "version": "0.0.34",
+  "version": "0.0.36",
   "type": "module",
   "engines": {
     "node": "^18.19.0 || >=20.16.0"
@@ -53,7 +53,7 @@
     "winston": "^3.17.0",
     "winston-console-format": "^1.0.8",
     "zod": "^3.23.8",
-    "@langchain/langgraph-ui": "0.0.34"
+    "@langchain/langgraph-ui": "0.0.36"
   },
   "peerDependencies": {
     "@langchain/core": "^0.3.42",
@@ -69,7 +69,7 @@
   },
   "devDependencies": {
     "typescript": "^5.5.4",
-    "@langchain/langgraph-sdk": "^0.0.70",
+    "@langchain/langgraph-sdk": "^0.0.77",
     "@types/babel__code-frame": "^7.0.6",
     "@types/node": "^22.2.0",
     "@types/react": "^19.0.8",