@langchain/langgraph-api 0.0.35 → 0.0.37

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/parser.mjs

@@ -147,12 +147,17 @@ export class SubgraphExtractor {
     };
     getAugmentedSourceFile = (suffix, name) => {
         const vars = this.getSubgraphsVariables(name);
+        const typeSuffix = suffix.replace(/[^a-zA-Z0-9]/g, "_");
         const typeExports = [
-            { typeName: `__langgraph__${name}`, valueName: name, graphName: name },
+            {
+                typeName: `__langgraph__${name}_${typeSuffix}`,
+                valueName: name,
+                graphName: name,
+            },
         ];
         for (const { subgraph, node, namespace } of vars) {
             typeExports.push({
-                typeName: `__langgraph__${namespace.join("_")}_${node}`,
+                typeName: `__langgraph__${namespace.join("_")}_${node}_${typeSuffix}`,
                 valueName: subgraph.name,
                 graphName: [...namespace, node].join("|"),
             });

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.35",
+  "version": "0.0.37",
   "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.35"
+    "@langchain/langgraph-ui": "0.0.37"
   },
   "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",