@langchain/langgraph 0.2.38 → 0.2.40

package/dist/prebuilt/index.d.ts

@@ -3,3 +3,4 @@ export { type FunctionCallingExecutorState, createFunctionCallingExecutor, } fro
 export { type AgentState, type CreateReactAgentParams, createReactAgent, } from "./react_agent_executor.js";
 export { type ToolExecutorArgs, type ToolInvocationInterface, ToolExecutor, } from "./tool_executor.js";
 export { ToolNode, toolsCondition, type ToolNodeOptions } from "./tool_node.js";
+export type { HumanInterruptConfig, ActionRequest, HumanInterrupt, HumanResponse, } from "./interrupt.js";

package/dist/prebuilt/interrupt.cjs

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/prebuilt/interrupt.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Configuration interface that defines what actions are allowed for a human interrupt.
+ * This controls the available interaction options when the graph is paused for human input.
+ *
+ * @property {boolean} allow_ignore - Whether the human can choose to ignore/skip the current step
+ * @property {boolean} allow_respond - Whether the human can provide a text response/feedback
+ * @property {boolean} allow_edit - Whether the human can edit the provided content/state
+ * @property {boolean} allow_accept - Whether the human can accept/approve the current state
+ */
+export interface HumanInterruptConfig {
+    allow_ignore: boolean;
+    allow_respond: boolean;
+    allow_edit: boolean;
+    allow_accept: boolean;
+}
+/**
+ * Represents a request for human action within the graph execution.
+ * Contains the action type and any associated arguments needed for the action.
+ *
+ * @property {string} action - The type or name of action being requested (e.g., "Approve XYZ action")
+ * @property {Record<string, any>} args - Key-value pairs of arguments needed for the action
+ */
+export interface ActionRequest {
+    action: string;
+    args: Record<string, any>;
+}
+/**
+ * Represents an interrupt triggered by the graph that requires human intervention.
+ * This is passed to the `interrupt` function when execution is paused for human input.
+ *
+ * @property {ActionRequest} action_request - The specific action being requested from the human
+ * @property {HumanInterruptConfig} config - Configuration defining what actions are allowed
+ * @property {string} [description] - Optional detailed description of what input is needed
+ */
+export interface HumanInterrupt {
+    action_request: ActionRequest;
+    config: HumanInterruptConfig;
+    description?: string;
+}
+/**
+ * The response provided by a human to an interrupt, which is returned when graph execution resumes.
+ *
+ * @property {("accept"|"ignore"|"response"|"edit")} type - The type of response:
+ *   - "accept": Approves the current state without changes
+ *   - "ignore": Skips/ignores the current step
+ *   - "response": Provides text feedback or instructions
+ *   - "edit": Modifies the current state/content
+ * @property {null|string|ActionRequest} args - The response payload:
+ *   - null: For ignore/accept actions
+ *   - string: For text responses
+ *   - ActionRequest: For edit actions with updated content
+ */
+export type HumanResponse = {
+    type: "accept" | "ignore" | "response" | "edit";
+    args: null | string | ActionRequest;
+};

package/dist/prebuilt/interrupt.js

@@ -0,0 +1 @@
+export {};

package/dist/pregel/index.cjs

@@ -824,6 +824,92 @@ class Pregel extends runnables_1.Runnable {
             managed,
         };
     }
