@langchain/langgraph 0.1.7 → 0.1.9

package/dist/constants.d.ts

@@ -68,3 +68,7 @@ export declare class Send implements SendInterface {
     constructor(node: string, args: any);
 }
 export declare function _isSend(x: unknown): x is Send;
+export type Interrupt = {
+    value: any;
+    when: "during";
+};

package/dist/errors.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = void 0;
+exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = void 0;
 class GraphRecursionError extends Error {
     constructor(message) {
         super(message);
@@ -22,15 +22,45 @@ class GraphValueError extends Error {
 }
 exports.GraphValueError = GraphValueError;
 class GraphInterrupt extends Error {
-    constructor(message) {
-        super(message);
+    constructor(interrupts = []) {
+        super(JSON.stringify(interrupts, null, 2));
+        Object.defineProperty(this, "interrupts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.name = "GraphInterrupt";
+        this.interrupts = interrupts;
     }
     static get unminifiable_name() {
         return "GraphInterrupt";
     }
 }
 exports.GraphInterrupt = GraphInterrupt;
+/** Raised by a node to interrupt execution. */
+class NodeInterrupt extends GraphInterrupt {
+    constructor(message) {
+        super([
+            {
+                value: message,
+                when: "during",
+            },
+        ]);
+        this.name = "NodeInterrupt";
+    }
+    static get unminifiable_name() {
+        return "NodeInterrupt";
+    }
+}
+exports.NodeInterrupt = NodeInterrupt;
+function isGraphInterrupt(e) {
+    return [
+        GraphInterrupt.unminifiable_name,
+        NodeInterrupt.unminifiable_name,
+    ].includes(e.name);
+}
+exports.isGraphInterrupt = isGraphInterrupt;
 class EmptyInputError extends Error {
     constructor(message) {
         super(message);

package/dist/errors.d.ts

@@ -1,3 +1,4 @@
+import { Interrupt } from "./constants.js";
 export declare class GraphRecursionError extends Error {
     constructor(message?: string);
     static get unminifiable_name(): string;
@@ -7,9 +8,16 @@ export declare class GraphValueError extends Error {
     static get unminifiable_name(): string;
 }
 export declare class GraphInterrupt extends Error {
-    constructor(message?: string);
+    interrupts: Interrupt[];
+    constructor(interrupts?: Interrupt[]);
+    static get unminifiable_name(): string;
+}
+/** Raised by a node to interrupt execution. */
+export declare class NodeInterrupt extends GraphInterrupt {
+    constructor(message: string);
     static get unminifiable_name(): string;
 }
+export declare function isGraphInterrupt(e: GraphInterrupt | Error): e is GraphInterrupt;
 export declare class EmptyInputError extends Error {
     constructor(message?: string);
     static get unminifiable_name(): string;

package/dist/errors.js

@@ -17,14 +17,42 @@ export class GraphValueError extends Error {
     }
 }
 export class GraphInterrupt extends Error {
-    constructor(message) {
-        super(message);
+    constructor(interrupts = []) {
+        super(JSON.stringify(interrupts, null, 2));
+        Object.defineProperty(this, "interrupts", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.name = "GraphInterrupt";
+        this.interrupts = interrupts;
     }
     static get unminifiable_name() {
         return "GraphInterrupt";
     }
 }
+/** Raised by a node to interrupt execution. */
+export class NodeInterrupt extends GraphInterrupt {
+    constructor(message) {
+        super([
+            {
+                value: message,
+                when: "during",
+            },
+        ]);
+        this.name = "NodeInterrupt";
+    }
+    static get unminifiable_name() {
+        return "NodeInterrupt";
+    }
+}
+export function isGraphInterrupt(e) {
+    return [
+        GraphInterrupt.unminifiable_name,
+        NodeInterrupt.unminifiable_name,
+    ].includes(e.name);
+}
 export class EmptyInputError extends Error {
     constructor(message) {
         super(message);

package/dist/graph/graph.cjs

@@ -223,12 +223,6 @@ class Graph {
         for (const [start] of Object.entries(this.branches)) {
             allSources.add(start);
         }
-        // validate sources
-        for (const node of Object.keys(this.nodes)) {
-            if (!allSources.has(node)) {
-                throw new Error(`Node \`${node}\` is a dead-end`);
-            }
-        }
         for (const source of allSources) {
             if (source !== exports.START && !(source in this.nodes)) {
                 throw new Error(`Found edge starting at unknown node \`${source}\``);

package/dist/graph/graph.js

@@ -219,12 +219,6 @@ export class Graph {
         for (const [start] of Object.entries(this.branches)) {
             allSources.add(start);
         }
-        // validate sources
-        for (const node of Object.keys(this.nodes)) {
-            if (!allSources.has(node)) {
-                throw new Error(`Node \`${node}\` is a dead-end`);
-            }
-        }
         for (const source of allSources) {
             if (source !== START && !(source in this.nodes)) {
                 throw new Error(`Found edge starting at unknown node \`${source}\``);

package/dist/graph/message.d.ts

@@ -1,6 +1,6 @@
 import { BaseMessage, BaseMessageLike } from "@langchain/core/messages";
 import { StateGraph } from "./state.js";
-type Messages = Array<BaseMessage | BaseMessageLike> | BaseMessage | BaseMessageLike;
+export type Messages = Array<BaseMessage | BaseMessageLike> | BaseMessage | BaseMessageLike;
 /**
  * Prebuilt reducer that combines returned messages.
  * Can handle standard messages and special modifiers like {@link RemoveMessage}
@@ -11,4 +11,3 @@ export declare function messagesStateReducer(left: BaseMessage[], right: Message
 export declare class MessageGraph extends StateGraph<BaseMessage[], BaseMessage[], Messages> {
     constructor();
 }
-export {};

package/dist/graph/messages_annotation.d.ts

@@ -1,9 +1,10 @@
 import { BaseMessage } from "@langchain/core/messages";
+import { Messages } from "./message.js";
 /**
  * Prebuilt state annotation that combines returned messages.
  * Can handle standard messages and special modifiers like {@link RemoveMessage}
  * instances.
  */
 export declare const MessagesAnnotation: import("./annotation.js").AnnotationRoot<{
-    messages: import("../web.js").BinaryOperatorAggregate<BaseMessage[], BaseMessage[]>;
+    messages: import("../web.js").BinaryOperatorAggregate<BaseMessage[], Messages>;
 }>;

package/dist/prebuilt/tool_node.cjs

@@ -4,16 +4,17 @@ exports.toolsCondition = exports.ToolNode = void 0;
 const messages_1 = require("@langchain/core/messages");
 const utils_js_1 = require("../utils.cjs");
 const graph_js_1 = require("../graph/graph.cjs");
+/**
+ * A node that runs the tools requested in the last AIMessage. It can be used
+ * either in StateGraph with a "messages" key or in MessageGraph. If multiple
+ * tool calls are requested, they will be run in parallel. The output will be
+ * a list of ToolMessages, one for each tool call.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 class ToolNode extends utils_js_1.RunnableCallable {
     constructor(tools, options) {
         const { name, tags, handleToolErrors } = options ?? {};
         super({ name, tags, func: (input, config) => this.run(input, config) });
-        /**
-        A node that runs the tools requested in the last AIMessage. It can be used
-        either in StateGraph with a "messages" key or in MessageGraph. If multiple
-        tool calls are requested, they will be run in parallel. The output will be
-        a list of ToolMessages, one for each tool call.
-        */
         Object.defineProperty(this, "tools", {
             enumerable: true,
             configurable: true,
@@ -29,11 +30,12 @@ class ToolNode extends utils_js_1.RunnableCallable {
         this.tools = tools;
         this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async run(input, config) {
         const message = Array.isArray(input)
             ? input[input.length - 1]
             : input.messages[input.messages.length - 1];
-        if (message._getType() !== "ai") {
+        if (message?._getType() !== "ai") {
             throw new Error("ToolNode only accepts AIMessages as input.");
         }
         const outputs = await Promise.all(message.tool_calls?.map(async (call) => {
@@ -66,7 +68,7 @@ class ToolNode extends utils_js_1.RunnableCallable {
                 });
             }
         }) ?? []);
-        return Array.isArray(input) ? outputs : { messages: outputs };
+        return (Array.isArray(input) ? outputs : { messages: outputs });
     }
 }
 exports.ToolNode = ToolNode;

package/dist/prebuilt/tool_node.d.ts

@@ -9,13 +9,13 @@ export type ToolNodeOptions = {
     tags?: string[];
     handleToolErrors?: boolean;
 };
-export declare class ToolNode<T extends BaseMessage[] | typeof MessagesAnnotation.State> extends RunnableCallable<T, T> {
-    /**
-    A node that runs the tools requested in the last AIMessage. It can be used
-    either in StateGraph with a "messages" key or in MessageGraph. If multiple
-    tool calls are requested, they will be run in parallel. The output will be
-    a list of ToolMessages, one for each tool call.
-    */
+/**
+ * A node that runs the tools requested in the last AIMessage. It can be used
+ * either in StateGraph with a "messages" key or in MessageGraph. If multiple
+ * tool calls are requested, they will be run in parallel. The output will be
+ * a list of ToolMessages, one for each tool call.
+ */
+export declare class ToolNode<T = any> extends RunnableCallable<T, T> {
     tools: (StructuredToolInterface | RunnableToolLike)[];
     handleToolErrors: boolean;
     constructor(tools: (StructuredToolInterface | RunnableToolLike)[], options?: ToolNodeOptions);

package/dist/prebuilt/tool_node.js

@@ -1,16 +1,17 @@
 import { ToolMessage, isBaseMessage, } from "@langchain/core/messages";
 import { RunnableCallable } from "../utils.js";
 import { END } from "../graph/graph.js";
+/**
+ * A node that runs the tools requested in the last AIMessage. It can be used
+ * either in StateGraph with a "messages" key or in MessageGraph. If multiple
+ * tool calls are requested, they will be run in parallel. The output will be
+ * a list of ToolMessages, one for each tool call.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class ToolNode extends RunnableCallable {
     constructor(tools, options) {
         const { name, tags, handleToolErrors } = options ?? {};
         super({ name, tags, func: (input, config) => this.run(input, config) });
-        /**
-        A node that runs the tools requested in the last AIMessage. It can be used
-        either in StateGraph with a "messages" key or in MessageGraph. If multiple
-        tool calls are requested, they will be run in parallel. The output will be
-        a list of ToolMessages, one for each tool call.
-        */
         Object.defineProperty(this, "tools", {
             enumerable: true,
             configurable: true,
@@ -26,11 +27,12 @@ export class ToolNode extends RunnableCallable {
         this.tools = tools;
         this.handleToolErrors = handleToolErrors ?? this.handleToolErrors;
     }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
     async run(input, config) {
         const message = Array.isArray(input)
             ? input[input.length - 1]
             : input.messages[input.messages.length - 1];
-        if (message._getType() !== "ai") {
+        if (message?._getType() !== "ai") {
             throw new Error("ToolNode only accepts AIMessages as input.");
         }
         const outputs = await Promise.all(message.tool_calls?.map(async (call) => {
@@ -63,7 +65,7 @@ export class ToolNode extends RunnableCallable {
                 });
             }
         }) ?? []);
-        return Array.isArray(input) ? outputs : { messages: outputs };
+        return (Array.isArray(input) ? outputs : { messages: outputs });
     }
 }
 export function toolsCondition(state) {

package/dist/pregel/algo.cjs

@@ -218,7 +218,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
             }
         }
         else {
-            taskDescriptions.push({ id: taskId, name: packet.node });
+            taskDescriptions.push({ id: taskId, name: packet.node, interrupts: [] });
         }
     }
     // Check if any processes should be run in next step
@@ -291,7 +291,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                 }
             }
             else {
-                taskDescriptions.push({ id: taskId, name });
+                taskDescriptions.push({ id: taskId, name, interrupts: [] });
             }
         }
     }

package/dist/pregel/algo.js

@@ -210,7 +210,7 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
             }
         }
         else {
-            taskDescriptions.push({ id: taskId, name: packet.node });
+            taskDescriptions.push({ id: taskId, name: packet.node, interrupts: [] });
         }
     }
     // Check if any processes should be run in next step
@@ -283,7 +283,7 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
                 }
             }
             else {
-                taskDescriptions.push({ id: taskId, name });
+                taskDescriptions.push({ id: taskId, name, interrupts: [] });
             }
         }
     }

package/dist/pregel/debug.cjs

@@ -53,7 +53,7 @@ function* _readChannels(channels
 }
 function* mapDebugTasks(step, tasks) {
     const ts = new Date().toISOString();
-    for (const { name, input, config, triggers } of tasks) {
+    for (const { id, name, input, config, triggers, writes } of tasks) {
         if (config?.tags?.includes(constants_js_1.TAG_HIDDEN))
             continue;
         const metadata = { ...config?.metadata };
@@ -63,6 +63,13 @@ function* mapDebugTasks(step, tasks) {
             langgraph_triggers: metadata.langgraph_triggers,
             langgraph_task_idx: metadata.langgraph_task_idx,
         });
+        const interrupts = writes
+            .filter(([writeId, n]) => {
+            return writeId === id && n === constants_js_1.INTERRUPT;
+        })
+            .map(([, v]) => {
+            return v;
+        });
         yield {
             type: "task",
             timestamp: ts,
@@ -72,14 +79,15 @@ function* mapDebugTasks(step, tasks) {
                 name,
                 input,
                 triggers,
+                interrupts,
             },
         };
     }
 }
 exports.mapDebugTasks = mapDebugTasks;
-function* mapDebugTaskResults(step, tasks, streamChannelsList) {
+function* mapDebugTaskResults(step, tasks, streamChannels) {
     const ts = new Date().toISOString();
-    for (const { name, writes, config } of tasks) {
+    for (const [{ name, config }, writes] of tasks) {
         if (config?.tags?.includes(constants_js_1.TAG_HIDDEN))
             continue;
         const metadata = { ...config?.metadata };
@@ -91,7 +99,9 @@ function* mapDebugTaskResults(step, tasks, streamChannelsList) {
             payload: {
                 id: (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([name, step, idMetadata]), constants_js_1.TASK_NAMESPACE),
                 name,
-                result: writes.filter(([channel]) => streamChannelsList.includes(channel)),
+                result: writes.filter(([channel]) => Array.isArray(streamChannels)
+                    ? streamChannels.includes(channel)
+                    : channel === streamChannels),
             },
         };
     }
@@ -141,9 +151,26 @@ exports.mapDebugCheckpoint = mapDebugCheckpoint;
 function tasksWithWrites(tasks, pendingWrites) {
     return tasks.map((task) => {
         const error = pendingWrites.find(([id, n]) => id === task.id && n === constants_js_1.ERROR)?.[2];
-        if (error)
-            return { id: task.id, name: task.name, error };
-        return { id: task.id, name: task.name };
+        const interrupts = pendingWrites
+            .filter(([id, n]) => {
+            return id === task.id && n === constants_js_1.INTERRUPT;
+        })
+            .map(([, , v]) => {
+            return v;
+        });
+        if (error) {
+            return {
+                id: task.id,
+                name: task.name,
+                error,
+                interrupts,
+            };
+        }
+        return {
+            id: task.id,
+            name: task.name,
+            interrupts,
+        };
     });
 }
 exports.tasksWithWrites = tasksWithWrites;

package/dist/pregel/debug.d.ts

@@ -12,9 +12,10 @@ export declare function mapDebugTasks<N extends PropertyKey, C extends PropertyK
         name: N;
         input: unknown;
         triggers: string[];
+        interrupts: unknown[];
     };
 }, void, unknown>;
-export declare function mapDebugTaskResults<N extends PropertyKey, C extends PropertyKey>(step: number, tasks: readonly PregelExecutableTask<N, C>[], streamChannelsList: Array<PropertyKey>): Generator<{
+export declare function mapDebugTaskResults<N extends PropertyKey, C extends PropertyKey>(step: number, tasks: readonly [PregelExecutableTask<N, C>, PendingWrite<C>[]][], streamChannels: PropertyKey | Array<PropertyKey>): Generator<{
     type: string;
     timestamp: string;
     step: number;

package/dist/pregel/debug.js

@@ -1,5 +1,5 @@
 import { uuid5, } from "@langchain/langgraph-checkpoint";
-import { ERROR, TAG_HIDDEN, TASK_NAMESPACE } from "../constants.js";
+import { ERROR, INTERRUPT, TAG_HIDDEN, TASK_NAMESPACE, } from "../constants.js";
 import { EmptyChannelError } from "../errors.js";
 import { readChannels } from "./io.js";
 import { _getIdMetadata } from "./utils.js";
@@ -49,7 +49,7 @@ function* _readChannels(channels
 }
 export function* mapDebugTasks(step, tasks) {
     const ts = new Date().toISOString();
-    for (const { name, input, config, triggers } of tasks) {
+    for (const { id, name, input, config, triggers, writes } of tasks) {
         if (config?.tags?.includes(TAG_HIDDEN))
             continue;
         const metadata = { ...config?.metadata };
@@ -59,6 +59,13 @@ export function* mapDebugTasks(step, tasks) {
             langgraph_triggers: metadata.langgraph_triggers,
             langgraph_task_idx: metadata.langgraph_task_idx,
         });
+        const interrupts = writes
+            .filter(([writeId, n]) => {
+            return writeId === id && n === INTERRUPT;
+        })
+            .map(([, v]) => {
+            return v;
+        });
         yield {
             type: "task",
             timestamp: ts,
@@ -68,13 +75,14 @@ export function* mapDebugTasks(step, tasks) {
                 name,
                 input,
                 triggers,
+                interrupts,
             },
         };
     }
 }
-export function* mapDebugTaskResults(step, tasks, streamChannelsList) {
+export function* mapDebugTaskResults(step, tasks, streamChannels) {
     const ts = new Date().toISOString();
-    for (const { name, writes, config } of tasks) {
+    for (const [{ name, config }, writes] of tasks) {
         if (config?.tags?.includes(TAG_HIDDEN))
             continue;
         const metadata = { ...config?.metadata };
@@ -86,7 +94,9 @@ export function* mapDebugTaskResults(step, tasks, streamChannelsList) {
             payload: {
                 id: uuid5(JSON.stringify([name, step, idMetadata]), TASK_NAMESPACE),
                 name,
-                result: writes.filter(([channel]) => streamChannelsList.includes(channel)),
+                result: writes.filter(([channel]) => Array.isArray(streamChannels)
+                    ? streamChannels.includes(channel)
+                    : channel === streamChannels),
             },
         };
     }
@@ -134,9 +144,26 @@ export function* mapDebugCheckpoint(step, config, channels, streamChannels, meta
 export function tasksWithWrites(tasks, pendingWrites) {
     return tasks.map((task) => {
         const error = pendingWrites.find(([id, n]) => id === task.id && n === ERROR)?.[2];
-        if (error)
-            return { id: task.id, name: task.name, error };
-        return { id: task.id, name: task.name };
+        const interrupts = pendingWrites
+            .filter(([id, n]) => {
+            return id === task.id && n === INTERRUPT;
+        })
+            .map(([, , v]) => {
+            return v;
+        });
+        if (error) {
+            return {
+                id: task.id,
+                name: task.name,
+                error,
+                interrupts,
+            };
+        }
+        return {
+            id: task.id,
+            name: task.name,
+            interrupts,
+        };
     });
 }
 export function printStepCheckpoint(step, channels, whitelist) {

package/dist/pregel/index.cjs

@@ -13,8 +13,7 @@ const write_js_1 = require("./write.cjs");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
 const algo_js_1 = require("./algo.cjs");
-const utils_js_1 = require("../utils.cjs");
-const utils_js_2 = require("./utils.cjs");
+const utils_js_1 = require("./utils.cjs");
 const loop_js_1 = require("./loop.cjs");
 const retry_js_1 = require("./retry.cjs");
 function isString(value) {
@@ -365,7 +364,7 @@ class Pregel extends runnables_1.Runnable {
         // apply to checkpoint and save
         // TODO: Why does keyof StrRecord allow number and symbol?
         (0, algo_js_1._applyWrites)(checkpoint, channels, [task], this.checkpointer.getNextVersion.bind(this.checkpointer));
-        const newVersions = (0, utils_js_2.getNewChannelVersions)(checkpointPreviousVersions, checkpoint.channel_versions);
+        const newVersions = (0, utils_js_1.getNewChannelVersions)(checkpointPreviousVersions, checkpoint.channel_versions);
         return await this.checkpointer.put(checkpointConfig, (0, base_js_1.createCheckpoint)(checkpoint, channels, step + 1), {
             source: "update",
             step: step + 1,
@@ -451,7 +450,7 @@ class Pregel extends runnables_1.Runnable {
             throw new Error(`Checkpointer requires one or more of the following "configurable" keys: "thread_id", "checkpoint_ns", "checkpoint_id"`);
         }
         const callbackManager = await (0, runnables_1.getCallbackManagerForConfig)(inputConfig);
-        const runManager = await callbackManager?.handleChainStart(this.toJSON(), (0, utils_js_2._coerceToDict)(input, "input"), inputConfig.runId, undefined, undefined, undefined, inputConfig?.runName ?? this.getName());
+        const runManager = await callbackManager?.handleChainStart(this.toJSON(), (0, utils_js_1._coerceToDict)(input, "input"), inputConfig.runId, undefined, undefined, undefined, inputConfig?.runName ?? this.getName());
         delete inputConfig.runId;
         // assign defaults
         const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer,] = this._defaults(inputConfig);
@@ -467,10 +466,11 @@ class Pregel extends runnables_1.Runnable {
                 checkpointer,
                 graph: this,
                 onBackgroundError,
+                outputKeys,
+                streamKeys: this.streamChannelsAsIs,
             });
             while (backgroundError === undefined &&
                 (await loop.tick({
-                    outputKeys,
                     interruptAfter,
                     interruptBefore,
                     manager: runManager,
@@ -495,35 +495,52 @@ class Pregel extends runnables_1.Runnable {
                 if (debug) {
                     (0, debug_js_1.printStepTasks)(loop.step, loop.tasks);
                 }
-                try {
-                    // execute tasks, and wait for one to fail or all to finish.
-                    // each task is independent from all other concurrent tasks
-                    // yield updates/debug output as each task finishes
-                    for await (const task of (0, retry_js_1.executeTasksWithRetry)(loop.tasks.filter((task) => task.writes.length === 0), {
-                        stepTimeout: this.stepTimeout,
-                        signal: config.signal,
-                        retryPolicy: this.retryPolicy,
-                    })) {
+                // execute tasks, and wait for one to fail or all to finish.
+                // each task is independent from all other concurrent tasks
+                // yield updates/debug output as each task finishes
+                const taskStream = (0, retry_js_1.executeTasksWithRetry)(loop.tasks.filter((task) => task.writes.length === 0), {
+                    stepTimeout: this.stepTimeout,
+                    signal: config.signal,
+                    retryPolicy: this.retryPolicy,
+                });
+                // Timeouts will be thrown
+                for await (const { task, error } of taskStream) {
+                    if (error !== undefined) {
+                        if ((0, errors_js_1.isGraphInterrupt)(error)) {
+                            loop.putWrites(task.id, error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]));
+                        }
+                        else {
+                            loop.putWrites(task.id, [
+                                [constants_js_1.ERROR, { message: error.message, name: error.name }],
+                            ]);
+                        }
+                    }
+                    else {
                         loop.putWrites(task.id, task.writes);
-                        if (streamMode.includes("updates")) {
-                            yield* (0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputUpdates)(outputKeys, [task]), streamMode.length > 1 ? "updates" : undefined);
+                    }
+                    while (loop.stream.length > 0) {
+                        const nextItem = loop.stream.shift();
+                        if (nextItem === undefined) {
+                            throw new Error("Data structure error.");
                         }
-                        if (streamMode.includes("debug")) {
-                            yield* (0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTaskResults)(loop.step, [task], this.streamChannelsList), streamMode.length > 1 ? "debug" : undefined);
+                        if (streamMode.includes(nextItem[0])) {
+                            if (streamMode.length === 1) {
+                                yield nextItem[1];
+                            }
+                            else {
+                                yield nextItem;
+                            }
                         }
                     }
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }
-                catch (e) {
-                    if (e.pregelTaskId) {
-                        loop.putWrites(e.pregelTaskId, [[constants_js_1.ERROR, { message: e.message }]]);
+                    if (error !== undefined && !(0, errors_js_1.isGraphInterrupt)(error)) {
+                        throw error;
                     }
-                    throw e;
                 }
                 if (debug) {
                     (0, debug_js_1.printStepWrites)(loop.step, loop.tasks.map((task) => task.writes).flat(), this.streamChannelsList);
                 }
             }
+            // Checkpointing failures
             if (backgroundError !== undefined) {
                 throw backgroundError;
             }

package/dist/pregel/index.js

@@ -4,13 +4,12 @@ import { compareChannelVersions, copyCheckpoint, emptyCheckpoint, uuid5, } from
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
 import { PregelNode } from "./read.js";
 import { validateGraph, validateKeys } from "./validate.js";
-import { mapOutputUpdates, readChannels } from "./io.js";
-import { mapDebugTaskResults, printStepCheckpoint, printStepTasks, printStepWrites, tasksWithWrites, } from "./debug.js";
+import { readChannels } from "./io.js";
+import { printStepCheckpoint, printStepTasks, printStepWrites, tasksWithWrites, } from "./debug.js";
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
 import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, } from "../constants.js";
-import { GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
+import { GraphRecursionError, GraphValueError, InvalidUpdateError, isGraphInterrupt, } from "../errors.js";
 import { _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
-import { prefixGenerator } from "../utils.js";
 import { _coerceToDict, getNewChannelVersions } from "./utils.js";
 import { PregelLoop } from "./loop.js";
 import { executeTasksWithRetry } from "./retry.js";
@@ -463,10 +462,11 @@ export class Pregel extends Runnable {
                 checkpointer,
                 graph: this,
                 onBackgroundError,
+                outputKeys,
+                streamKeys: this.streamChannelsAsIs,
             });
             while (backgroundError === undefined &&
                 (await loop.tick({
-                    outputKeys,
                     interruptAfter,
                     interruptBefore,
                     manager: runManager,
@@ -491,35 +491,52 @@ export class Pregel extends Runnable {
                 if (debug) {
                     printStepTasks(loop.step, loop.tasks);
                 }
-                try {
-                    // execute tasks, and wait for one to fail or all to finish.
-                    // each task is independent from all other concurrent tasks
-                    // yield updates/debug output as each task finishes
-                    for await (const task of executeTasksWithRetry(loop.tasks.filter((task) => task.writes.length === 0), {
-                        stepTimeout: this.stepTimeout,
-                        signal: config.signal,
-                        retryPolicy: this.retryPolicy,
-                    })) {
+                // execute tasks, and wait for one to fail or all to finish.
+                // each task is independent from all other concurrent tasks
+                // yield updates/debug output as each task finishes
+                const taskStream = executeTasksWithRetry(loop.tasks.filter((task) => task.writes.length === 0), {
+                    stepTimeout: this.stepTimeout,
+                    signal: config.signal,
+                    retryPolicy: this.retryPolicy,
+                });
+                // Timeouts will be thrown
+                for await (const { task, error } of taskStream) {
+                    if (error !== undefined) {
+                        if (isGraphInterrupt(error)) {
+                            loop.putWrites(task.id, error.interrupts.map((interrupt) => [INTERRUPT, interrupt]));
+                        }
+                        else {
+                            loop.putWrites(task.id, [
+                                [ERROR, { message: error.message, name: error.name }],
+                            ]);
+                        }
+                    }
+                    else {
                         loop.putWrites(task.id, task.writes);
-                        if (streamMode.includes("updates")) {
-                            yield* prefixGenerator(mapOutputUpdates(outputKeys, [task]), streamMode.length > 1 ? "updates" : undefined);
+                    }
+                    while (loop.stream.length > 0) {
+                        const nextItem = loop.stream.shift();
+                        if (nextItem === undefined) {
+                            throw new Error("Data structure error.");
                         }
-                        if (streamMode.includes("debug")) {
-                            yield* prefixGenerator(mapDebugTaskResults(loop.step, [task], this.streamChannelsList), streamMode.length > 1 ? "debug" : undefined);
+                        if (streamMode.includes(nextItem[0])) {
+                            if (streamMode.length === 1) {
+                                yield nextItem[1];
+                            }
+                            else {
+                                yield nextItem;
+                            }
                         }
                     }
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }
-                catch (e) {
-                    if (e.pregelTaskId) {
-                        loop.putWrites(e.pregelTaskId, [[ERROR, { message: e.message }]]);
+                    if (error !== undefined && !isGraphInterrupt(error)) {
+                        throw error;
                     }
-                    throw e;
                 }
                 if (debug) {
                     printStepWrites(loop.step, loop.tasks.map((task) => task.writes).flat(), this.streamChannelsList);
                 }
             }
+            // Checkpointing failures
             if (backgroundError !== undefined) {
                 throw backgroundError;
             }

package/dist/pregel/loop.cjs

@@ -135,6 +135,18 @@ class PregelLoop {
             writable: true,
             value: Promise.resolve()
         });
+        Object.defineProperty(this, "outputKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streamKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "onBackgroundError", {
             enumerable: true,
             configurable: true,
@@ -162,6 +174,8 @@ class PregelLoop {
         this.step = params.step;
         this.stop = params.stop;
         this.isNested = constants_js_1.CONFIG_KEY_READ in (this.config.configurable ?? {});
+        this.outputKeys = params.outputKeys;
+        this.streamKeys = params.streamKeys;
         this.onBackgroundError = params.onBackgroundError;
     }
     static async initialize(params) {
@@ -203,6 +217,8 @@ class PregelLoop {
             stop,
             checkpointPreviousVersions,
             checkpointPendingWrites,
+            outputKeys: params.outputKeys,
+            streamKeys: params.streamKeys,
             onBackgroundError: params.onBackgroundError,
         });
     }
@@ -239,6 +255,11 @@ class PregelLoop {
             }, writes, taskId)
                 .catch(this.onBackgroundError);
         }
+        const task = this.tasks.find((task) => task.id === taskId);
+        if (task !== undefined) {
+            this.stream.push(...(0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputUpdates)(this.outputKeys, [task]), "updates")));
+            this.stream.push(...(0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTaskResults)(this.step, [[task, writes]], this.streamKeys), "debug")));
+        }
     }
     /**
      * Execute a single iteration of the Pregel loop.
@@ -246,7 +267,7 @@ class PregelLoop {
      * @param params
      */
     async tick(params) {
-        const { outputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        const { interruptAfter = [], interruptBefore = [], manager } = params;
         if (this.status !== "pending") {
             throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
         }
@@ -258,15 +279,11 @@ class PregelLoop {
             // All tasks have finished
             (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, this.tasks, this.checkpointerGetNextVersion);
             // produce values output
-            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(outputKeys, writes, this.channels), "values"));
+            const valuesOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, writes, this.channels), "values"));
             this.stream.push(...valuesOutput);
             // clear pending writes
             this.checkpointPendingWrites = [];
-            const updatesOnly = this.graph.streamMode?.length === 1 &&
-                this.graph.streamMode?.includes("updates");
-            const metadataWrites = updatesOnly
-                ? (0, io_js_1.mapOutputUpdates)(outputKeys, this.tasks).next().value
-                : (0, io_js_1.mapOutputValues)(outputKeys, writes, this.channels).next().value;
+            const metadataWrites = (0, io_js_1.mapOutputUpdates)(this.outputKeys, this.tasks).next().value;
             await this._putCheckpoint({
                 source: "loop",
                 writes: metadataWrites ?? null,
@@ -308,8 +325,7 @@ class PregelLoop {
         // if there are pending writes from a previous loop, apply them
         if (this.checkpointPendingWrites.length > 0) {
             for (const [tid, k, v] of this.checkpointPendingWrites) {
-                // TODO: Do the same for INTERRUPT
-                if (k === constants_js_1.ERROR) {
+                if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT) {
                     continue;
                 }
                 const task = this.tasks.find((t) => t.id === tid);
@@ -321,7 +337,6 @@ class PregelLoop {
         // if all tasks have finished, re-tick
         if (this.tasks.every((task) => task.writes.length > 0)) {
             return this.tick({
-                outputKeys,
                 interruptAfter,
                 interruptBefore,
                 manager,

package/dist/pregel/loop.d.ts

@@ -9,6 +9,8 @@ export type PregelLoopInitializeParams = {
     config: RunnableConfig;
     checkpointer?: BaseCheckpointSaver;
     graph: PregelInterface<any, any>;
+    outputKeys: string | string[];
+    streamKeys: string | string[];
     onBackgroundError: (e: Error) => void;
 };
 type PregelLoopParams = {
@@ -24,6 +26,8 @@ type PregelLoopParams = {
     channels: Record<string, BaseChannel>;
     step: number;
     stop: number;
+    outputKeys: string | string[];
+    streamKeys: string | string[];
     onBackgroundError: (e: Error) => void;
 };
 export declare class PregelLoop {
@@ -45,6 +49,8 @@ export declare class PregelLoop {
     stream: Deque<[StreamMode, any]>;
     protected isNested: boolean;
     protected _putCheckpointPromise: Promise<unknown>;
+    outputKeys: string | string[];
+    streamKeys: string | string[];
     onBackgroundError: (e: Error) => void;
     get backgroundTasksPromise(): Promise<unknown>;
     constructor(params: PregelLoopParams);
@@ -67,7 +73,6 @@ export declare class PregelLoop {
      * @param params
      */
     tick(params: {
-        outputKeys: string | string[];
         interruptAfter: string[] | All;
         interruptBefore: string[] | All;
         manager?: CallbackManagerForChainRun;

package/dist/pregel/loop.js

@@ -3,11 +3,11 @@ import { copyCheckpoint, emptyCheckpoint, } from "@langchain/langgraph-checkpoin
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
 import { CONFIG_KEY_READ, CONFIG_KEY_RESUMING, ERROR, INPUT, INTERRUPT, } from "../constants.js";
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
-import { gatherIterator, prefixGenerator } from "../utils.js";
+import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapInput, mapOutputUpdates, mapOutputValues } from "./io.js";
 import { EmptyInputError, GraphInterrupt } from "../errors.js";
 import { getNewChannelVersions } from "./utils.js";
-import { mapDebugTasks, mapDebugCheckpoint } from "./debug.js";
+import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, } from "./debug.js";
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
@@ -129,6 +129,18 @@ export class PregelLoop {
             writable: true,
             value: Promise.resolve()
         });
+        Object.defineProperty(this, "outputKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "streamKeys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "onBackgroundError", {
             enumerable: true,
             configurable: true,
@@ -156,6 +168,8 @@ export class PregelLoop {
         this.step = params.step;
         this.stop = params.stop;
         this.isNested = CONFIG_KEY_READ in (this.config.configurable ?? {});
+        this.outputKeys = params.outputKeys;
+        this.streamKeys = params.streamKeys;
         this.onBackgroundError = params.onBackgroundError;
     }
     static async initialize(params) {
@@ -197,6 +211,8 @@ export class PregelLoop {
             stop,
             checkpointPreviousVersions,
             checkpointPendingWrites,
+            outputKeys: params.outputKeys,
+            streamKeys: params.streamKeys,
             onBackgroundError: params.onBackgroundError,
         });
     }
@@ -233,6 +249,11 @@ export class PregelLoop {
             }, writes, taskId)
                 .catch(this.onBackgroundError);
         }
+        const task = this.tasks.find((task) => task.id === taskId);
+        if (task !== undefined) {
+            this.stream.push(...gatherIteratorSync(prefixGenerator(mapOutputUpdates(this.outputKeys, [task]), "updates")));
+            this.stream.push(...gatherIteratorSync(prefixGenerator(mapDebugTaskResults(this.step, [[task, writes]], this.streamKeys), "debug")));
+        }
     }
     /**
      * Execute a single iteration of the Pregel loop.
@@ -240,7 +261,7 @@ export class PregelLoop {
      * @param params
      */
     async tick(params) {
-        const { outputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        const { interruptAfter = [], interruptBefore = [], manager } = params;
         if (this.status !== "pending") {
             throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
         }
@@ -252,15 +273,11 @@ export class PregelLoop {
             // All tasks have finished
             _applyWrites(this.checkpoint, this.channels, this.tasks, this.checkpointerGetNextVersion);
             // produce values output
-            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(outputKeys, writes, this.channels), "values"));
+            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, writes, this.channels), "values"));
             this.stream.push(...valuesOutput);
             // clear pending writes
             this.checkpointPendingWrites = [];
-            const updatesOnly = this.graph.streamMode?.length === 1 &&
-                this.graph.streamMode?.includes("updates");
-            const metadataWrites = updatesOnly
-                ? mapOutputUpdates(outputKeys, this.tasks).next().value
-                : mapOutputValues(outputKeys, writes, this.channels).next().value;
+            const metadataWrites = mapOutputUpdates(this.outputKeys, this.tasks).next().value;
             await this._putCheckpoint({
                 source: "loop",
                 writes: metadataWrites ?? null,
@@ -302,8 +319,7 @@ export class PregelLoop {
         // if there are pending writes from a previous loop, apply them
         if (this.checkpointPendingWrites.length > 0) {
             for (const [tid, k, v] of this.checkpointPendingWrites) {
-                // TODO: Do the same for INTERRUPT
-                if (k === ERROR) {
+                if (k === ERROR || k === INTERRUPT) {
                     continue;
                 }
                 const task = this.tasks.find((t) => t.id === tid);
@@ -315,7 +331,6 @@ export class PregelLoop {
         // if all tasks have finished, re-tick
         if (this.tasks.every((task) => task.writes.length > 0)) {
             return this.tick({
-                outputKeys,
                 interruptAfter,
                 interruptBefore,
                 manager,

package/dist/pregel/retry.cjs

@@ -42,9 +42,7 @@ const DEFAULT_RETRY_ON_HANDLER = (error) => {
 };
 async function* executeTasksWithRetry(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tasks, options
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+tasks, options) {
     const { stepTimeout, retryPolicy } = options ?? {};
     let signal = options?.signal;
     // Start tasks
@@ -71,16 +69,12 @@ tasks, options
         signal?.addEventListener("abort", listener);
     }).finally(() => signal?.removeEventListener("abort", listener));
     while (Object.keys(executingTasksMap).length > 0) {
-        const { task, error } = await Promise.race([
+        const settledTask = await Promise.race([
             ...Object.values(executingTasksMap),
             signalPromise,
         ]);
-        if (error !== undefined) {
-            // TODO: don't stop others if exception is interrupt
-            throw error;
-        }
-        yield task;
-        delete executingTasksMap[task.id];
+        yield settledTask;
+        delete executingTasksMap[settledTask.task.id];
     }
 }
 exports.executeTasksWithRetry = executeTasksWithRetry;
@@ -109,7 +103,7 @@ pregelTask, retryPolicy) {
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
-            if (error.name === errors_js_1.GraphInterrupt.unminifiable_name) {
+            if ((0, errors_js_1.isGraphInterrupt)(error)) {
                 break;
             }
             if (resolvedRetryPolicy === undefined) {

package/dist/pregel/retry.d.ts

@@ -4,8 +4,12 @@ export declare const DEFAULT_INITIAL_INTERVAL = 500;
 export declare const DEFAULT_BACKOFF_FACTOR = 2;
 export declare const DEFAULT_MAX_INTERVAL = 128000;
 export declare const DEFAULT_MAX_RETRIES = 3;
+export type SettledPregelTask = {
+    task: PregelExecutableTask<any, any>;
+    error: Error;
+};
 export declare function executeTasksWithRetry(tasks: PregelExecutableTask<any, any>[], options?: {
     stepTimeout?: number;
     signal?: AbortSignal;
     retryPolicy?: RetryPolicy;
-}): AsyncGenerator<PregelExecutableTask<any, any>>;
+}): AsyncGenerator<SettledPregelTask>;

package/dist/pregel/retry.js

@@ -1,4 +1,4 @@
-import { GraphInterrupt } from "../errors.js";
+import { isGraphInterrupt } from "../errors.js";
 export const DEFAULT_INITIAL_INTERVAL = 500;
 export const DEFAULT_BACKOFF_FACTOR = 2;
 export const DEFAULT_MAX_INTERVAL = 128000;
@@ -39,9 +39,7 @@ const DEFAULT_RETRY_ON_HANDLER = (error) => {
 };
 export async function* executeTasksWithRetry(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tasks, options
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
+tasks, options) {
     const { stepTimeout, retryPolicy } = options ?? {};
     let signal = options?.signal;
     // Start tasks
@@ -68,16 +66,12 @@ tasks, options
         signal?.addEventListener("abort", listener);
     }).finally(() => signal?.removeEventListener("abort", listener));
     while (Object.keys(executingTasksMap).length > 0) {
-        const { task, error } = await Promise.race([
+        const settledTask = await Promise.race([
             ...Object.values(executingTasksMap),
             signalPromise,
         ]);
-        if (error !== undefined) {
-            // TODO: don't stop others if exception is interrupt
-            throw error;
-        }
-        yield task;
-        delete executingTasksMap[task.id];
+        yield settledTask;
+        delete executingTasksMap[settledTask.task.id];
     }
 }
 async function _runWithRetry(
@@ -105,7 +99,7 @@ pregelTask, retryPolicy) {
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
-            if (error.name === GraphInterrupt.unminifiable_name) {
+            if (isGraphInterrupt(error)) {
                 break;
             }
             if (resolvedRetryPolicy === undefined) {

package/dist/pregel/types.d.ts

@@ -3,6 +3,7 @@ import type { PendingWrite, CheckpointMetadata, BaseCheckpointSaver } from "@lan
 import type { BaseChannel } from "../channels/base.js";
 import type { PregelNode } from "./read.js";
 import { RetryPolicy } from "./utils.js";
+import { Interrupt } from "../constants.js";
 export type StreamMode = "values" | "updates" | "debug";
 /**
  * Construct a type with a set of properties K of type T
@@ -49,6 +50,7 @@ export interface PregelTaskDescription {
     readonly id: string;
     readonly name: string;
     readonly error?: unknown;
+    readonly interrupts: Interrupt[];
 }
 export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyKey> {
     readonly name: N;

package/dist/utils.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.gatherIterator = exports.prefixGenerator = exports.RunnableCallable = void 0;
+exports.gatherIteratorSync = exports.gatherIterator = exports.prefixGenerator = exports.RunnableCallable = void 0;
 const runnables_1 = require("@langchain/core/runnables");
 const singletons_1 = require("@langchain/core/singletons");
 class RunnableCallable extends runnables_1.Runnable {
@@ -105,3 +105,11 @@ async function gatherIterator(i) {
     return out;
 }
 exports.gatherIterator = gatherIterator;
+function gatherIteratorSync(i) {
+    const out = [];
+    for (const item of i) {
+        out.push(item);
+    }
+    return out;
+}
+exports.gatherIteratorSync = gatherIteratorSync;

package/dist/utils.d.ts

@@ -22,3 +22,4 @@ export declare function prefixGenerator<T, Prefix extends string>(generator: Gen
 export declare function prefixGenerator<T>(generator: Generator<T>, prefix?: undefined): Generator<T>;
 export declare function prefixGenerator<T, Prefix extends string | undefined = undefined>(generator: Generator<T>, prefix?: Prefix | undefined): Generator<Prefix extends string ? [Prefix, T] : T>;
 export declare function gatherIterator<T>(i: AsyncIterable<T> | Promise<AsyncIterable<T>> | Iterable<T> | Promise<Iterable<T>>): Promise<Array<T>>;
+export declare function gatherIteratorSync<T>(i: Iterable<T>): Array<T>;

package/dist/utils.js

@@ -99,3 +99,10 @@ export async function gatherIterator(i) {
     }
     return out;
 }
+export function gatherIteratorSync(i) {
+    const out = [];
+    for (const item of i) {
+        out.push(item);
+    }
+    return out;
+}

package/dist/web.cjs

@@ -1,6 +1,20 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.Send = exports.BinaryOperatorAggregate = exports.BaseChannel = exports.EmptyChannelError = exports.InvalidUpdateError = exports.GraphValueError = exports.GraphRecursionError = exports.AnnotationRoot = exports.Annotation = exports.messagesStateReducer = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
+exports.BaseCheckpointSaver = exports.emptyCheckpoint = exports.copyCheckpoint = exports.MemorySaver = exports.Send = exports.BinaryOperatorAggregate = exports.BaseChannel = exports.Annotation = exports.messagesStateReducer = exports.MessageGraph = exports.StateGraph = exports.START = exports.Graph = exports.END = void 0;
 var index_js_1 = require("./graph/index.cjs");
 Object.defineProperty(exports, "END", { enumerable: true, get: function () { return index_js_1.END; } });
 Object.defineProperty(exports, "Graph", { enumerable: true, get: function () { return index_js_1.Graph; } });
@@ -9,12 +23,7 @@ Object.defineProperty(exports, "StateGraph", { enumerable: true, get: function (
 Object.defineProperty(exports, "MessageGraph", { enumerable: true, get: function () { return index_js_1.MessageGraph; } });
 Object.defineProperty(exports, "messagesStateReducer", { enumerable: true, get: function () { return index_js_1.messagesStateReducer; } });
 Object.defineProperty(exports, "Annotation", { enumerable: true, get: function () { return index_js_1.Annotation; } });
-Object.defineProperty(exports, "AnnotationRoot", { enumerable: true, get: function () { return index_js_1.AnnotationRoot; } });
-var errors_js_1 = require("./errors.cjs");
-Object.defineProperty(exports, "GraphRecursionError", { enumerable: true, get: function () { return errors_js_1.GraphRecursionError; } });
-Object.defineProperty(exports, "GraphValueError", { enumerable: true, get: function () { return errors_js_1.GraphValueError; } });
-Object.defineProperty(exports, "InvalidUpdateError", { enumerable: true, get: function () { return errors_js_1.InvalidUpdateError; } });
-Object.defineProperty(exports, "EmptyChannelError", { enumerable: true, get: function () { return errors_js_1.EmptyChannelError; } });
+__exportStar(require("./errors.cjs"), exports);
 var index_js_2 = require("./channels/index.cjs");
 Object.defineProperty(exports, "BaseChannel", { enumerable: true, get: function () { return index_js_2.BaseChannel; } });
 Object.defineProperty(exports, "BinaryOperatorAggregate", { enumerable: true, get: function () { return index_js_2.BinaryOperatorAggregate; } });

package/dist/web.d.ts

@@ -1,5 +1,5 @@
-export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, messagesStateReducer, Annotation, AnnotationRoot, type StateDefinition, type SingleReducer, type StateType, type UpdateType, type NodeType, type CompiledGraph, } from "./graph/index.js";
-export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";
+export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, messagesStateReducer, Annotation, type AnnotationRoot, type StateDefinition, type SingleReducer, type StateType, type UpdateType, type NodeType, type CompiledGraph, } from "./graph/index.js";
+export * from "./errors.js";
 export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
 export { type RetryPolicy } from "./pregel/utils.js";
 export { Send } from "./constants.js";

package/dist/web.js

@@ -1,5 +1,5 @@
-export { END, Graph, START, StateGraph, MessageGraph, messagesStateReducer, Annotation, AnnotationRoot, } from "./graph/index.js";
-export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";
+export { END, Graph, START, StateGraph, MessageGraph, messagesStateReducer, Annotation, } from "./graph/index.js";
+export * from "./errors.js";
 export { BaseChannel, BinaryOperatorAggregate, } from "./channels/index.js";
 export { Send } from "./constants.js";
 export { MemorySaver, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "@langchain/langgraph-checkpoint";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -31,7 +31,7 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/core": ">=0.2.20 <0.3.0",
+    "@langchain/core": ">=0.2.31 <0.3.0",
     "@langchain/langgraph-checkpoint": "~0.0.4",
     "@langchain/langgraph-checkpoint-sqlite": "~0.0.1",
     "double-ended-queue": "^2.1.0-0",