@langchain/langgraph 0.2.40 → 0.2.42

package/dist/pregel/index.cjs

@@ -16,11 +16,12 @@ const algo_js_1 = require("./algo.cjs");
 const index_js_1 = require("./utils/index.cjs");
 const subgraph_js_1 = require("./utils/subgraph.cjs");
 const loop_js_1 = require("./loop.cjs");
-const retry_js_1 = require("./retry.cjs");
 const base_js_2 = require("../managed/base.cjs");
 const utils_js_1 = require("../utils.cjs");
 const config_js_1 = require("./utils/config.cjs");
 const messages_js_1 = require("./messages.cjs");
+const runner_js_1 = require("./runner.cjs");
+const stream_js_1 = require("./stream.cjs");
 function isString(value) {
     return typeof value === "string";
 }
@@ -824,92 +825,6 @@ 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);
@@ -925,7 +840,7 @@ class Pregel extends runnables_1.Runnable {
         const { runId, ...restConfig } = inputConfig;
         // assign defaults
         const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer, store, streamModeSingle,] = this._defaults(restConfig);
-        const stream = new loop_js_1.IterableReadableWritableStream({
+        const stream = new stream_js_1.IterableReadableWritableStream({
             modes: new Set(streamMode),
         });
         // set up messages stream mode
@@ -974,6 +889,14 @@ class Pregel extends runnables_1.Runnable {
                     streamKeys: this.streamChannelsAsIs,
                     store,
                     stream,
+                    interruptAfter,
+                    interruptBefore,
+                    manager: runManager,
+                    debug: this.debug,
+                });
+                const runner = new runner_js_1.PregelRunner({
+                    loop,
+                    nodeFinished: config.configurable?.nodeFinished,
                 });
                 if (options?.subgraphs) {
                     loop.config.configurable = {
@@ -981,14 +904,7 @@ class Pregel extends runnables_1.Runnable {
                         [constants_js_1.CONFIG_KEY_STREAM]: loop.stream,
                     };
                 }
-                await this._runLoop({
-                    loop,
-                    interruptAfter,
-                    interruptBefore,
-                    runManager,
-                    debug,
-                    config,
-                });
+                await this._runLoop({ loop, runner, debug, config });
             }
             catch (e) {
                 loopError = e;
@@ -1086,5 +1002,52 @@ class Pregel extends runnables_1.Runnable {
         }
         return chunks;
     }
+    async _runLoop(params) {
+        const { loop, runner, debug, config } = params;
+        let tickError;
+        try {
+            while (await loop.tick({
+                inputKeys: this.inputChannels,
+            })) {
+                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));
+                }
+                await runner.tick({
+                    timeout: this.stepTimeout,
+                    retryPolicy: this.retryPolicy,
+                    onStepWrite: (step, writes) => {
+                        if (debug) {
+                            (0, debug_js_1.printStepWrites)(step, writes, this.streamChannelsList);
+                        }
+                    },
+                    signal: config.signal,
+                });
+            }
+            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();
+            }
+        }
+    }
 }
 exports.Pregel = Pregel;

package/dist/pregel/index.d.ts

@@ -1,6 +1,5 @@
 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";
@@ -9,7 +8,6 @@ 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;
@@ -112,14 +110,6 @@ 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.
@@ -137,4 +127,5 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
      * @param options.debug Whether to print debug information during execution.
      */
     invoke(input: InputType | Command | null, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<OutputType>;
+    private _runLoop;
 }

package/dist/pregel/index.js