+    async _runLoop(params) {
+        const { loop, interruptAfter, interruptBefore, runManager, debug, config } = params;
+        let tickError;
+        try {
+            while (await loop.tick({
+                inputKeys: this.inputChannels,
+                interruptAfter,
+                interruptBefore,
+                manager: runManager,
+            })) {
+                if (debug) {
+                    (0, debug_js_1.printStepCheckpoint)(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
+                }
+                if (debug) {
+                    (0, debug_js_1.printStepTasks)(loop.step, Object.values(loop.tasks));
+                }
+                // 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)(Object.values(loop.tasks).filter((task) => task.writes.length === 0), {
+                    stepTimeout: this.stepTimeout,
+                    signal: config.signal,
+                    retryPolicy: this.retryPolicy,
+                });
+                let graphInterrupt;
+                for await (const { task, error } of taskStream) {
+                    if (error !== undefined) {
+                        if ((0, errors_js_1.isGraphBubbleUp)(error)) {
+                            if (loop.isNested) {
+                                throw error;
+                            }
+                            if ((0, errors_js_1.isGraphInterrupt)(error)) {
+                                graphInterrupt = error;
+                                if (error.interrupts.length) {
+                                    const interrupts = error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]);
+                                    const resumes = task.writes.filter((w) => w[0] === constants_js_1.RESUME);
+                                    if (resumes.length) {
+                                        interrupts.push(...resumes);
+                                    }
+                                    loop.putWrites(task.id, interrupts);
+                                }
+                            }
+                        }
+                        else {
+                            loop.putWrites(task.id, [
+                                [constants_js_1.ERROR, { message: error.message, name: error.name }],
+                            ]);
+                            throw error;
+                        }
+                    }
+                    else {
+                        loop.putWrites(task.id, task.writes);
+                    }
+                }
+                if (debug) {
+                    (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)
+                        .map((task) => task.writes)
+                        .flat(), this.streamChannelsList);
+                }
+                if (graphInterrupt !== undefined) {
+                    throw graphInterrupt;
+                }
+            }
+            if (loop.status === "out_of_steps") {
+                throw new errors_js_1.GraphRecursionError([
+                    `Recursion limit of ${config.recursionLimit} reached`,
+                    "without hitting a stop condition. You can increase the",
+                    `limit by setting the "recursionLimit" config key.`,
+                ].join(" "), {
+                    lc_error_code: "GRAPH_RECURSION_LIMIT",
+                });
+            }
+        }
+        catch (e) {
+            tickError = e;
+            const suppress = await loop.finishAndHandleError(tickError);
+            if (!suppress) {
+                throw e;
+            }
+        }
+        finally {
+            if (tickError === undefined) {
+                await loop.finishAndHandleError();
+            }
+        }
+    }
     async *_streamIterator(input, options) {
         const streamSubgraphs = options?.subgraphs;
         const inputConfig = (0, config_js_1.ensureLangGraphConfig)(this.config, options);
@@ -867,7 +953,15 @@ class Pregel extends runnables_1.Runnable {
         const { channelSpecs, managed } = await this.prepareSpecs(config);
         let loop;
         let loopError;
-        const runLoop = async () => {
+        /**
+         * The PregelLoop will yield events from concurrent tasks as soon as they are
+         * generated. Each task can push multiple events onto the stream in any order.
+         *
+         * We use a separate background method and stream here in order to yield events
+         * from the loop to the main stream and therefore back to the user as soon as
+         * they are available.
+         */
+        const createAndRunLoop = async () => {
             try {
                 loop = await loop_js_1.PregelLoop.initialize({
                     input,
@@ -887,68 +981,14 @@ class Pregel extends runnables_1.Runnable {
                         [constants_js_1.CONFIG_KEY_STREAM]: loop.stream,
                     };
                 }
-                while (await loop.tick({
-                    inputKeys: this.inputChannels,
+                await this._runLoop({
+                    loop,
                     interruptAfter,
                     interruptBefore,
-                    manager: runManager,
-                })) {
-                    if (debug) {
-                        (0, debug_js_1.printStepCheckpoint)(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
-                    }
-                    if (debug) {
-                        (0, debug_js_1.printStepTasks)(loop.step, Object.values(loop.tasks));
-                    }
-                    // 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)(Object.values(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.isGraphBubbleUp)(error)) {
-                                if (loop.isNested) {
-                                    throw error;
-                                }
-                                if ((0, errors_js_1.isGraphInterrupt)(error) && error.interrupts.length) {
-                                    const interrupts = error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]);
-                                    const resumes = task.writes.filter((w) => w[0] === constants_js_1.RESUME);
-                                    if (resumes.length) {
-                                        interrupts.push(...resumes);
-                                    }
-                                    loop.putWrites(task.id, interrupts);
-                                }
-                            }
-                            else {
-                                loop.putWrites(task.id, [
-                                    [constants_js_1.ERROR, { message: error.message, name: error.name }],
-                                ]);
-                                throw error;
-                            }
-                        }
-                        else {
-                            loop.putWrites(task.id, task.writes);
-                        }
-                    }
-                    if (debug) {
-                        (0, debug_js_1.printStepWrites)(loop.step, Object.values(loop.tasks)
-                            .map((task) => task.writes)
-                            .flat(), this.streamChannelsList);
-                    }
-                }
-                if (loop.status === "out_of_steps") {
-                    throw new errors_js_1.GraphRecursionError([
-                        `Recursion limit of ${config.recursionLimit} reached`,
-                        "without hitting a stop condition. You can increase the",
-                        `limit by setting the "recursionLimit" config key.`,
-                    ].join(" "), {
-                        lc_error_code: "GRAPH_RECURSION_LIMIT",
-                    });
-                }
+                    runManager,
+                    debug,
+                    config,
+                });
             }
             catch (e) {
                 loopError = e;
@@ -982,7 +1022,7 @@ class Pregel extends runnables_1.Runnable {
                 }
             }
         };
