@langchain/langgraph 0.0.34 → 0.1.0-rc.1

package/dist/graph/graph.cjs

@@ -115,6 +115,9 @@ class Graph {
         return this.edges;
     }
     addNode(key, action) {
+        if (key.includes(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR)) {
+            throw new Error(`"${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}" is a reserved character and is not allowed in node names.`);
+        }
         this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
         if (key in this.nodes) {
             throw new Error(`Node \`${key}\` already present.`);
@@ -137,7 +140,7 @@ class Graph {
         }
         if (!this.supportMultipleEdges &&
             Array.from(this.edges).some(([start]) => start === startKey)) {
-            throw new Error(`Already found path for ${startKey}`);
+            throw new Error(`Already found path for ${startKey}. For multiple edges, use StateGraph with an annotated state key.`);
         }
         this.edges.add([startKey, endKey]);
         return this;
@@ -190,8 +193,8 @@ class Graph {
                 [exports.START]: new ephemeral_value_js_1.EphemeralValue(),
                 [exports.END]: new ephemeral_value_js_1.EphemeralValue(),
             },
-            inputs: exports.START,
-            outputs: exports.END,
+            inputChannels: exports.START,
+            outputChannels: exports.END,
             streamChannels: [],
             streamMode: "values",
         });

package/dist/graph/graph.d.ts

@@ -1,8 +1,9 @@
 import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 import { Graph as RunnableGraph } from "@langchain/core/runnables/graph";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { PregelNode } from "../pregel/read.js";
-import { Pregel, PregelInterface } from "../pregel/index.js";
-import { BaseCheckpointSaver } from "../checkpoint/base.js";
+import { Pregel } from "../pregel/index.js";
+import type { PregelParams } from "../pregel/types.js";
 import { BaseChannel } from "../channels/base.js";
 import { All } from "../pregel/types.js";
 import { Send } from "../constants.js";
@@ -51,10 +52,13 @@ export declare class Graph<N extends string = typeof END, RunInput = any, RunOut
     validate(interrupt?: string[]): void;
 }
 export declare class CompiledGraph<N extends string, RunInput = any, RunOutput = any> extends Pregel<Record<N | typeof START, PregelNode<RunInput, RunOutput>>, Record<N | typeof START | typeof END | string, BaseChannel>> {
+    NodeType: N;
+    RunInput: RunInput;
+    RunOutput: RunOutput;
     builder: Graph<N, RunInput, RunOutput>;
     constructor({ builder, ...rest }: {
         builder: Graph<N, RunInput, RunOutput>;
-    } & PregelInterface<Record<N | typeof START, PregelNode<RunInput, RunOutput>>, Record<N | typeof START | typeof END | string, BaseChannel>>);
+    } & PregelParams<Record<N | typeof START, PregelNode<RunInput, RunOutput>>, Record<N | typeof START | typeof END | string, BaseChannel>>);
     attachNode(key: N, node: Runnable<RunInput, RunOutput>): void;
     attachEdge(start: N | typeof START, end: N | typeof END): void;
     attachBranch(start: N | typeof START, name: string, branch: Branch<RunInput, N>): void;

package/dist/graph/graph.js

@@ -6,7 +6,7 @@ import { PregelNode } from "../pregel/read.js";
 import { Channel, Pregel } from "../pregel/index.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
