@langchain/langgraph 0.0.34 → 0.1.0-rc.0

package/dist/pregel/index.cjs

@@ -1,18 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareNextTasks = exports._applyWrites = exports._localWrite = exports._localRead = exports._shouldInterrupt = exports.Pregel = exports.Channel = void 0;
+exports.Pregel = exports.Channel = void 0;
 /* eslint-disable no-param-reassign */
 const runnables_1 = require("@langchain/core/runnables");
-const stream_1 = require("@langchain/core/utils/stream");
 const base_js_1 = require("../channels/base.cjs");
 const base_js_2 = require("../checkpoint/base.cjs");
 const read_js_1 = require("./read.cjs");
 const validate_js_1 = require("./validate.cjs");
 const io_js_1 = require("./io.cjs");
+const debug_js_1 = require("./debug.cjs");
 const write_js_1 = require("./write.cjs");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
-const DEFAULT_LOOP_LIMIT = 25;
+const algo_js_1 = require("./algo.cjs");
+const id_js_1 = require("../checkpoint/id.cjs");
+const utils_js_1 = require("../utils.cjs");
+const utils_js_2 = require("./utils.cjs");
+const loop_js_1 = require("./loop.cjs");
 function isString(value) {
     return typeof value === "string";
 }
@@ -96,13 +100,13 @@ class Pregel extends runnables_1.Runnable {
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "inputs", {
+        Object.defineProperty(this, "inputChannels", {
             enumerable: true,
             configurable: true,
             writable: true,
             value: void 0
         });
-        Object.defineProperty(this, "outputs", {
+        Object.defineProperty(this, "outputChannels", {
             enumerable: true,
             configurable: true,
             writable: true,
@@ -118,7 +122,7 @@ class Pregel extends runnables_1.Runnable {
             enumerable: true,
             configurable: true,
             writable: true,
-            value: "values"
+            value: ["values"]
         });
         Object.defineProperty(this, "streamChannels", {
             enumerable: true,
@@ -156,20 +160,22 @@ class Pregel extends runnables_1.Runnable {
             writable: true,
             value: void 0
         });
+        let { streamMode } = fields;
+        if (streamMode != null && !Array.isArray(streamMode)) {
+            streamMode = [streamMode];
+        }
         this.nodes = fields.nodes;
         this.channels = fields.channels;
         this.autoValidate = fields.autoValidate ?? this.autoValidate;
-        this.streamMode = fields.streamMode ?? this.streamMode;
-        this.outputs = fields.outputs;
+        this.streamMode = streamMode ?? this.streamMode;
+        this.inputChannels = fields.inputChannels;
+        this.outputChannels = fields.outputChannels;
         this.streamChannels = fields.streamChannels ?? this.streamChannels;
         this.interruptAfter = fields.interruptAfter;
         this.interruptBefore = fields.interruptBefore;
-        this.inputs = fields.inputs;
         this.stepTimeout = fields.stepTimeout ?? this.stepTimeout;
         this.debug = fields.debug ?? this.debug;
         this.checkpointer = fields.checkpointer;
-        // Bind the method to the instance
-        this._transform = this._transform.bind(this);
         if (this.autoValidate) {
             this.validate();
         }
@@ -178,8 +184,8 @@ class Pregel extends runnables_1.Runnable {
         (0, validate_js_1.validateGraph)({
             nodes: this.nodes,
             channels: this.channels,
-            outputChannels: this.outputs,
-            inputChannels: this.inputs,
+            outputChannels: this.outputChannels,
+            inputChannels: this.inputChannels,
             streamChannels: this.streamChannels,
             interruptAfterNodes: this.interruptAfter,
             interruptBeforeNodes: this.interruptBefore,
@@ -212,8 +218,7 @@ class Pregel extends runnables_1.Runnable {
         const saved = await this.checkpointer.getTuple(config);
         const checkpoint = saved ? saved.checkpoint : (0, base_js_2.emptyCheckpoint)();
         const channels = (0, base_js_1.emptyChannels)(this.channels, checkpoint);
-        // eslint-disable-next-line @typescript-eslint/no-unused-vars
-        const [_, nextTasks] = _prepareNextTasks(checkpoint, this.nodes, channels, false, { step: -1 });
+        const [, nextTasks] = (0, algo_js_1._prepareNextTasks)(checkpoint, this.nodes, channels, saved !== undefined ? saved.config : config, false, { step: -1 });
         return {
             values: (0, io_js_1.readChannels)(channels, this.streamChannelsAsIs),
             next: nextTasks.map((task) => task.name),
@@ -223,14 +228,13 @@ class Pregel extends runnables_1.Runnable {
             parentConfig: saved?.parentConfig,
         };
     }
-    async *getStateHistory(config, limit, before) {
+    async *getStateHistory(config, options) {
         if (!this.checkpointer) {
             throw new errors_js_1.GraphValueError("No checkpointer set");
         }
-        for await (const saved of this.checkpointer.list(config, limit, before)) {
+        for await (const saved of this.checkpointer.list(config, options)) {
             const channels = (0, base_js_1.emptyChannels)(this.channels, saved.checkpoint);
-            // eslint-disable-next-line @typescript-eslint/no-unused-vars
-            const [_, nextTasks] = _prepareNextTasks(saved.checkpoint, this.nodes, channels, false, { step: -1 });
+            const [, nextTasks] = (0, algo_js_1._prepareNextTasks)(saved.checkpoint, this.nodes, channels, saved.config, false, { step: -1 });
             yield {
                 values: (0, io_js_1.readChannels)(channels, this.streamChannelsAsIs),
                 next: nextTasks.map((task) => task.name),
@@ -250,38 +254,75 @@ class Pregel extends runnables_1.Runnable {
         const checkpoint = saved
             ? (0, base_js_2.copyCheckpoint)(saved.checkpoint)
             : (0, base_js_2.emptyCheckpoint)();
-        // Find last that updated the state, if not provided
-        const maxSeens = Object.entries(checkpoint.versions_seen).reduce((acc, [node, versions]) => {
-            const maxSeen = Math.max(...Object.values(versions));
-            if (maxSeen) {
-                if (!acc[maxSeen]) {
-                    acc[maxSeen] = [];
-                }
-                acc[maxSeen].push(node);
-            }
-            return acc;
-        }, {});
-        if (!asNode && !Object.keys(maxSeens).length) {
-            if (!Array.isArray(this.inputs) && this.inputs in this.nodes) {
-                asNode = this.inputs;
+        const checkpointPreviousVersions = saved?.checkpoint.channel_versions ?? {};
+        const step = saved?.metadata?.step ?? -1;
+        // merge configurable fields with previous checkpoint config
+        const checkpointConfig = {
+            ...config,
+            configurable: {
+                ...config.configurable,
+                // TODO: add proper support for updating nested subgraph state
+                checkpoint_ns: "",
+                ...saved?.config.configurable,
+            },
+        };
+        // Find last node that updated the state, if not provided
+        if (values === undefined && asNode === undefined) {
+            return await this.checkpointer.put(checkpointConfig, (0, base_js_1.createCheckpoint)(checkpoint, {}, step), {
+                source: "update",
+                step,
+                writes: {},
+            }, {});
+        }
+        const nonNullVersion = Object.values(checkpoint.versions_seen)
+            .map((seenVersions) => {
+            return Object.values(seenVersions);
+        })
+            .flat()
+            .find((v) => !!v);
+        if (asNode === undefined && !nonNullVersion) {
+            if (typeof this.inputChannels === "string" &&
+                this.nodes[this.inputChannels] !== undefined) {
+                asNode = this.inputChannels;
             }
         }
-        else if (!asNode) {
-            const maxSeen = Math.max(...Object.keys(maxSeens).map(Number));
-            const nodes = maxSeens[maxSeen];
-            if (nodes.length === 1) {
-                asNode = nodes[0];
+        else if (asNode === undefined) {
+            // TODO: Double check
+            const lastSeenByNode = Object.entries(checkpoint.versions_seen)
+                .map(([n, seen]) => {
+                return Object.values(seen).map((v) => {
+                    return [v, n];
+                });
+            })
+                .flat()
+                .sort(([aNumber], [bNumber]) => {
+                return aNumber - bNumber;
+            });
+            // if two nodes updated the state at the same time, it's ambiguous
+            if (lastSeenByNode) {
+                if (lastSeenByNode.length === 1) {
+                    // eslint-disable-next-line prefer-destructuring
+                    asNode = lastSeenByNode[0][1];
+                }
+                else if (lastSeenByNode[lastSeenByNode.length - 1][0] !==
+                    lastSeenByNode[lastSeenByNode.length - 2][0]) {
+                    // eslint-disable-next-line prefer-destructuring
+                    asNode = lastSeenByNode[lastSeenByNode.length - 1][1];
+                }
             }
         }
-        if (!asNode) {
-            throw new errors_js_1.InvalidUpdateError("Ambiguous update, specify as_node");
+        if (asNode === undefined) {
+            throw new errors_js_1.InvalidUpdateError(`Ambiguous update, specify "asNode"`);
+        }
+        if (this.nodes[asNode] === undefined) {
+            throw new errors_js_1.InvalidUpdateError(`Node "${asNode.toString()}" does not exist`);
         }
         // update channels
         const channels = (0, base_js_1.emptyChannels)(this.channels, checkpoint);
-        // create task to run all writers of the chosen node
+        // run all writers of the chosen node
         const writers = this.nodes[asNode].getWriters();
         if (!writers.length) {
-            throw new errors_js_1.InvalidUpdateError(`No writers found for node ${asNode}`);
+            throw new errors_js_1.InvalidUpdateError(`No writers found for node "${asNode.toString()}"`);
         }
         const task = {
             name: asNode,
@@ -290,24 +331,29 @@ class Pregel extends runnables_1.Runnable {
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
             writers.length > 1 ? runnables_1.RunnableSequence.from(writers) : writers[0],
             writes: [],
+            triggers: [constants_js_1.INTERRUPT],
             config: undefined,
+            id: (0, id_js_1.uuid5)(constants_js_1.INTERRUPT, checkpoint.id),
         };
         // execute task
         await task.proc.invoke(task.input, (0, runnables_1.patchConfig)(config, {
             runName: `${this.name}UpdateState`,
             configurable: {
                 [constants_js_1.CONFIG_KEY_SEND]: (items) => task.writes.push(...items),
-                [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, task.writes),
+                [constants_js_1.CONFIG_KEY_READ]: algo_js_1._localRead.bind(undefined, checkpoint, channels, 
+                // TODO: Why does keyof StrRecord allow number and symbol?
+                task),
             },
         }));
         // apply to checkpoint and save
-        _applyWrites(checkpoint, channels, task.writes);
-        const step = (saved?.metadata?.step ?? -2) + 1;
-        return await this.checkpointer.put(saved?.config ?? config, (0, base_js_1.createCheckpoint)(checkpoint, channels, step), {
+        // TODO: Why does keyof StrRecord allow number and symbol?
+        (0, algo_js_1._applyWrites)(checkpoint, channels, [task], this.checkpointer.getNextVersion.bind(this.checkpointer));
+        const newVersions = (0, utils_js_2.getNewChannelVersions)(checkpointPreviousVersions, checkpoint.channel_versions);
+        return await this.checkpointer.put(checkpointConfig, (0, base_js_1.createCheckpoint)(checkpoint, channels, step + 1), {
             source: "update",
-            step,
+            step: step + 1,
             writes: { [asNode]: values },
-        });
+        }, newVersions);
     }
     _defaults(config) {
         const { debug, streamMode, inputKeys, outputKeys, interruptAfter, interruptBefore, ...rest } = config;
@@ -321,7 +367,7 @@ class Pregel extends runnables_1.Runnable {
         }
         let defaultInputKeys = inputKeys;
         if (defaultInputKeys === undefined) {
-            defaultInputKeys = this.inputs;
+            defaultInputKeys = this.inputChannels;
         }
         else {
             (0, validate_js_1.validateKeys)(defaultInputKeys, this.channels);
@@ -330,14 +376,23 @@ class Pregel extends runnables_1.Runnable {
         const defaultInterruptAfter = interruptAfter ?? this.interruptAfter ?? [];
         let defaultStreamMode;
         if (streamMode !== undefined) {
-            defaultStreamMode = streamMode;
+            defaultStreamMode = Array.isArray(streamMode) ? streamMode : [streamMode];
         }
         else {
             defaultStreamMode = this.streamMode;
         }
+        let defaultCheckpointer;
         if (config.configurable !== undefined &&
             config.configurable[constants_js_1.CONFIG_KEY_READ] !== undefined) {
-            defaultStreamMode = "values";
+            defaultStreamMode = ["values"];
+        }
+        if (config !== undefined &&
+            config.configurable?.[constants_js_1.CONFIG_KEY_CHECKPOINTER] !== undefined &&
+            (defaultInterruptAfter.length > 0 || defaultInterruptBefore.length > 0)) {
+            defaultCheckpointer = config.configurable[constants_js_1.CONFIG_KEY_CHECKPOINTER];
+        }
+        else {
+            defaultCheckpointer = this.checkpointer;
         }
         return [
             defaultDebug,
@@ -347,489 +402,142 @@ class Pregel extends runnables_1.Runnable {
             rest,
             defaultInterruptBefore,
             defaultInterruptAfter,
+            defaultCheckpointer,
         ];
     }
-    async *_transform(input, runManager, config = {}) {
-        const bg = [];
+    async *_streamIterator(input, options) {
+        const inputConfig = (0, runnables_1.ensureConfig)(options);
+        if (inputConfig.recursionLimit === undefined ||
+            inputConfig.recursionLimit < 1) {
+            throw new Error(`Passed "recursionLimit" must be at least 1.`);
+        }
+        if (this.checkpointer !== undefined &&
+            inputConfig.configurable === undefined) {
+            throw new Error(`Checkpointer requires one or more of the following "configurable" keys: "thread_id", "checkpoint_ns", "checkpoint_id"`);
+        }
+        const callbackManager = await (0, runnables_1.getCallbackManagerForConfig)(inputConfig);
+        const runManager = await callbackManager?.handleChainStart(this.toJSON(), (0, utils_js_2._coerceToDict)(input, "input"), inputConfig.runId, undefined, undefined, undefined, inputConfig?.runName ?? this.getName());
+        delete inputConfig.runId;
+        // assign defaults
+        const [debug, streamMode, , outputKeys, config, interruptBefore, interruptAfter, checkpointer,] = this._defaults(inputConfig);
+        let loop;
+        let backgroundError;
+        const onBackgroundError = (e) => {
+            backgroundError = e;
+        };
         try {
-            if (config.recursionLimit && config.recursionLimit < 1) {
-                throw new errors_js_1.GraphValueError(`Recursion limit must be greater than 0, got ${config.recursionLimit}`);
-            }
-            if (this.checkpointer && !config.configurable) {
-                throw new errors_js_1.GraphValueError(`Checkpointer requires one or more of the following 'configurable' keys: thread_id, checkpoint_id`);
-            }
-            // assign defaults
-            const [debug, streamMode, inputKeys, outputKeys, restConfig, interruptBefore, interruptAfter,] = this._defaults(config);
-            // copy nodes to ignore mutations during execution
-            const processes = { ...this.nodes };
-            // get checkpoint, or create an empty one
-            const saved = this.checkpointer
-                ? await this.checkpointer.getTuple(config)
-                : null;
-            let checkpoint = saved ? saved.checkpoint : (0, base_js_2.emptyCheckpoint)();
-            let checkpointConfig = saved ? saved.config : config;
-            let start = (saved?.metadata?.step ?? -2) + 1;
-            // create channels from checkpoint
-            const channels = (0, base_js_1.emptyChannels)(this.channels, checkpoint);
-            // map inputs to channel updates
-            const inputPendingWrites = [];
-            for await (const c of input) {
-                for (const value of (0, io_js_1.mapInput)(inputKeys, c)) {
-                    inputPendingWrites.push(value);
-                }
-            }
-            if (inputPendingWrites.length) {
-                // discard any unfinished tasks from previous checkpoint
-                const discarded = _prepareNextTasks(checkpoint, processes, channels, true, { step: -1 });
-                checkpoint = discarded[0]; // eslint-disable-line prefer-destructuring
-                // apply input writes
-                _applyWrites(checkpoint, channels, inputPendingWrites);
-                // save input checkpoint
-                if (this.checkpointer) {
-                    checkpoint = (0, base_js_1.createCheckpoint)(checkpoint, channels, start);
-                    bg.push(this.checkpointer.put(checkpointConfig, checkpoint, {
-                        source: "input",
-                        step: start,
-                        writes: Object.fromEntries(inputPendingWrites),
-                    }));
-                    checkpointConfig = {
-                        configurable: {
-                            ...checkpointConfig.configurable,
-                            checkpoint_id: checkpoint.id,
-                        },
-                    };
+            loop = await loop_js_1.PregelLoop.initialize({
+                input,
+                config,
+                checkpointer,
+                graph: this,
+                onBackgroundError,
+            });
+            while (backgroundError === undefined &&
+                (await loop.tick({
+                    outputKeys,
+                    interruptAfter,
+                    interruptBefore,
+                    manager: runManager,
+                }))) {
+                if (debug) {
+                    (0, debug_js_1.printStepCheckpoint)(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
                 }
-                // increment start to 0
-                start += 1;
-            }
-            else {
-                checkpoint = (0, base_js_2.copyCheckpoint)(checkpoint);
-                for (const k of this.streamChannelsList) {
-                    const version = checkpoint.channel_versions[k] ?? 0;
-                    if (!checkpoint.versions_seen[constants_js_1.INTERRUPT]) {
-                        checkpoint.versions_seen[constants_js_1.INTERRUPT] = {};
+                while (loop.stream.length > 0) {
+                    const nextItem = loop.stream.shift();
+                    if (nextItem === undefined) {
+                        throw new Error("Data structure error.");
+                    }
+                    if (streamMode.includes(nextItem[0])) {
+                        if (streamMode.length === 1) {
+                            yield nextItem[1];
+                        }
+                        else {
+                            yield nextItem;
+                        }
                     }
-                    checkpoint.versions_seen[constants_js_1.INTERRUPT][k] = version;
-                }
-            }
-            // Similarly to Bulk Synchronous Parallel / Pregel model
-            // computation proceeds in steps, while there are channel updates
-            // channel updates from step N are only visible in step N+1
-            // channels are guaranteed to be immutable for the duration of the step,
-            // with channel updates applied only at the transition between steps
-            const stop = start + (config.recursionLimit ?? DEFAULT_LOOP_LIMIT);
-            for (let step = start; step < stop + 1; step += 1) {
-                const [nextCheckpoint, nextTasks] = _prepareNextTasks(checkpoint, processes, channels, true, { step });
-                // if no more tasks, we're done
-                if (nextTasks.length === 0 && step === start) {
-                    throw new errors_js_1.GraphValueError(`No tasks to run in graph.`);
-                }
-                else if (nextTasks.length === 0) {
-                    break;
-                }
-                else if (step === stop) {
-                    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.`);
-                }
-                // before execution, check if we should interrupt
-                if (_shouldInterrupt(checkpoint, interruptBefore, this.streamChannelsList, nextTasks)) {
-                    break;
-                }
-                else {
-                    checkpoint = nextCheckpoint;
                 }
                 if (debug) {
-                    console.log(nextTasks);
+                    (0, debug_js_1.printStepTasks)(loop.step, loop.tasks);
                 }
-                const tasksWithConfig = nextTasks.map(
-                // eslint-disable-next-line no-loop-func
-                (task, i) => [
-                    task.proc,
-                    task.input,
-                    (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(restConfig, processes[task.name].config, {
-                        metadata: {
-                            langgraph_step: step,
-                            langgraph_node: task.name,
-                            langgraph_triggers: [constants_js_1.TASKS],
-                            langgraph_task_idx: i,
-                        },
-                    }), {
-                        callbacks: runManager?.getChild(`graph:step:${step}`),
-                        runName: task.name,
-                        configurable: {
-                            ...config.configurable,
-                            [constants_js_1.CONFIG_KEY_SEND]: (items) => task.writes.push(...items),
-                            [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, task.writes),
-                        },
-                    }),
-                ]);
                 // execute tasks, and wait for one to fail or all to finish.
                 // each task is independent from all other concurrent tasks
-                const tasks = tasksWithConfig.map(([proc, input, updatedConfig]) => () => proc.invoke(input, updatedConfig));
-                await executeTasks(tasks, this.stepTimeout, config.signal);
-                // combine pending writes from all tasks
-                const pendingWrites = [];
-                for (const task of nextTasks) {
-                    pendingWrites.push(...task.writes);
-                }
-                // apply writes to channels
-                _applyWrites(checkpoint, channels, pendingWrites);
-                // yield current value and checkpoint view
-                if (streamMode === "values") {
-                    yield* (0, io_js_1.mapOutputValues)(outputKeys, pendingWrites, channels);
+                // yield updates/debug output as each task finishes
+                const tasks = loop.tasks.map((pregelTask) => () => {
+                    return pregelTask.proc.invoke(pregelTask.input, pregelTask.config);
+                });
+                await (0, algo_js_1.executeTasks)(tasks, this.stepTimeout, config.signal);
+                for (const task of loop.tasks) {
+                    loop.putWrites(task.id, task.writes);
                 }
-                else if (streamMode === "updates") {
+                if (streamMode.includes("updates")) {
                     // TODO: Refactor
-                    for await (const task of nextTasks) {
-                        yield* (0, io_js_1.mapOutputUpdates)(outputKeys, [task]);
+                    for await (const task of loop.tasks) {
+                        yield* (0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputUpdates)(outputKeys, [task]), streamMode.length > 1 ? "updates" : undefined);
                     }
                 }
-                // save end of step checkpoint
-                if (this.checkpointer) {
-                    checkpoint = (0, base_js_1.createCheckpoint)(checkpoint, channels, step);
-                    bg.push(this.checkpointer.put(checkpointConfig, checkpoint, {
-                        source: "loop",
-                        step,
-                        writes: (0, io_js_1.single)(this.streamMode === "values"
-                            ? (0, io_js_1.mapOutputValues)(outputKeys, pendingWrites, channels)
-                            : (0, io_js_1.mapOutputUpdates)(outputKeys, nextTasks)),
-                    }));
-                    checkpointConfig = {
-                        configurable: {
-                            ...checkpointConfig.configurable,
-                            checkpoint_id: checkpoint.id,
-                        },
-                    };
-                }
-                if (_shouldInterrupt(checkpoint, interruptAfter, this.streamChannelsList, nextTasks)) {
-                    break;
+                if (streamMode.includes("debug")) {
+                    yield* (0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTaskResults)(loop.step, loop.tasks, this.streamChannelsList), streamMode.length > 1 ? "debug" : undefined);
                 }
-            }
-        }
-        finally {
-            await Promise.all(bg);
-        }
-    }
-    async invoke(input, options) {
-        const config = (0, runnables_1.ensureConfig)(options);
-        if (!config?.outputKeys) {
-            config.outputKeys = this.outputs;
-        }
-        if (!config?.streamMode) {
-            config.streamMode = "values";
-        }
-        let latest;
-        for await (const chunk of await this.stream(input, config)) {
-            latest = chunk;
-        }
-        if (!latest) {
-            return undefined;
-        }
-        return latest;
-    }
-    async stream(input, config) {
-        const inputIterator = (async function* () {
-            yield input;
-        })();
-        return stream_1.IterableReadableStream.fromAsyncGenerator(this.transform(inputIterator, config));
-    }
-    async *transform(generator, config) {
-        for await (const chunk of this._transformStreamWithConfig(generator, this._transform, config)) {
-            yield chunk;
-        }
-    }
-}
-exports.Pregel = Pregel;
-async function executeTasks(tasks, stepTimeout, signal) {
-    if (stepTimeout && signal) {
-        if ("any" in AbortSignal) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            signal = AbortSignal.any([
-                signal,
-                AbortSignal.timeout(stepTimeout),
-            ]);
-        }
-    }
-    else if (stepTimeout) {
-        signal = AbortSignal.timeout(stepTimeout);
-    }
-    // Abort if signal is aborted
-    signal?.throwIfAborted();
-    // Start all tasks
-    const started = tasks.map((task) => task());
-    // Wait for all tasks to settle
-    // If any tasks fail, or signal is aborted, the promise will reject
-    await Promise.all(signal
-        ? [
-            ...started,
-            new Promise((_resolve, reject) => {
-                signal?.addEventListener("abort", () => reject(new Error("Abort")));
-            }),
-        ]
-        : started);
-}
-function _shouldInterrupt(checkpoint, interruptNodes, snapshotChannels, tasks) {
-    const anySnapshotChannelUpdated = snapshotChannels.some((chan) => (0, base_js_2.getChannelVersion)(checkpoint, chan) >
-        (0, base_js_2.getVersionSeen)(checkpoint, constants_js_1.INTERRUPT, chan));
-    const anyTaskNodeInInterruptNodes = tasks.some((task) => interruptNodes === "*"
-        ? !task.config?.tags?.includes(constants_js_1.TAG_HIDDEN)
-        : interruptNodes.includes(task.name));
-    return anySnapshotChannelUpdated && anyTaskNodeInInterruptNodes;
-}
-exports._shouldInterrupt = _shouldInterrupt;
-function _localRead(checkpoint, channels, writes, select, fresh = false) {
-    if (fresh) {
-        const newCheckpoint = (0, base_js_1.createCheckpoint)(checkpoint, channels, -1);
-        // create a new copy of channels
-        const newChannels = (0, base_js_1.emptyChannels)(channels, newCheckpoint);
-        // Note: _applyWrites contains side effects
-        _applyWrites((0, base_js_2.copyCheckpoint)(newCheckpoint), newChannels, writes);
-        return (0, io_js_1.readChannels)(newChannels, select);
-    }
-    else {
-        return (0, io_js_1.readChannels)(channels, select);
-    }
-}
-exports._localRead = _localRead;
-function _localWrite(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-commit, processes, channels, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-writes) {
-    for (const [chan, value] of writes) {
-        if (chan === constants_js_1.TASKS) {
-            if (!(0, constants_js_1._isSend)(value)) {
-                throw new errors_js_1.InvalidUpdateError(`Invalid packet type, expected SendProtocol, got ${JSON.stringify(value)}`);
-            }
-            if (!(value.node in processes)) {
-                throw new errors_js_1.InvalidUpdateError(`Invalid node name ${value.node} in packet`);
-            }
-        }
-        else if (!(chan in channels)) {
-            console.warn(`Skipping write for channel '${chan}' which has no readers`);
-        }
-    }
-    commit(writes);
-}
-exports._localWrite = _localWrite;
-function _applyWrites(checkpoint, channels, pendingWrites) {
-    if (checkpoint.pending_sends) {
-        checkpoint.pending_sends = [];
-    }
-    const pendingWritesByChannel = {};
-    // Group writes by channel
-    for (const [chan, val] of pendingWrites) {
-        if (chan === constants_js_1.TASKS) {
-            checkpoint.pending_sends.push({
-                node: val.node,
-                args: val.args,
-            });
-        }
-        else {
-            if (chan in pendingWritesByChannel) {
-                pendingWritesByChannel[chan].push(val);
-            }
-            else {
-                pendingWritesByChannel[chan] = [val];
-            }
-        }
-    }
-    // find the highest version of all channels
-    let maxVersion = 0;
-    if (Object.keys(checkpoint.channel_versions).length > 0) {
-        maxVersion = Math.max(...Object.values(checkpoint.channel_versions));
-    }
-    const updatedChannels = new Set();
-    // Apply writes to channels
-    for (const [chan, vals] of Object.entries(pendingWritesByChannel)) {
-        if (chan in channels) {
-            // side effect: update channels
-            try {
-                channels[chan].update(vals);
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            }
-            catch (e) {
-                if (e.name === errors_js_1.InvalidUpdateError.unminifiable_name) {
-                    throw new errors_js_1.InvalidUpdateError(`Invalid update for channel ${chan}. Values: ${vals}\n\nError: ${e.message}`);
+                if (debug) {
+                    (0, debug_js_1.printStepWrites)(loop.step, loop.tasks.map((task) => task.writes).flat(), this.streamChannelsList);
                 }
             }
-            // side effect: update checkpoint channel versions
-            checkpoint.channel_versions[chan] = maxVersion + 1;
-            updatedChannels.add(chan);
-        }
-        else {
-            console.warn(`Skipping write for channel ${chan} which has no readers`);
-        }
-    }
-    // Channels that weren't updated in this step are notified of a new step
-    for (const chan in channels) {
-        if (!updatedChannels.has(chan)) {
-            // side effect: update channels
-            channels[chan].update([]);
-        }
-    }
-}
-exports._applyWrites = _applyWrites;
-function _prepareNextTasks(checkpoint, processes, channels, forExecution, extra) {
-    const newCheckpoint = (0, base_js_2.copyCheckpoint)(checkpoint);
-    const tasks = [];
-    const taskDescriptions = [];
-    for (const packet of checkpoint.pending_sends) {
-        if (!(0, constants_js_1._isSendInterface)(packet)) {
-            console.warn(`Ignoring invalid packet ${JSON.stringify(packet)} in pending sends.`);
-            continue;
-        }
-        if (!(packet.node in processes)) {
-            console.warn(`Ignoring unknown node name ${packet.node} in pending sends.`);
-            continue;
-        }
-        if (forExecution) {
-            const proc = processes[packet.node];
-            const node = proc.getNode();
-            if (node !== undefined) {
-                const triggers = [constants_js_1.TASKS];
-                const metadata = {
-                    langgraph_step: extra.step,
-                    langgraph_node: packet.node,
-                    langgraph_triggers: triggers,
-                    langgraph_task_idx: tasks.length,
-                };
-                const writes = [];
-                tasks.push({
-                    name: packet.node,
-                    input: packet.args,
-                    proc: node,
-                    writes,
-                    config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(proc.config, processes[packet.node].config, {
-                        metadata,
-                    }), {
-                        runName: packet.node,
-                        // callbacks:
-                        configurable: {
-                            [constants_js_1.CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
-                            [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, writes),
-                        },
-                    }),
-                });
-            }
-        }
-        else {
-            taskDescriptions.push({
-                name: packet.node,
-                input: packet.args,
-            });
-        }
-    }
-    // Check if any processes should be run in next step
-    // If so, prepare the values to be passed to them
-    for (const [name, proc] of Object.entries(processes)) {
-        const hasUpdatedChannels = proc.triggers
-            .filter((chan) => {
-            try {
-                (0, io_js_1.readChannel)(channels, chan, false);
-                return true;
+            if (backgroundError !== undefined) {
+                throw backgroundError;
             }
-            catch (e) {
-                return false;
-            }
-        })
-            .some((chan) => (0, base_js_2.getChannelVersion)(newCheckpoint, chan) >
-            (0, base_js_2.getVersionSeen)(newCheckpoint, name, chan));
-        // If any of the channels read by this process were updated
-        if (hasUpdatedChannels) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            let val;
-            // If all trigger channels subscribed by this process are not empty
-            // then invoke the process with the values of all non-empty channels
-            if (Array.isArray(proc.channels)) {
-                let emptyChannels = 0;
-                for (const chan of proc.channels) {
-                    try {
-                        val = (0, io_js_1.readChannel)(channels, chan, false);
-                        break;
-                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    }
-                    catch (e) {
-                        if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
-                            emptyChannels += 1;
-                            continue;
-                        }
-                        else {
-                            throw e;
-                        }
-                    }
+            while (loop.stream.length > 0) {
+                const nextItem = loop.stream.shift();
+                if (nextItem === undefined) {
+                    throw new Error("Data structure error.");
                 }
-                if (emptyChannels === proc.channels.length) {
-                    continue;
-                }
-            }
-            else if (typeof proc.channels === "object") {
-                val = {};
-                try {
-                    for (const [k, chan] of Object.entries(proc.channels)) {
-                        val[k] = (0, io_js_1.readChannel)(channels, chan, !proc.triggers.includes(chan));
-                    }
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                }
-                catch (e) {
-                    if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
-                        continue;
+                if (streamMode.includes(nextItem[0])) {
+                    if (streamMode.length === 1) {
+                        yield nextItem[1];
                     }
                     else {
-                        throw e;
+                        yield nextItem;
                     }
                 }
             }
-            else {
-                throw new Error(`Invalid channels type, expected list or dict, got ${proc.channels}`);
-            }
-            // If the process has a mapper, apply it to the value
-            if (proc.mapper !== undefined) {
-                val = proc.mapper(val);
-            }
-            if (forExecution) {
-                // Update seen versions
-                if (!newCheckpoint.versions_seen[name]) {
-                    newCheckpoint.versions_seen[name] = {};
-                }
-                proc.triggers.forEach((chan) => {
-                    const version = newCheckpoint.channel_versions[chan];
-                    if (version !== undefined) {
-                        // side effect: updates newCheckpoint
-                        newCheckpoint.versions_seen[name][chan] = version;
-                    }
-                });
-                const node = proc.getNode();
-                if (node !== undefined) {
-                    const metadata = {
-                        langgraph_step: extra.step,
-                        langgraph_node: name,
-                        langgraph_triggers: proc.triggers,
-                        langgraph_task_idx: tasks.length,
-                    };
-                    const writes = [];
-                    tasks.push({
-                        name,
-                        input: val,
-                        proc: node,
-                        writes,
-                        config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(proc.config, { metadata }), {
-                            runName: name,
-                            configurable: {
-                                [constants_js_1.CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
-                                [constants_js_1.CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, writes),
-                            },
-                        }),
-                    });
-                }
-            }
-            else {
-                taskDescriptions.push({
-                    name,
-                    input: val,
-                });
+            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(" "));
             }
+            await runManager?.handleChainEnd((0, io_js_1.readChannels)(loop.channels, outputKeys));
+        }
+        catch (e) {
+            await runManager?.handleChainError(e);
+            throw e;
+        }
+        finally {
+            await loop?.backgroundTasksPromise;
         }
     }
-    return [newCheckpoint, forExecution ? tasks : taskDescriptions];
+    /**
+     * Run the graph with a single input and config.
+     * @param input
+     * @param options
+     */
+    async invoke(input, options) {
+        const streamMode = options?.streamMode ?? "values";
+        const config = {
+            ...(0, runnables_1.ensureConfig)(options),
+            outputKeys: options?.outputKeys ?? this.outputChannels,
+            streamMode,
+        };
+        const chunks = [];
+        const stream = await this.stream(input, config);
+        for await (const chunk of stream) {
+            chunks.push(chunk);
+        }
+        if (streamMode === "values") {
+            return chunks[chunks.length - 1];
+        }
+        return chunks;
+    }
 }
-exports._prepareNextTasks = _prepareNextTasks;
+exports.Pregel = Pregel;