@langchain/langgraph 0.1.8 → 0.1.10-rc.0

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.d.ts

@@ -1,11 +1,10 @@
 import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 import { Graph as RunnableGraph } from "@langchain/core/runnables/graph";
-import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { All, BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { PregelNode } from "../pregel/read.js";
 import { Pregel } from "../pregel/index.js";
 import type { PregelParams } from "../pregel/types.js";
 import { BaseChannel } from "../channels/base.js";
-import { All } from "../pregel/types.js";
 import { Send } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
 /** Special reserved node name denoting the start of a graph. */

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/graph/state.cjs

@@ -82,7 +82,7 @@ class StateGraph extends graph_js_1.Graph {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: {}
         });
         // TODO: this doesn't dedupe edges as in py, so worth fixing at some point
         Object.defineProperty(this, "waitingEdges", {
@@ -91,21 +91,50 @@ class StateGraph extends graph_js_1.Graph {
             writable: true,
             value: new Set()
         });
-        if (isStateDefinition(fields) || isAnnotationRoot(fields)) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (isStateGraphArgsWithInputOutputSchemas(fields)) {
+            this.schema = fields.input.spec;
+            this.input = fields.input.spec;
+            this.output = fields.output.spec;
+        }
+        else if (isStateGraphArgsWithStateSchema(fields)) {
+            this.schema = fields.stateSchema.spec;
+            this.input = (fields.input?.spec ?? this.schema);
+            this.output = (fields.output?.spec ?? this.schema);
+        }
+        else if (isStateDefinition(fields) || isAnnotationRoot(fields)) {
             const spec = isAnnotationRoot(fields) ? fields.spec : fields;
-            this.channels = {};
-            for (const [key, val] of Object.entries(spec)) {
-                if (typeof val === "function") {
-                    this.channels[key] = val();
-                }
-                else {
-                    this.channels[key] = val;
-                }
-            }
+            this.schema = spec;
+        }
+        else if (isStateGraphArgs(fields)) {
+            const spec = _getChannels(fields.channels);
+            this.schema = spec;
         }
         else {
-            this.channels = _getChannels(fields.channels);
+            throw new Error("Invalid StateGraph input.");
         }
+        this.input = this.input ?? this.schema;
+        this.output = this.output ?? this.schema;
+        this._addSchema(this.schema);
+        this._addSchema(this.input);
+        this._addSchema(this.output);
         for (const c of Object.values(this.channels)) {
             if (c.lc_graph_name === "BinaryOperatorAggregate") {
                 this.supportMultipleEdges = true;
@@ -119,6 +148,27 @@ class StateGraph extends graph_js_1.Graph {
             ...Array.from(this.waitingEdges).flatMap(([starts, end]) => starts.map((start) => [start, end])),
         ]);
     }
+    _addSchema(stateDefinition) {
+        for (const [key, val] of Object.entries(stateDefinition)) {
+            let channel;
+            if (typeof val === "function") {
+                channel = val();
+            }
+            else {
+                channel = val;
+            }
+            if (this.channels[key] !== undefined) {
+                if (this.channels[key].lc_graph_name !== channel.lc_graph_name) {
+                    if (channel.lc_graph_name !== "LastValue") {
+                        throw new Error(`Channel "${key}" already exists with a different type.`);
+                    }
+                }
+            }
+            else {
+                this.channels[key] = channel;
+            }
+        }
+    }
     addNode(key, action, options) {
         if (key in this.channels) {
             throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
@@ -173,10 +223,10 @@ class StateGraph extends graph_js_1.Graph {
             ...(Array.isArray(interruptAfter) ? interruptAfter : []),
         ]);
         // prepare output channels
-        const stateKeys = Object.keys(this.channels);
-        const outputChannels = stateKeys.length === 1 && stateKeys[0] === ROOT
-            ? stateKeys[0]
-            : stateKeys;
+        const stateKeys = Object.keys(this.schema);
+        const outputChannels = stateKeys.length === 1 && stateKeys[0] === ROOT ? ROOT : stateKeys;
+        const outputKeys = Object.keys(this.output);
+        const streamChannels = outputKeys.length === 1 && outputKeys[0] === ROOT ? ROOT : outputKeys;
         // create empty compiled graph
         const compiled = new CompiledStateGraph({
             builder: this,
@@ -191,7 +241,7 @@ class StateGraph extends graph_js_1.Graph {
             },
             inputChannels: graph_js_1.START,
             outputChannels,
-            streamChannels: outputChannels,
+            streamChannels,
             streamMode: "updates",
         });
         // attach nodes, edges and branches
@@ -229,7 +279,7 @@ function _getChannels(schema) {
 }
 class CompiledStateGraph extends graph_js_1.CompiledGraph {
     attachNode(key, node) {
-        const stateKeys = Object.keys(this.builder.channels);
+        const stateKeys = Object.keys(this.builder.input);
         function getStateKey(key, input) {
             if (!input) {
                 return write_js_1.SKIP_WRITE;
@@ -367,3 +417,20 @@ function isAnnotationRoot(obj) {
         "lc_graph_name" in obj &&
         obj.lc_graph_name === "AnnotationRoot");
 }
+function isStateGraphArgs(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        obj.channels !== undefined);
+}
+function isStateGraphArgsWithStateSchema(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        obj.stateSchema !== undefined);
+}
+function isStateGraphArgsWithInputOutputSchemas(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        obj.stateSchema === undefined &&
+        obj.input !== undefined &&
+        obj.output !== undefined);
+}

package/dist/graph/state.d.ts

@@ -1,8 +1,7 @@
 import { RunnableLike } from "@langchain/core/runnables";
-import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { All, BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, Branch, AddNodeOptions, NodeSpec } from "./graph.js";
-import { All } from "../pregel/types.js";
 import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
 import type { RetryPolicy } from "../pregel/utils.js";
 export type ChannelReducers<Channels extends object> = {
@@ -22,6 +21,15 @@ export type StateGraphNodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutp
 export type StateGraphAddNodeOptions = {
     retryPolicy?: RetryPolicy;
 } & AddNodeOptions;
+export type StateGraphArgsWithStateSchema<SD extends StateDefinition, I extends StateDefinition, O extends StateDefinition> = {
+    stateSchema: AnnotationRoot<SD>;
+    input?: AnnotationRoot<I>;
+    output?: AnnotationRoot<O>;
+};
+export type StateGraphArgsWithInputOutputSchemas<SD extends StateDefinition, O extends StateDefinition = SD> = {
+    input: AnnotationRoot<SD>;
+    output: AnnotationRoot<O>;
+};
 /**
  * A graph whose nodes communicate by reading and writing to a shared state.
  * Each node takes a defined `State` as input and returns a `Partial<State>`.
@@ -84,21 +92,25 @@ export type StateGraphAddNodeOptions = {
  * // }
  * ```
  */
-export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START> extends Graph<N, S, U, StateGraphNodeSpec<S, U>> {
+export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START, I extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, O extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition> extends Graph<N, S, U, StateGraphNodeSpec<S, U>> {
     channels: Record<string, BaseChannel>;
     waitingEdges: Set<[N[], N]>;
-    constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> : StateGraphArgs<S>);
+    schema: StateDefinition;
+    input: I;
+    output: O;
+    constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> | StateGraphArgsWithStateSchema<SD, I, O> | StateGraphArgsWithInputOutputSchemas<SD, O> : StateGraphArgs<S>);
     get allEdges(): Set<[string, string]>;
-    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K>;
+    _addSchema(stateDefinition: StateDefinition): void;
+    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
     compile({ checkpointer, interruptBefore, interruptAfter, }?: {
         checkpointer?: BaseCheckpointSaver;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;
-    }): CompiledStateGraph<S, U, N>;
+    }): CompiledStateGraph<S, U, N, I, O>;
 }