-        const runLoopPromise = runLoop();
+        const runLoopPromise = createAndRunLoop();
         try {
             for await (const chunk of stream) {
                 if (chunk === undefined) {

package/dist/pregel/index.d.ts

@@ -1,5 +1,6 @@
 import { Runnable, RunnableConfig, RunnableFunc } from "@langchain/core/runnables";
 import { IterableReadableStream } from "@langchain/core/utils/stream";
+import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
 import { All, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointTuple } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
@@ -8,6 +9,7 @@ import { Command } from "../constants.js";
 import { PregelInterface, PregelParams, StateSnapshot, StreamMode, PregelInputType, PregelOutputType, PregelOptions } from "./types.js";
 import { StrRecord } from "./algo.js";
 import { RetryPolicy } from "./utils/index.js";
+import { PregelLoop } from "./loop.js";
 import { ManagedValueMapping, type ManagedValueSpec } from "../managed/base.js";
 import { LangGraphRunnableConfig } from "./runnable_types.js";
 type WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;
@@ -110,6 +112,14 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
         channelSpecs: Record<string, BaseChannel<unknown, unknown, unknown>>;
         managed: ManagedValueMapping;
     }>;
+    _runLoop(params: {
+        loop: PregelLoop;
+        interruptAfter: string[] | "*";
+        interruptBefore: string[] | "*";
+        runManager?: CallbackManagerForChainRun;
+        debug: boolean;
+        config: LangGraphRunnableConfig;
+    }): Promise<void>;
     _streamIterator(input: PregelInputType | Command, options?: Partial<PregelOptions<Nn, Cc>>): AsyncGenerator<PregelOutputType>;
     /**
      * Run the graph with a single input and config.

package/dist/pregel/index.js

@@ -820,6 +820,92 @@ export class Pregel extends Runnable {
             managed,
         };
     }
+    async _runLoop(params) {
+        const { loop, interruptAfter, interruptBefore, runManager, debug, config } = params;
+        let tickError;
+        try {
+            while (await loop.tick({
+                inputKeys: this.inputChannels,
+                interruptAfter,
+                interruptBefore,
+                manager: runManager,
+            })) {
+                if (debug) {
+                    printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
+                }
+                if (debug) {
+                    printStepTasks(loop.step, Object.values(loop.tasks));
+                }
+                // 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(Object.values(loop.tasks).filter((task) => task.writes.length === 0), {
+                    stepTimeout: this.stepTimeout,
+                    signal: config.signal,
+                    retryPolicy: this.retryPolicy,
+                });
+                let graphInterrupt;
+                for await (const { task, error } of taskStream) {
+                    if (error !== undefined) {
+                        if (isGraphBubbleUp(error)) {
+                            if (loop.isNested) {
+                                throw error;
+                            }
+                            if (isGraphInterrupt(error)) {
+                                graphInterrupt = error;
+                                if (error.interrupts.length) {
+                                    const interrupts = error.interrupts.map((interrupt) => [INTERRUPT, interrupt]);
+                                    const resumes = task.writes.filter((w) => w[0] === RESUME);
+                                    if (resumes.length) {
+                                        interrupts.push(...resumes);
+                                    }
+                                    loop.putWrites(task.id, interrupts);
+                                }
+                            }
+                        }
+                        else {
+                            loop.putWrites(task.id, [
+                                [ERROR, { message: error.message, name: error.name }],
+                            ]);
+                            throw error;
+                        }
+                    }
+                    else {
+                        loop.putWrites(task.id, task.writes);
+                    }
+                }
+                if (debug) {
+                    printStepWrites(loop.step, Object.values(loop.tasks)
+                        .map((task) => task.writes)
+                        .flat(), this.streamChannelsList);
+                }
+                if (graphInterrupt !== undefined) {
+                    throw graphInterrupt;
+                }
+            }
+            if (loop.status === "out_of_steps") {
+                throw new GraphRecursionError([
+                    `Recursion limit of ${config.recursionLimit} reached`,
+                    "without hitting a stop condition. You can increase the",
+                    `limit by setting the "recursionLimit" config key.`,
+                ].join(" "), {
+                    lc_error_code: "GRAPH_RECURSION_LIMIT",
+                });
+            }
+        }
+        catch (e) {
+            tickError = e;
+            const suppress = await loop.finishAndHandleError(tickError);
+            if (!suppress) {
+                throw e;
+            }
+        }
+        finally {
+            if (tickError === undefined) {
+                await loop.finishAndHandleError();
+            }
+        }
+    }
     async *_streamIterator(input, options) {
         const streamSubgraphs = options?.subgraphs;
         const inputConfig = ensureLangGraphConfig(this.config, options);
@@ -863,7 +949,15 @@ export class Pregel extends Runnable {
         const { channelSpecs, managed } = await this.prepareSpecs(config);
         let loop;
         let loopError;
-        const runLoop = async () => {
+        /**
+         * The PregelLoop will yield events from concurrent tasks as soon as they are
+         * generated. Each task can push multiple events onto the stream in any order.
+         *
+         * We use a separate background method and stream here in order to yield events
+         * from the loop to the main stream and therefore back to the user as soon as
+         * they are available.
+         */
+        const createAndRunLoop = async () => {
             try {
                 loop = await PregelLoop.initialize({
                     input,
@@ -883,68 +977,14 @@ export class Pregel extends Runnable {
                         [CONFIG_KEY_STREAM]: loop.stream,
                     };
                 }
-                while (await loop.tick({
-                    inputKeys: this.inputChannels,
+                await this._runLoop({
+                    loop,
                     interruptAfter,
                     interruptBefore,
-                    manager: runManager,
-                })) {
-                    if (debug) {
-                        printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
-                    }
-                    if (debug) {
-                        printStepTasks(loop.step, Object.values(loop.tasks));
-                    }
-                    // 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(Object.values(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 (isGraphBubbleUp(error)) {
-                                if (loop.isNested) {
-                                    throw error;
-                                }
-                                if (isGraphInterrupt(error) && error.interrupts.length) {
-                                    const interrupts = error.interrupts.map((interrupt) => [INTERRUPT, interrupt]);
-                                    const resumes = task.writes.filter((w) => w[0] === RESUME);
-                                    if (resumes.length) {
-                                        interrupts.push(...resumes);
-                                    }
-                                    loop.putWrites(task.id, interrupts);
-                                }
-                            }
-                            else {
-                                loop.putWrites(task.id, [
-                                    [ERROR, { message: error.message, name: error.name }],
-                                ]);
-                                throw error;
-                            }
-                        }
-                        else {
-                            loop.putWrites(task.id, task.writes);
-                        }
-                    }
-                    if (debug) {
-                        printStepWrites(loop.step, Object.values(loop.tasks)
-                            .map((task) => task.writes)
-                            .flat(), this.streamChannelsList);
-                    }
-                }
-                if (loop.status === "out_of_steps") {
-                    throw new GraphRecursionError([
-                        `Recursion limit of ${config.recursionLimit} reached`,
-                        "without hitting a stop condition. You can increase the",
-                        `limit by setting the "recursionLimit" config key.`,
-                    ].join(" "), {
-                        lc_error_code: "GRAPH_RECURSION_LIMIT",
-                    });
-                }
+                    runManager,
+                    debug,
+                    config,
+                });
             }
             catch (e) {
                 loopError = e;
@@ -978,7 +1018,7 @@ export class Pregel extends Runnable {
                 }
             }
         };