@@ -7,17 +7,18 @@ import { validateGraph, validateKeys } from "./validate.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, CHECKPOINT_NAMESPACE_SEPARATOR, CHECKPOINT_NAMESPACE_END, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, NULL_TASK_ID, INPUT, RESUME, PUSH, } from "../constants.js";
-import { GraphRecursionError, GraphValueError, InvalidUpdateError, isGraphBubbleUp, isGraphInterrupt, } from "../errors.js";
+import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, CHECKPOINT_NAMESPACE_SEPARATOR, CHECKPOINT_NAMESPACE_END, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, NULL_TASK_ID, INPUT, PUSH, } from "../constants.js";
+import { GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
 import { _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
 import { _coerceToDict, getNewChannelVersions, patchCheckpointMap, } from "./utils/index.js";
 import { findSubgraphPregel } from "./utils/subgraph.js";
-import { PregelLoop, IterableReadableWritableStream } from "./loop.js";
-import { executeTasksWithRetry } from "./retry.js";
+import { PregelLoop } from "./loop.js";
 import { ChannelKeyPlaceholder, isConfiguredManagedValue, ManagedValueMapping, NoopManagedValue, } from "../managed/base.js";
 import { gatherIterator, patchConfigurable } from "../utils.js";
 import { ensureLangGraphConfig } from "./utils/config.js";
 import { StreamMessagesHandler } from "./messages.js";
+import { PregelRunner } from "./runner.js";
+import { IterableReadableWritableStream } from "./stream.js";
 function isString(value) {
     return typeof value === "string";
 }
@@ -820,92 +821,6 @@ 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);
@@ -970,6 +885,14 @@ export class Pregel extends Runnable {
                     streamKeys: this.streamChannelsAsIs,
                     store,
                     stream,
+                    interruptAfter,
+                    interruptBefore,
+                    manager: runManager,
+                    debug: this.debug,
+                });
+                const runner = new PregelRunner({
+                    loop,
+                    nodeFinished: config.configurable?.nodeFinished,
                 });
                 if (options?.subgraphs) {
                     loop.config.configurable = {
@@ -977,14 +900,7 @@ export class Pregel extends Runnable {
                         [CONFIG_KEY_STREAM]: loop.stream,
                     };
                 }
-                await this._runLoop({
-                    loop,
-                    interruptAfter,
-                    interruptBefore,
-                    runManager,
-                    debug,
-                    config,
-                });
+                await this._runLoop({ loop, runner, debug, config });
             }
             catch (e) {
                 loopError = e;
@@ -1082,4 +998,51 @@ export class Pregel extends Runnable {
         }
         return chunks;
     }
+    async _runLoop(params) {
+        const { loop, runner, debug, config } = params;
+        let tickError;
+        try {
+            while (await loop.tick({
+                inputKeys: this.inputChannels,
+            })) {
+                if (debug) {
+                    printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
+                }
+                if (debug) {
+                    printStepTasks(loop.step, Object.values(loop.tasks));
+                }
+                await runner.tick({
+                    timeout: this.stepTimeout,
+                    retryPolicy: this.retryPolicy,
+                    onStepWrite: (step, writes) => {
+                        if (debug) {
+                            printStepWrites(step, writes, this.streamChannelsList);
+                        }
+                    },
+                    signal: config.signal,
+                });
+            }
+            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();
+            }
+        }
+    }
 }

package/dist/pregel/io.cjs

@@ -171,7 +171,12 @@ function* mapOutputUpdates(outputChannels, tasks, cached
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let updated;
-    if (!Array.isArray(outputChannels)) {
+    if (outputTasks.some(([task]) => task.writes.some(([chan, _]) => chan === constants_js_1.RETURN))) {
+        updated = outputTasks.flatMap(([task]) => task.writes
+            .filter(([chan, _]) => chan === constants_js_1.RETURN)
+            .map(([_, value]) => [task.name, value]));
+    }
+    else if (!Array.isArray(outputChannels)) {
         updated = outputTasks.flatMap(([task]) => task.writes
             .filter(([chan, _]) => chan === outputChannels)
             // eslint-disable-next-line @typescript-eslint/no-explicit-any

package/dist/pregel/io.js

@@ -1,5 +1,5 @@
 import { validate } from "uuid";
-import { _isSend, Command, ERROR, INTERRUPT, NULL_TASK_ID, RESUME, SELF, TAG_HIDDEN, TASKS, } from "../constants.js";
+import { _isSend, Command, ERROR, INTERRUPT, NULL_TASK_ID, RESUME, RETURN, SELF, TAG_HIDDEN, TASKS, } from "../constants.js";
 import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
 export function readChannel(channels, chan, catchErrors = true, returnException = false) {
     try {
@@ -163,7 +163,12 @@ export function* mapOutputUpdates(outputChannels, tasks, cached
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     let updated;
-    if (!Array.isArray(outputChannels)) {
+    if (outputTasks.some(([task]) => task.writes.some(([chan, _]) => chan === RETURN))) {
+        updated = outputTasks.flatMap(([task]) => task.writes
+            .filter(([chan, _]) => chan === RETURN)
+            .map(([_, value]) => [task.name, value]));
+    }
+    else if (!Array.isArray(outputChannels)) {
         updated = outputTasks.flatMap(([task]) => task.writes
             .filter(([chan, _]) => chan === outputChannels)
             // eslint-disable-next-line @typescript-eslint/no-explicit-any