-import { _isSend, TAG_HIDDEN } from "../constants.js";
+import { _isSend, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
 import { InvalidUpdateError } from "../errors.js";
 export const START = "__start__";
@@ -111,6 +111,9 @@ export class Graph {
         return this.edges;
     }
     addNode(key, action) {
+        if (key.includes(CHECKPOINT_NAMESPACE_SEPARATOR)) {
+            throw new Error(`"${CHECKPOINT_NAMESPACE_SEPARATOR}" is a reserved character and is not allowed in node names.`);
+        }
         this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
         if (key in this.nodes) {
             throw new Error(`Node \`${key}\` already present.`);
@@ -133,7 +136,7 @@ export class Graph {
         }
         if (!this.supportMultipleEdges &&
             Array.from(this.edges).some(([start]) => start === startKey)) {
-            throw new Error(`Already found path for ${startKey}`);
+            throw new Error(`Already found path for ${startKey}. For multiple edges, use StateGraph with an annotated state key.`);
         }
         this.edges.add([startKey, endKey]);
         return this;
@@ -186,8 +189,8 @@ export class Graph {
                 [START]: new EphemeralValue(),
                 [END]: new EphemeralValue(),
             },
-            inputs: START,
-            outputs: END,
+            inputChannels: START,
+            outputChannels: END,
             streamChannels: [],
             streamMode: "values",
         });

package/dist/graph/index.d.ts

@@ -1,4 +1,4 @@
 export { Annotation, type StateType, type UpdateType } from "./annotation.js";
-export { END, START, Graph } from "./graph.js";
+export { END, START, Graph, type CompiledGraph } from "./graph.js";
 export { type StateGraphArgs, StateGraph, type CompiledStateGraph, } from "./state.js";
 export { MessageGraph, messagesStateReducer } from "./message.js";

package/dist/graph/state.cjs

@@ -74,14 +74,14 @@ class StateGraph extends graph_js_1.Graph {
                 throw new Error("END cannot be a start node");
             }
             if (!Object.keys(this.nodes).some((node) => node === start)) {
-                throw new Error(`Need to add_node ${start} first`);
+                throw new Error(`Need to addNode ${start} first`);
             }
         }
         if (endKey === graph_js_1.END) {
             throw new Error("END cannot be an end node");
         }
         if (!Object.keys(this.nodes).some((node) => node === endKey)) {
-            throw new Error(`Need to add_node ${endKey} first`);
+            throw new Error(`Need to addNode ${endKey} first`);
         }
         this.waitingEdges.add([startKey, endKey]);
         return this;
@@ -94,7 +94,7 @@ class StateGraph extends graph_js_1.Graph {
         ]);
         // prepare output channels
         const stateKeys = Object.keys(this.channels);
-        const outputs = stateKeys.length === 1 && stateKeys[0] === ROOT
+        const outputChannels = stateKeys.length === 1 && stateKeys[0] === ROOT
             ? stateKeys[0]
             : stateKeys;
         // create empty compiled graph
@@ -109,9 +109,9 @@ class StateGraph extends graph_js_1.Graph {
                 ...this.channels,
                 [graph_js_1.START]: new ephemeral_value_js_1.EphemeralValue(),
             },
-            inputs: graph_js_1.START,
-            outputs,
-            streamChannels: outputs,
+            inputChannels: graph_js_1.START,
+            outputChannels,
+            streamChannels: outputChannels,
             streamMode: "updates",
         });
         // attach nodes, edges and branches
@@ -155,7 +155,8 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
                 return write_js_1.SKIP_WRITE;
             }
             else if (typeof input !== "object" || Array.isArray(input)) {
-                throw new errors_js_1.InvalidUpdateError(`Expected dict, got ${typeof input}`);
+                const typeofInput = Array.isArray(input) ? "array" : typeof input;
+                throw new errors_js_1.InvalidUpdateError(`Expected object, got ${typeofInput}`);
             }
             else {
                 return key in input ? input[key] : write_js_1.SKIP_WRITE;
@@ -252,7 +253,7 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
             return new write_js_1.ChannelWrite(writes, [constants_js_1.TAG_HIDDEN]);
         }, 
         // reader
-        (config) => read_js_1.ChannelRead.doRead(config, this.outputs, true)));
+        (config) => read_js_1.ChannelRead.doRead(config, this.outputChannels, true)));
         // attach branch subscribers
         const ends = branch.ends
             ? Object.values(branch.ends)

package/dist/graph/state.d.ts