-        const runLoopPromise = runLoop();
+        const runLoopPromise = createAndRunLoop();
         try {
             for await (const chunk of stream) {
                 if (chunk === undefined) {

package/dist/pregel/io.cjs

@@ -94,8 +94,15 @@ function* mapCommand(cmd, pendingWrites) {
         if (typeof cmd.update !== "object" || !cmd.update) {
             throw new Error("Expected cmd.update to be a dict mapping channel names to update values");
         }
-        for (const [k, v] of Object.entries(cmd.update)) {
-            yield [constants_js_1.NULL_TASK_ID, k, v];
+        if (Array.isArray(cmd.update)) {
+            for (const [k, v] of cmd.update) {
+                yield [constants_js_1.NULL_TASK_ID, k, v];
+            }
+        }
+        else {
+            for (const [k, v] of Object.entries(cmd.update)) {
+                yield [constants_js_1.NULL_TASK_ID, k, v];
+            }
         }
     }
 }
@@ -154,8 +161,10 @@ exports.mapOutputValues = mapOutputValues;
 function* mapOutputUpdates(outputChannels, tasks, cached
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
-    const outputTasks = tasks.filter(([task]) => {
-        return task.config === undefined || !task.config.tags?.includes(constants_js_1.TAG_HIDDEN);
+    const outputTasks = tasks.filter(([task, ww]) => {
+        return ((task.config === undefined || !task.config.tags?.includes(constants_js_1.TAG_HIDDEN)) &&
+            ww[0][0] !== constants_js_1.ERROR &&
+            ww[0][0] !== constants_js_1.INTERRUPT);
     });
     if (!outputTasks.length) {
         return;

package/dist/pregel/io.js

@@ -1,5 +1,5 @@
 import { validate } from "uuid";
-import { _isSend, Command, NULL_TASK_ID, RESUME, SELF, TAG_HIDDEN, TASKS, } from "../constants.js";
+import { _isSend, Command, ERROR, INTERRUPT, NULL_TASK_ID, RESUME, SELF, TAG_HIDDEN, TASKS, } from "../constants.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 export function readChannel(channels, chan, catchErrors = true, returnException = false) {
     try {
@@ -89,8 +89,15 @@ export function* mapCommand(cmd, pendingWrites) {
         if (typeof cmd.update !== "object" || !cmd.update) {
             throw new Error("Expected cmd.update to be a dict mapping channel names to update values");
         }
-        for (const [k, v] of Object.entries(cmd.update)) {
-            yield [NULL_TASK_ID, k, v];
+        if (Array.isArray(cmd.update)) {
+            for (const [k, v] of cmd.update) {
+                yield [NULL_TASK_ID, k, v];
+            }
+        }
+        else {
+            for (const [k, v] of Object.entries(cmd.update)) {
+                yield [NULL_TASK_ID, k, v];
+            }
         }
     }
 }
@@ -146,8 +153,10 @@ export function* mapOutputValues(outputChannels, pendingWrites, channels
 export function* mapOutputUpdates(outputChannels, tasks, cached
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 ) {
-    const outputTasks = tasks.filter(([task]) => {
-        return task.config === undefined || !task.config.tags?.includes(TAG_HIDDEN);
+    const outputTasks = tasks.filter(([task, ww]) => {
+        return ((task.config === undefined || !task.config.tags?.includes(TAG_HIDDEN)) &&
+            ww[0][0] !== ERROR &&
+            ww[0][0] !== INTERRUPT);
     });
     if (!outputTasks.length) {
         return;

package/dist/pregel/loop.cjs

@@ -455,125 +455,125 @@ class PregelLoop {
      * @param params
      */
     async tick(params) {
-        let tickError;
-        try {
-            if (this.store && !this.store.isRunning) {
-                this.store?.start();
-            }
-            const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
-            if (this.status !== "pending") {
-                throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
-            }
-            if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
-                await this._first(inputKeys);
-            }
-            else if (Object.values(this.tasks).every((task) => task.writes.filter(([c]) => !(c in langgraph_checkpoint_1.WRITES_IDX_MAP)).length > 0)) {
-                const writes = Object.values(this.tasks).flatMap((t) => t.writes);
-                // All tasks have finished
-                const managedValueWrites = (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
-                for (const [key, values] of Object.entries(managedValueWrites)) {
-                    await this.updateManagedValues(key, values);
-                }
-                // produce values output
-                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._emit(valuesOutput);
-                // clear pending writes
-                this.checkpointPendingWrites = [];
-                await this._putCheckpoint({
-                    source: "loop",
-                    writes: (0, io_js_1.mapOutputUpdates)(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
-                });
-                // after execution, check if we should interrupt
-                if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
-                    this.status = "interrupt_after";
-                    if (this.isNested) {
-                        throw new errors_js_1.GraphInterrupt();
-                    }
-                    else {
-                        return false;
-                    }
-                }
-            }
-            else {
-                return false;
-            }
-            if (this.step > this.stop) {
-                this.status = "out_of_steps";
-                return false;
+        if (this.store && !this.store.isRunning) {
+            this.store?.start();
+        }
+        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        if (this.status !== "pending") {
+            throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
+        }
+        if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
+            await this._first(inputKeys);
+        }
+        else if (Object.values(this.tasks).every((task) => task.writes.filter(([c]) => !(c in langgraph_checkpoint_1.WRITES_IDX_MAP)).length > 0)) {
+            const writes = Object.values(this.tasks).flatMap((t) => t.writes);
+            // All tasks have finished
+            const managedValueWrites = (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
+            for (const [key, values] of Object.entries(managedValueWrites)) {
+                await this.updateManagedValues(key, values);
             }
-            const nextTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
-                step: this.step,
-                checkpointer: this.checkpointer,
-                isResuming: this.input === INPUT_RESUMING,
-                manager,
-                store: this.store,
+            // produce values output
+            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._emit(valuesOutput);
+            // clear pending writes
+            this.checkpointPendingWrites = [];
+            await this._putCheckpoint({
+                source: "loop",
+                writes: (0, io_js_1.mapOutputUpdates)(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
             });
-            this.tasks = nextTasks;
-            // Produce debug output
-            if (this.checkpointer) {
-                this._emit(await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugCheckpoint)(this.step - 1, // printing checkpoint for previous step
-                this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites, this.prevCheckpointConfig), "debug")));
-            }
-            if (Object.values(this.tasks).length === 0) {
-                this.status = "done";
-                return false;
+            // after execution, check if we should interrupt
+            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+                this.status = "interrupt_after";
+                throw new errors_js_1.GraphInterrupt();
             }
-            // if there are pending writes from a previous loop, apply them
-            if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
-                for (const [tid, k, v] of this.checkpointPendingWrites) {
-                    if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT || k === constants_js_1.RESUME) {
-                        continue;
-                    }
-                    const task = Object.values(this.tasks).find((t) => t.id === tid);
-                    if (task) {
-                        task.writes.push([k, v]);
-                    }
+        }
+        else {
+            return false;
+        }
+        if (this.step > this.stop) {
+            this.status = "out_of_steps";
+            return false;
+        }
+        const nextTasks = (0, algo_js_1._prepareNextTasks)(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
+            step: this.step,
+            checkpointer: this.checkpointer,
+            isResuming: this.input === INPUT_RESUMING,
+            manager,
+            store: this.store,
+        });
+        this.tasks = nextTasks;
+        // Produce debug output
+        if (this.checkpointer) {
+            this._emit(await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugCheckpoint)(this.step - 1, // printing checkpoint for previous step
+            this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites, this.prevCheckpointConfig), "debug")));
+        }
+        if (Object.values(this.tasks).length === 0) {
+            this.status = "done";
+            return false;
+        }
+        // if there are pending writes from a previous loop, apply them
+        if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
+            for (const [tid, k, v] of this.checkpointPendingWrites) {
+                if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT || k === constants_js_1.RESUME) {
+                    continue;
                 }
-                for (const task of Object.values(this.tasks)) {
-                    if (task.writes.length > 0) {
-                        this._outputWrites(task.id, task.writes, true);
-                    }
+                const task = Object.values(this.tasks).find((t) => t.id === tid);
+                if (task) {
+                    task.writes.push([k, v]);
                 }
             }
-            // if all tasks have finished, re-tick
-            if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
-                return this.tick({
-                    inputKeys,
-                    interruptAfter,
-                    interruptBefore,
-                    manager,
-                });
-            }
-            // Before execution, check if we should interrupt
-            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
-                this.status = "interrupt_before";
-                if (this.isNested) {
-                    throw new errors_js_1.GraphInterrupt();
-                }
-                else {
-                    return false;
+            for (const task of Object.values(this.tasks)) {
+                if (task.writes.length > 0) {
+                    this._outputWrites(task.id, task.writes, true);
                 }
             }
-            // Produce debug output
-            const debugOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTasks)(this.step, Object.values(this.tasks)), "debug"));
-            this._emit(debugOutput);
-            return true;
         }
-        catch (e) {
-            tickError = e;
-            if (!this._suppressInterrupt(tickError)) {
-                throw tickError;
-            }
-            else {
-                this.output = (0, io_js_1.readChannels)(this.channels, this.outputKeys);
-            }
-            return false;
+        // if all tasks have finished, re-tick
+        if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+            return this.tick({
+                inputKeys,
+                interruptAfter,
+                interruptBefore,
+                manager,
+            });
+        }
+        // Before execution, check if we should interrupt
+        if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+            this.status = "interrupt_before";
+            throw new errors_js_1.GraphInterrupt();
         }
-        finally {
-            if (tickError === undefined) {
-                this.output = (0, io_js_1.readChannels)(this.channels, this.outputKeys);
+        // Produce debug output
+        const debugOutput = await (0, utils_js_1.gatherIterator)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTasks)(this.step, Object.values(this.tasks)), "debug"));
+        this._emit(debugOutput);
+        return true;
+    }
+    async finishAndHandleError(error) {
+        const suppress = this._suppressInterrupt(error);
+        if (suppress || error === undefined) {
+            this.output = (0, io_js_1.readChannels)(this.channels, this.outputKeys);
+        }
+        if (suppress) {
+            // emit one last "values" event, with pending writes applied
+            if (this.tasks !== undefined &&
+                this.checkpointPendingWrites.length > 0 &&
+                Object.values(this.tasks).some((task) => task.writes.length > 0)) {
+                const managedValueWrites = (0, algo_js_1._applyWrites)(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
+                for (const [key, values] of Object.entries(managedValueWrites)) {
+                    await this.updateManagedValues(key, values);
+                }
+                this._emit((0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputValues)(this.outputKeys, Object.values(this.tasks).flatMap((t) => t.writes), this.channels), "values")));
             }
+            // Emit INTERRUPT event
+            this._emit([
+                [
+                    "updates",
+                    {
+                        [constants_js_1.INTERRUPT]: error.interrupts,
+                    },
+                ],
+            ]);
         }
+        return suppress;
     }
     _suppressInterrupt(e) {
         return (0, errors_js_1.isGraphInterrupt)(e) && !this.isNested;

package/dist/pregel/loop.d.ts

@@ -112,6 +112,7 @@ export declare class PregelLoop {
         interruptBefore: string[] | All;
         manager?: CallbackManagerForChainRun;
     }): Promise<boolean>;
+    finishAndHandleError(error?: Error): Promise<boolean>;
     protected _suppressInterrupt(e?: Error): boolean;
     /**
      * Resuming from previous checkpoint requires

package/dist/pregel/loop.js

@@ -451,125 +451,125 @@ export class PregelLoop {
      * @param params
      */
     async tick(params) {
-        let tickError;
-        try {
-            if (this.store && !this.store.isRunning) {
-                this.store?.start();
-            }
-            const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
-            if (this.status !== "pending") {
-                throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
-            }
-            if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
-                await this._first(inputKeys);
-            }
-            else if (Object.values(this.tasks).every((task) => task.writes.filter(([c]) => !(c in WRITES_IDX_MAP)).length > 0)) {
-                const writes = Object.values(this.tasks).flatMap((t) => t.writes);
-                // All tasks have finished
-                const managedValueWrites = _applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
-                for (const [key, values] of Object.entries(managedValueWrites)) {
-                    await this.updateManagedValues(key, values);
-                }
-                // produce values output
-                const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, writes, this.channels), "values"));
-                this._emit(valuesOutput);
-                // clear pending writes
-                this.checkpointPendingWrites = [];
-                await this._putCheckpoint({
-                    source: "loop",
-                    writes: mapOutputUpdates(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
-                });
-                // after execution, check if we should interrupt
-                if (shouldInterrupt(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
-                    this.status = "interrupt_after";
-                    if (this.isNested) {
-                        throw new GraphInterrupt();
-                    }
-                    else {
-                        return false;
-                    }
-                }
-            }
-            else {
-                return false;
-            }
-            if (this.step > this.stop) {
-                this.status = "out_of_steps";
-                return false;
+        if (this.store && !this.store.isRunning) {
+            this.store?.start();
+        }
+        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        if (this.status !== "pending") {
+            throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
+        }
+        if (![INPUT_DONE, INPUT_RESUMING].includes(this.input)) {
+            await this._first(inputKeys);
+        }
+        else if (Object.values(this.tasks).every((task) => task.writes.filter(([c]) => !(c in WRITES_IDX_MAP)).length > 0)) {
+            const writes = Object.values(this.tasks).flatMap((t) => t.writes);
+            // All tasks have finished
+            const managedValueWrites = _applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
+            for (const [key, values] of Object.entries(managedValueWrites)) {
+                await this.updateManagedValues(key, values);
             }
-            const nextTasks = _prepareNextTasks(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
-                step: this.step,
-                checkpointer: this.checkpointer,
-                isResuming: this.input === INPUT_RESUMING,
-                manager,
-                store: this.store,
+            // produce values output
+            const valuesOutput = await gatherIterator(prefixGenerator(mapOutputValues(this.outputKeys, writes, this.channels), "values"));
+            this._emit(valuesOutput);
+            // clear pending writes
+            this.checkpointPendingWrites = [];
+            await this._putCheckpoint({
+                source: "loop",
+                writes: mapOutputUpdates(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
             });
-            this.tasks = nextTasks;
-            // Produce debug output
-            if (this.checkpointer) {
-                this._emit(await gatherIterator(prefixGenerator(mapDebugCheckpoint(this.step - 1, // printing checkpoint for previous step
-                this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites, this.prevCheckpointConfig), "debug")));
-            }
-            if (Object.values(this.tasks).length === 0) {
-                this.status = "done";
-                return false;
+            // after execution, check if we should interrupt
+            if (shouldInterrupt(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+                this.status = "interrupt_after";
+                throw new GraphInterrupt();
             }
-            // if there are pending writes from a previous loop, apply them
-            if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
-                for (const [tid, k, v] of this.checkpointPendingWrites) {
-                    if (k === ERROR || k === INTERRUPT || k === RESUME) {
-                        continue;
-                    }
-                    const task = Object.values(this.tasks).find((t) => t.id === tid);
-                    if (task) {
-                        task.writes.push([k, v]);
-                    }
+        }
+        else {
+            return false;
+        }
+        if (this.step > this.stop) {
+            this.status = "out_of_steps";
+            return false;
+        }
+        const nextTasks = _prepareNextTasks(this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
+            step: this.step,
+            checkpointer: this.checkpointer,
+            isResuming: this.input === INPUT_RESUMING,
+            manager,
+            store: this.store,
+        });
+        this.tasks = nextTasks;
+        // Produce debug output
+        if (this.checkpointer) {
+            this._emit(await gatherIterator(prefixGenerator(mapDebugCheckpoint(this.step - 1, // printing checkpoint for previous step
+            this.checkpointConfig, this.channels, this.streamKeys, this.checkpointMetadata, Object.values(this.tasks), this.checkpointPendingWrites, this.prevCheckpointConfig), "debug")));
+        }
+        if (Object.values(this.tasks).length === 0) {
+            this.status = "done";
+            return false;
+        }
+        // if there are pending writes from a previous loop, apply them
+        if (this.skipDoneTasks && this.checkpointPendingWrites.length > 0) {
+            for (const [tid, k, v] of this.checkpointPendingWrites) {
+                if (k === ERROR || k === INTERRUPT || k === RESUME) {
+                    continue;
                 }
-                for (const task of Object.values(this.tasks)) {
-                    if (task.writes.length > 0) {
-                        this._outputWrites(task.id, task.writes, true);
-                    }
+                const task = Object.values(this.tasks).find((t) => t.id === tid);
+                if (task) {
+                    task.writes.push([k, v]);
                 }
             }
-            // if all tasks have finished, re-tick
-            if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
-                return this.tick({
-                    inputKeys,
-                    interruptAfter,
-                    interruptBefore,
-                    manager,
-                });
-            }
-            // Before execution, check if we should interrupt
-            if (shouldInterrupt(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
-                this.status = "interrupt_before";
-                if (this.isNested) {
-                    throw new GraphInterrupt();
-                }
-                else {
-                    return false;
+            for (const task of Object.values(this.tasks)) {
+                if (task.writes.length > 0) {
+                    this._outputWrites(task.id, task.writes, true);
                 }
             }
-            // Produce debug output
-            const debugOutput = await gatherIterator(prefixGenerator(mapDebugTasks(this.step, Object.values(this.tasks)), "debug"));
-            this._emit(debugOutput);
-            return true;
         }
-        catch (e) {
-            tickError = e;
-            if (!this._suppressInterrupt(tickError)) {
-                throw tickError;
-            }
-            else {
-                this.output = readChannels(this.channels, this.outputKeys);
-            }
-            return false;
+        // if all tasks have finished, re-tick
+        if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
+            return this.tick({
+                inputKeys,
+                interruptAfter,
+                interruptBefore,
+                manager,
+            });
+        }
+        // Before execution, check if we should interrupt
+        if (shouldInterrupt(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+            this.status = "interrupt_before";
+            throw new GraphInterrupt();
         }
-        finally {
-            if (tickError === undefined) {
-                this.output = readChannels(this.channels, this.outputKeys);
+        // Produce debug output
+        const debugOutput = await gatherIterator(prefixGenerator(mapDebugTasks(this.step, Object.values(this.tasks)), "debug"));
+        this._emit(debugOutput);
+        return true;
+    }
+    async finishAndHandleError(error) {
+        const suppress = this._suppressInterrupt(error);
+        if (suppress || error === undefined) {
+            this.output = readChannels(this.channels, this.outputKeys);
+        }
+        if (suppress) {
+            // emit one last "values" event, with pending writes applied
+            if (this.tasks !== undefined &&
+                this.checkpointPendingWrites.length > 0 &&
+                Object.values(this.tasks).some((task) => task.writes.length > 0)) {
+                const managedValueWrites = _applyWrites(this.checkpoint, this.channels, Object.values(this.tasks), this.checkpointerGetNextVersion);
+                for (const [key, values] of Object.entries(managedValueWrites)) {
+                    await this.updateManagedValues(key, values);
+                }
+                this._emit(gatherIteratorSync(prefixGenerator(mapOutputValues(this.outputKeys, Object.values(this.tasks).flatMap((t) => t.writes), this.channels), "values")));
             }
+            // Emit INTERRUPT event
+            this._emit([
+                [
+                    "updates",
+                    {
+                        [INTERRUPT]: error.interrupts,
+                    },
+                ],
+            ]);
         }
+        return suppress;
     }
     _suppressInterrupt(e) {
         return isGraphInterrupt(e) && !this.isNested;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.38",
+  "version": "0.2.40",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -72,7 +72,7 @@
     "pg": "^8.13.0",
     "prettier": "^2.8.3",
     "release-it": "^17.6.0",
-    "rollup": "^4.24.1",
+    "rollup": "^4.29.0",
     "ts-jest": "^29.1.0",
     "tsx": "^4.7.0",
     "typescript": "^4.9.5 || ^5.4.5",