-export declare class CompiledStateGraph<S, U, N extends string = typeof START> extends CompiledGraph<N, S, U> {
-    builder: StateGraph<unknown, S, U, N>;
+export declare class CompiledStateGraph<S, U, N extends string = typeof START, I extends StateDefinition = StateDefinition, O extends StateDefinition = StateDefinition> extends CompiledGraph<N, S, U> {
+    builder: StateGraph<unknown, S, U, N, I, O>;
     attachNode(key: typeof START, node?: never): void;
     attachNode(key: N, node: StateGraphNodeSpec<S, U>): void;
     attachEdge(start: N | N[] | "__start__", end: N | "__end__"): void;

package/dist/graph/state.js

@@ -79,7 +79,7 @@ export class StateGraph extends Graph {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: void 0
+            value: {}
         });
         // TODO: this doesn't dedupe edges as in py, so worth fixing at some point
         Object.defineProperty(this, "waitingEdges", {
@@ -88,21 +88,50 @@ export class StateGraph extends Graph {
             writable: true,
             value: new Set()
         });
-        if (isStateDefinition(fields) || isAnnotationRoot(fields)) {
+        Object.defineProperty(this, "schema", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "input", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "output", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (isStateGraphArgsWithInputOutputSchemas(fields)) {
+            this.schema = fields.input.spec;
+            this.input = fields.input.spec;
+            this.output = fields.output.spec;
+        }
+        else if (isStateGraphArgsWithStateSchema(fields)) {
+            this.schema = fields.stateSchema.spec;
+            this.input = (fields.input?.spec ?? this.schema);
+            this.output = (fields.output?.spec ?? this.schema);
+        }
+        else if (isStateDefinition(fields) || isAnnotationRoot(fields)) {
             const spec = isAnnotationRoot(fields) ? fields.spec : fields;
-            this.channels = {};
-            for (const [key, val] of Object.entries(spec)) {
-                if (typeof val === "function") {
-                    this.channels[key] = val();
-                }
-                else {
-                    this.channels[key] = val;
-                }
-            }
+            this.schema = spec;
+        }
+        else if (isStateGraphArgs(fields)) {
+            const spec = _getChannels(fields.channels);
+            this.schema = spec;
         }
         else {
-            this.channels = _getChannels(fields.channels);
+            throw new Error("Invalid StateGraph input.");
         }
+        this.input = this.input ?? this.schema;
+        this.output = this.output ?? this.schema;
+        this._addSchema(this.schema);
+        this._addSchema(this.input);
+        this._addSchema(this.output);
         for (const c of Object.values(this.channels)) {
             if (c.lc_graph_name === "BinaryOperatorAggregate") {
                 this.supportMultipleEdges = true;
@@ -116,6 +145,27 @@ export class StateGraph extends Graph {
             ...Array.from(this.waitingEdges).flatMap(([starts, end]) => starts.map((start) => [start, end])),
         ]);
     }
+    _addSchema(stateDefinition) {
+        for (const [key, val] of Object.entries(stateDefinition)) {
+            let channel;
+            if (typeof val === "function") {
+                channel = val();
+            }
+            else {
+                channel = val;
+            }
+            if (this.channels[key] !== undefined) {
+                if (this.channels[key].lc_graph_name !== channel.lc_graph_name) {
+                    if (channel.lc_graph_name !== "LastValue") {
+                        throw new Error(`Channel "${key}" already exists with a different type.`);
+                    }
+                }
+            }
+            else {
+                this.channels[key] = channel;
+            }
+        }
+    }
     addNode(key, action, options) {
         if (key in this.channels) {
             throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
@@ -170,10 +220,10 @@ export class StateGraph extends Graph {
             ...(Array.isArray(interruptAfter) ? interruptAfter : []),
         ]);
         // prepare output channels
-        const stateKeys = Object.keys(this.channels);
-        const outputChannels = stateKeys.length === 1 && stateKeys[0] === ROOT
-            ? stateKeys[0]
-            : stateKeys;
+        const stateKeys = Object.keys(this.schema);
+        const outputChannels = stateKeys.length === 1 && stateKeys[0] === ROOT ? ROOT : stateKeys;
+        const outputKeys = Object.keys(this.output);
+        const streamChannels = outputKeys.length === 1 && outputKeys[0] === ROOT ? ROOT : outputKeys;
         // create empty compiled graph
         const compiled = new CompiledStateGraph({
             builder: this,
@@ -188,7 +238,7 @@ export class StateGraph extends Graph {
             },
             inputChannels: START,
             outputChannels,
-            streamChannels: outputChannels,
+            streamChannels,
             streamMode: "updates",
         });
         // attach nodes, edges and branches
@@ -225,7 +275,7 @@ function _getChannels(schema) {
 }
 export class CompiledStateGraph extends CompiledGraph {
     attachNode(key, node) {
-        const stateKeys = Object.keys(this.builder.channels);
+        const stateKeys = Object.keys(this.builder.input);
         function getStateKey(key, input) {
             if (!input) {
                 return SKIP_WRITE;
@@ -362,3 +412,20 @@ function isAnnotationRoot(obj) {
         "lc_graph_name" in obj &&
         obj.lc_graph_name === "AnnotationRoot");
 }
+function isStateGraphArgs(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        obj.channels !== undefined);
+}
+function isStateGraphArgsWithStateSchema(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        obj.stateSchema !== undefined);
+}
+function isStateGraphArgsWithInputOutputSchemas(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        obj.stateSchema === undefined &&
+        obj.input !== undefined &&
+        obj.output !== undefined);
+}

package/dist/prebuilt/agent_executor.d.ts

@@ -18,5 +18,5 @@ export interface AgentExecutorState {
 export declare function createAgentExecutor({ agentRunnable, tools, }: {
     agentRunnable: Runnable;
     tools: Array<Tool> | ToolExecutor;
-}): import("../graph/state.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action">;
+}): import("../graph/state.js").CompiledStateGraph<AgentExecutorState, Partial<AgentExecutorState>, "__start__" | "agent" | "action", import("../graph/annotation.js").StateDefinition, import("../graph/annotation.js").StateDefinition>;
 export {};

package/dist/prebuilt/react_agent_executor.d.ts

@@ -2,11 +2,10 @@ import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
+import { All, BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { START } from "../graph/index.js";
 import { MessagesAnnotation } from "../graph/messages_annotation.js";
 import { CompiledStateGraph } from "../graph/state.js";
-import { All } from "../pregel/types.js";
 import { ToolNode } from "./tool_node.js";
 export interface AgentState {
     messages: BaseMessage[];

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.d.ts

@@ -1,9 +1,9 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite } from "@langchain/langgraph-checkpoint";
+import { All, BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
-import { All, PregelExecutableTask, PregelTaskDescription } from "./types.js";
+import { PregelExecutableTask, PregelTaskDescription } from "./types.js";
 /**
  * Construct a type with a set of properties K of type T
  */

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: [] });
             }
         }
     }