@@ -1,7 +1,7 @@
 import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
 import { END, CompiledGraph, Graph, START, Branch } from "./graph.js";
-import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { All } from "../pregel/types.js";
 import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
 export type ChannelReducers<Channels extends object> = {

package/dist/graph/state.js

@@ -71,14 +71,14 @@ export class StateGraph extends Graph {
                 throw new Error("END cannot be a start node");
             }
             if (!Object.keys(this.nodes).some((node) => node === start)) {
-                throw new Error(`Need to add_node ${start} first`);
+                throw new Error(`Need to addNode ${start} first`);
             }
         }
         if (endKey === END) {
             throw new Error("END cannot be an end node");
         }
         if (!Object.keys(this.nodes).some((node) => node === endKey)) {
-            throw new Error(`Need to add_node ${endKey} first`);
+            throw new Error(`Need to addNode ${endKey} first`);
         }
         this.waitingEdges.add([startKey, endKey]);
         return this;
@@ -91,7 +91,7 @@ export class StateGraph extends Graph {
         ]);
         // prepare output channels
         const stateKeys = Object.keys(this.channels);
-        const outputs = stateKeys.length === 1 && stateKeys[0] === ROOT
+        const outputChannels = stateKeys.length === 1 && stateKeys[0] === ROOT
             ? stateKeys[0]
             : stateKeys;
         // create empty compiled graph
@@ -106,9 +106,9 @@ export class StateGraph extends Graph {
                 ...this.channels,
                 [START]: new EphemeralValue(),
             },
-            inputs: START,
-            outputs,
-            streamChannels: outputs,
+            inputChannels: START,
+            outputChannels,
+            streamChannels: outputChannels,
             streamMode: "updates",
         });
         // attach nodes, edges and branches
@@ -151,7 +151,8 @@ export class CompiledStateGraph extends CompiledGraph {
                 return SKIP_WRITE;
             }
             else if (typeof input !== "object" || Array.isArray(input)) {
-                throw new InvalidUpdateError(`Expected dict, got ${typeof input}`);
+                const typeofInput = Array.isArray(input) ? "array" : typeof input;
+                throw new InvalidUpdateError(`Expected object, got ${typeofInput}`);
             }
             else {
                 return key in input ? input[key] : SKIP_WRITE;
@@ -248,7 +249,7 @@ export class CompiledStateGraph extends CompiledGraph {
             return new ChannelWrite(writes, [TAG_HIDDEN]);
         }, 
         // reader
-        (config) => ChannelRead.doRead(config, this.outputs, true)));
+        (config) => ChannelRead.doRead(config, this.outputChannels, true)));
         // attach branch subscribers
         const ends = branch.ends
             ? Object.values(branch.ends)

package/dist/prebuilt/react_agent_executor.d.ts

@@ -2,7 +2,7 @@ import { BaseChatModel } from "@langchain/core/language_models/chat_models";
 import { BaseMessage, SystemMessage } from "@langchain/core/messages";
 import { Runnable, RunnableToolLike } from "@langchain/core/runnables";
 import { StructuredToolInterface } from "@langchain/core/tools";
-import { BaseCheckpointSaver } from "../checkpoint/base.js";
+import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { START } from "../graph/index.js";
 import { MessagesState } from "../graph/message.js";
 import { CompiledStateGraph } from "../graph/state.js";

package/dist/pregel/algo.cjs

@@ -0,0 +1,391 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._prepareNextTasks = exports._applyWrites = exports._localWrite = exports._localRead = exports.shouldInterrupt = exports.executeTasks = exports.increment = void 0;
+/* eslint-disable no-param-reassign */
+const runnables_1 = require("@langchain/core/runnables");
+const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
+const base_js_1 = require("../channels/base.cjs");
+const io_js_1 = require("./io.cjs");
+const constants_js_1 = require("../constants.cjs");
+const errors_js_1 = require("../errors.cjs");
+const utils_js_1 = require("./utils.cjs");
+const increment = (current) => {
+    return current !== undefined ? current + 1 : 1;
+};
+exports.increment = increment;
+async function* executeTasks(tasks, stepTimeout, signal
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    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 executingTasks = Object.fromEntries(Object.entries(tasks).map(([taskId, task]) => {
+        return [taskId, task()];
+    }));
+    let listener;
+    const signalPromise = new Promise((_resolve, reject) => {
+        listener = () => reject(new Error("Abort"));
+        signal?.addEventListener("abort", listener);
+    }).finally(() => signal?.removeEventListener("abort", listener));
+    while (Object.keys(executingTasks).length > 0) {
+        const { task, error } = await Promise.race([
+            ...Object.values(executingTasks),
+            signalPromise,
+        ]);
+        if (error !== undefined) {
+            // TODO: don't stop others if exception is interrupt
+            throw error;
+        }
+        yield task;
+        delete executingTasks[task.id];
+    }
+}
+exports.executeTasks = executeTasks;
+function shouldInterrupt(checkpoint, interruptNodes, tasks) {
+    const versionValues = Object.values(checkpoint.channel_versions);
+    const versionType = versionValues.length > 0 ? typeof versionValues[0] : undefined;
+    let nullVersion;
+    if (versionType === "number") {
+        nullVersion = 0;
+    }
+    else if (versionType === "string") {
+        nullVersion = "";
+    }
+    const seen = checkpoint.versions_seen[constants_js_1.INTERRUPT] ?? {};
+    const anyChannelUpdated = Object.entries(checkpoint.channel_versions).some(([chan, version]) => {
+        return version > (seen[chan] ?? nullVersion);
+    });
+    const anyTriggeredNodeInInterruptNodes = tasks.some((task) => interruptNodes === "*"
+        ? !task.config?.tags?.includes(constants_js_1.TAG_HIDDEN)
+        : interruptNodes.includes(task.name));
+    return anyChannelUpdated && anyTriggeredNodeInInterruptNodes;
+}
+exports.shouldInterrupt = shouldInterrupt;
+function _localRead(checkpoint, channels, task, 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, langgraph_checkpoint_1.copyCheckpoint)(newCheckpoint), newChannels, [task]);
+        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, tasks, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+getNextVersion) {
+    // Update seen versions
+    for (const task of tasks) {
+        if (checkpoint.versions_seen[task.name] === undefined) {
+            checkpoint.versions_seen[task.name] = {};
+        }
+        for (const chan of task.triggers) {
+            if (chan in checkpoint.channel_versions) {
+                checkpoint.versions_seen[task.name][chan] =
+                    checkpoint.channel_versions[chan];
+            }
+        }
+    }
+    // Find the highest version of all channels
+    let maxVersion;
+    if (Object.keys(checkpoint.channel_versions).length > 0) {
+        maxVersion = Math.max(...Object.values(checkpoint.channel_versions));
+    }
+    // Consume all channels that were read
+    const channelsToConsume = new Set(tasks
+        .flatMap((task) => task.triggers)
+        .filter((chan) => !constants_js_1.RESERVED.includes(chan)));
+    for (const chan of channelsToConsume) {
+        if (channels[chan].consume()) {
+            if (getNextVersion !== undefined) {
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+            }
+        }
+    }
+    // Clear pending sends
+    if (checkpoint.pending_sends) {
+        checkpoint.pending_sends = [];
+    }
+    // Group writes by channel
+    const pendingWriteValuesByChannel = {};
+    for (const task of tasks) {
+        for (const [chan, val] of task.writes) {
+            if (chan === constants_js_1.TASKS) {
+                checkpoint.pending_sends.push({
+                    node: val.node,
+                    args: val.args,
+                });
+            }
+            else {
+                if (chan in pendingWriteValuesByChannel) {
+                    pendingWriteValuesByChannel[chan].push(val);
+                }
+                else {
+                    pendingWriteValuesByChannel[chan] = [val];
+                }
+            }
+        }
+    }
+    // find the highest version of all channels
+    maxVersion = undefined;
+    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(pendingWriteValuesByChannel)) {
+        if (chan in channels) {
+            let updated;
+            try {
+                updated = 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} with values ${JSON.stringify(vals)}`);
+                }
+                else {
+                    throw e;
+                }
+            }
+            if (updated && getNextVersion !== undefined) {
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+            }
+            updatedChannels.add(chan);
+        }
+    }
+    // Channels that weren't updated in this step are notified of a new step
+    for (const chan of Object.keys(channels)) {
+        if (!updatedChannels.has(chan)) {
+            const updated = channels[chan].update([]);
+            if (updated && getNextVersion !== undefined) {
+                checkpoint.channel_versions[chan] = getNextVersion(maxVersion, channels[chan]);
+            }
+        }
+    }
+}
+exports._applyWrites = _applyWrites;
+function _prepareNextTasks(checkpoint, processes, channels, config, forExecution, extra) {
+    const parentNamespace = config.configurable?.checkpoint_ns ?? "";
+    const tasks = [];
+    const taskDescriptions = [];
+    const { step, isResuming = false, checkpointer, manager } = extra;
+    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;
+        }
+        const triggers = [constants_js_1.TASKS];
+        const metadata = (0, utils_js_1._getIdMetadata)({
+            langgraph_step: step,
+            langgraph_node: packet.node,
+            langgraph_triggers: triggers,
+            langgraph_task_idx: forExecution ? tasks.length : taskDescriptions.length,
+        });
+        const checkpointNamespace = parentNamespace === ""
+            ? packet.node
+            : `${parentNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${packet.node}`;
+        const taskId = (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
+        if (forExecution) {
+            const proc = processes[packet.node];
+            const node = proc.getNode();
+            if (node !== undefined) {
+                const writes = [];
+                tasks.push({
+                    name: packet.node,
+                    input: packet.args,
+                    proc: node,
+                    writes,
+                    triggers,
+                    config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, processes[packet.node].config, {
+                        metadata,
+                    }), {
+                        runName: packet.node,
+                        callbacks: manager?.getChild(`graph:step:${step}`),
+                        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, {
+                                name: packet.node,
+                                writes: writes,
+                                triggers,
+                            }),
+                        },
+                    }),
+                    id: taskId,
+                });
+            }
+        }
+        else {
+            taskDescriptions.push({ id: taskId, name: packet.node });
+        }
+    }
+    // Check if any processes should be run in next step
+    // If so, prepare the values to be passed to them
+    const nullVersion = (0, utils_js_1.getNullChannelVersion)(checkpoint.channel_versions);
+    if (nullVersion === undefined) {
+        return forExecution ? tasks : taskDescriptions;
+    }
+    for (const [name, proc] of Object.entries(processes)) {
+        const seen = checkpoint.versions_seen[name] ?? {};
+        const triggers = proc.triggers
+            .filter((chan) => {
+            const result = (0, io_js_1.readChannel)(channels, chan, false, true);
+            const isEmptyChannelError = 
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            result instanceof Error &&
+                result.name === errors_js_1.EmptyChannelError.unminifiable_name;
+            return (!isEmptyChannelError &&
+                (checkpoint.channel_versions[chan] ?? nullVersion) >
+                    (seen[chan] ?? nullVersion));
+        })
+            .sort();
+        // If any of the channels read by this process were updated
+        if (triggers.length > 0) {
+            const val = _procInput(proc, channels, forExecution);
+            if (val === undefined) {
+                continue;
+            }
+            const metadata = (0, utils_js_1._getIdMetadata)({
+                langgraph_step: step,
+                langgraph_node: name,
+                langgraph_triggers: triggers,
+                langgraph_task_idx: forExecution
+                    ? tasks.length
+                    : taskDescriptions.length,
+            });
+            const checkpointNamespace = parentNamespace === ""
+                ? name
+                : `${parentNamespace}${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}${name}`;
+            const taskId = (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([checkpointNamespace, metadata]), checkpoint.id);
+            if (forExecution) {
+                const node = proc.getNode();
+                if (node !== undefined) {
+                    const writes = [];
+                    tasks.push({
+                        name,
+                        input: val,
+                        proc: node,
+                        writes,
+                        triggers,
+                        config: (0, runnables_1.patchConfig)((0, runnables_1.mergeConfigs)(config, proc.config, { metadata }), {
+                            runName: name,
+                            callbacks: manager?.getChild(`graph:step:${step}`),
+                            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, {
+                                    name,
+                                    writes: writes,
+                                    triggers,
+                                }),
+                                [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer,
+                                [constants_js_1.CONFIG_KEY_RESUMING]: isResuming,
+                                checkpoint_id: checkpoint.id,
+                                checkpoint_ns: checkpointNamespace,
+                            },
+                        }),
+                        id: taskId,
+                    });
+                }
+            }
+            else {
+                taskDescriptions.push({ id: taskId, name });
+            }
+        }
+    }
+    return forExecution ? tasks : taskDescriptions;
+}
+exports._prepareNextTasks = _prepareNextTasks;
+function _procInput(proc, channels, forExecution) {
+    // 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 successfulRead = false;
+        for (const chan of proc.channels) {
+            try {
+                val = (0, io_js_1.readChannel)(channels, chan, false);
+                successfulRead = true;
+                break;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if (e.name === errors_js_1.EmptyChannelError.unminifiable_name) {
+                    continue;
+                }
+                else {
+                    throw e;
+                }
+            }
+        }
+        if (!successfulRead) {
+            return;
+        }
+    }
+    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) {
+                return;
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    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 (forExecution && proc.mapper !== undefined) {
+        val = proc.mapper(val);
+    }
+    return val;
+}

package/dist/pregel/algo.d.ts

@@ -0,0 +1,35 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+import { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
+import { BaseCheckpointSaver, Checkpoint, ReadonlyCheckpoint, type PendingWrite } from "@langchain/langgraph-checkpoint";
+import { BaseChannel } from "../channels/base.js";
+import { PregelNode } from "./read.js";
+import { All, PregelExecutableTask, PregelTaskDescription } from "./types.js";
+/**
+ * Construct a type with a set of properties K of type T
+ */
+export type StrRecord<K extends string, T> = {
+    [P in K]: T;
+};
+export type WritesProtocol<C = string> = {
+    name: string;
+    writes: PendingWrite<C>[];
+    triggers: string[];
+};
+export declare const increment: (current?: number) => number;
+export declare function executeTasks(tasks: Record<string, () => Promise<{
+    task: PregelExecutableTask<any, any>;
+    result: any;
+    error: Error;
+}>>, stepTimeout?: number, signal?: AbortSignal): AsyncGenerator<PregelExecutableTask<any, any>>;
+export declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;
+export declare function _localRead<Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
+export declare function _localWrite(commit: (writes: [string, any][]) => void, processes: Record<string, PregelNode>, channels: Record<string, BaseChannel>, writes: [string, any][]): void;
+export declare function _applyWrites<Cc extends Record<string, BaseChannel>>(checkpoint: Checkpoint, channels: Cc, tasks: WritesProtocol<keyof Cc>[], getNextVersion?: (version: any, channel: BaseChannel) => any): void;
+export type NextTaskExtraFields = {
+    step: number;
+    isResuming?: boolean;
+    checkpointer?: BaseCheckpointSaver;
+    manager?: CallbackManagerForChainRun;
+};
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: false, extra: NextTaskExtraFields): PregelTaskDescription[];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, config: RunnableConfig, forExecution: true, extra: NextTaskExtraFields): PregelExecutableTask<keyof Nn, keyof Cc>[];