@langchain/langgraph 0.0.33 → 0.0.34

package/dist/graph/state.cjs

@@ -1,9 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CompiledStateGraph = exports.StateGraph = exports.Annotation = void 0;
-const binop_js_1 = require("../channels/binop.cjs");
+exports.CompiledStateGraph = exports.StateGraph = void 0;
 const graph_js_1 = require("./graph.cjs");
-const last_value_js_1 = require("../channels/last_value.cjs");
 const write_js_1 = require("../pregel/write.cjs");
 const read_js_1 = require("../pregel/read.cjs");
 const named_barrier_value_js_1 = require("../channels/named_barrier_value.cjs");
@@ -11,17 +9,8 @@ const ephemeral_value_js_1 = require("../channels/ephemeral_value.cjs");
 const utils_js_1 = require("../utils.cjs");
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
+const annotation_js_1 = require("./annotation.cjs");
 const ROOT = "__root__";
-function Annotation(annotation) {
-    if (annotation) {
-        return getChannel(annotation);
-    }
-    else {
-        // @ts-expect-error - Annotation without reducer
-        return new last_value_js_1.LastValue();
-    }
-}
-exports.Annotation = Annotation;
 class StateGraph extends graph_js_1.Graph {
     constructor(fields) {
         super();
@@ -38,9 +27,10 @@ class StateGraph extends graph_js_1.Graph {
             writable: true,
             value: new Set()
         });
-        if (isStateDefinition(fields)) {
+        if (isStateDefinition(fields) || isAnnotationRoot(fields)) {
+            const spec = isAnnotationRoot(fields) ? fields.spec : fields;
             this.channels = {};
-            for (const [key, val] of Object.entries(fields)) {
+            for (const [key, val] of Object.entries(spec)) {
                 if (typeof val === "function") {
                     this.channels[key] = val();
                 }
@@ -148,31 +138,15 @@ function _getChannels(schema) {
     const channels = {};
     for (const [name, val] of Object.entries(schema)) {
         if (name === ROOT) {
-            channels[name] = getChannel(val);
+            channels[name] = (0, annotation_js_1.getChannel)(val);
         }
         else {
             const key = name;
-            channels[name] = getChannel(val);
+            channels[name] = (0, annotation_js_1.getChannel)(val);
         }
     }
     return channels;
 }
-function getChannel(reducer) {
-    if (typeof reducer === "object" &&
-        reducer &&
-        "reducer" in reducer &&
-        reducer.reducer) {
-        return new binop_js_1.BinaryOperatorAggregate(reducer.reducer, reducer.default);
-    }
-    if (typeof reducer === "object" &&
-        reducer &&
-        "value" in reducer &&
-        reducer.value) {
-        return new binop_js_1.BinaryOperatorAggregate(reducer.value, reducer.default);
-    }
-    // @ts-expect-error - Annotation without reducer
-    return new last_value_js_1.LastValue();
-}
 class CompiledStateGraph extends graph_js_1.CompiledGraph {
     attachNode(key, node) {
         const stateKeys = Object.keys(this.builder.channels);
@@ -209,7 +183,7 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
             });
         }
         else {
-            this.channels[key] = new ephemeral_value_js_1.EphemeralValue();
+            this.channels[key] = new ephemeral_value_js_1.EphemeralValue(false);
             this.nodes[key] = new read_js_1.PregelNode({
                 triggers: [],
                 // read state keys
@@ -266,10 +240,15 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
             if (!filteredDests.length) {
                 return;
             }
-            const writes = filteredDests.map((dest) => ({
-                channel: `branch:${start}:${name}:${dest}`,
-                value: start,
-            }));
+            const writes = filteredDests.map((dest) => {
+                if ((0, constants_js_1._isSend)(dest)) {
+                    return dest;
+                }
+                return {
+                    channel: `branch:${start}:${name}:${dest}`,
+                    value: start,
+                };
+            });
             return new write_js_1.ChannelWrite(writes, [constants_js_1.TAG_HIDDEN]);
         }, 
         // reader
@@ -284,7 +263,7 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
             }
             const channelName = `branch:${start}:${name}:${end}`;
             this.channels[channelName] =
-                new ephemeral_value_js_1.EphemeralValue();
+                new ephemeral_value_js_1.EphemeralValue(false);
             this.nodes[end].triggers.push(channelName);
         }
     }
@@ -300,3 +279,9 @@ function isStateDefinition(obj) {
         Object.keys(obj).length > 0 &&
         Object.values(obj).every((v) => typeof v === "function" || isBaseChannel(v)));
 }
+function isAnnotationRoot(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        "lc_graph_name" in obj &&
+        obj.lc_graph_name === "AnnotationRoot");
+}

package/dist/graph/state.d.ts

@@ -1,33 +1,9 @@
 import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 import { BaseChannel } from "../channels/base.js";
-import { BinaryOperator, BinaryOperatorAggregate } from "../channels/binop.js";
 import { END, CompiledGraph, Graph, START, Branch } from "./graph.js";
-import { LastValue } from "../channels/last_value.js";
 import { BaseCheckpointSaver } from "../checkpoint/base.js";
 import { All } from "../pregel/types.js";
-export declare function Annotation<ValueType>(): LastValue<ValueType>;
-export declare function Annotation<ValueType, UpdateType = ValueType>(annotation: SingleReducer<ValueType, UpdateType>): BinaryOperatorAggregate<ValueType, UpdateType>;
-interface StateDefinition {
-    [key: string]: BaseChannel | (() => BaseChannel);
-}
-type ExtractValueType<C> = C extends BaseChannel ? C["ValueType"] : C extends () => BaseChannel ? ReturnType<C>["ValueType"] : never;
-type ExtractUpdateType<C> = C extends BaseChannel ? C["UpdateType"] : C extends () => BaseChannel ? ReturnType<C>["UpdateType"] : never;
-export type StateInterface<S extends StateDefinition> = {
-    [key in keyof S]: ExtractValueType<S[key]>;
-};
-export type UpdateInterface<S extends StateDefinition> = {
-    [key in keyof S]?: ExtractUpdateType<S[key]>;
-};
-type SingleReducer<ValueType, UpdateType = ValueType> = {
-    reducer: BinaryOperator<ValueType, UpdateType>;
-    default?: () => ValueType;
-} | {
-    /**
-     * @deprecated Use `reducer` instead
-     */
-    value: BinaryOperator<ValueType, UpdateType>;
-    default?: () => ValueType;
-} | null;
+import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
 export type ChannelReducers<Channels extends object> = {
     [K in keyof Channels]: SingleReducer<Channels[K], any>;
 };
@@ -38,12 +14,12 @@ export interface StateGraphArgs<Channels extends object | unknown> {
         __root__: Channels;
     }>;
 }
-export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateInterface<SD> : SD, U = SD extends StateDefinition ? UpdateInterface<SD> : Partial<S>, N extends string = typeof START> extends Graph<N, S, U> {
+export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START> extends Graph<N, S, U> {
     channels: Record<string, BaseChannel>;
     waitingEdges: Set<[N[], N]>;
-    constructor(fields: SD extends StateDefinition ? SD | StateGraphArgs<S> : StateGraphArgs<S>);
+    constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> : StateGraphArgs<S>);
     get allEdges(): Set<[string, string]>;
-    addNode<K extends string>(key: K, action: RunnableLike<S, U>): StateGraph<SD, S, U, N | K>;
+    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U>): StateGraph<SD, S, U, N | K>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
     compile({ checkpointer, interruptBefore, interruptAfter, }?: {
         checkpointer?: BaseCheckpointSaver;
@@ -58,4 +34,3 @@ export declare class CompiledStateGraph<S, U, N extends string = typeof START> e
     attachEdge(start: N | N[] | "__start__", end: N | "__end__"): void;
     attachBranch(start: N | typeof START, name: string, branch: Branch<S, N>): void;
 }
-export {};

package/dist/graph/state.js

@@ -1,23 +1,13 @@
-import { BinaryOperatorAggregate } from "../channels/binop.js";
 import { END, CompiledGraph, Graph, START } from "./graph.js";
-import { LastValue } from "../channels/last_value.js";
 import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
 import { NamedBarrierValue } from "../channels/named_barrier_value.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
-import { TAG_HIDDEN } from "../constants.js";
+import { _isSend, TAG_HIDDEN } from "../constants.js";
 import { InvalidUpdateError } from "../errors.js";
+import { getChannel, } from "./annotation.js";
 const ROOT = "__root__";
-export function Annotation(annotation) {
-    if (annotation) {
-        return getChannel(annotation);
-    }
-    else {
-        // @ts-expect-error - Annotation without reducer
-        return new LastValue();
-    }
-}
 export class StateGraph extends Graph {
     constructor(fields) {
         super();
@@ -34,9 +24,10 @@ export class StateGraph extends Graph {
             writable: true,
             value: new Set()
         });
-        if (isStateDefinition(fields)) {
+        if (isStateDefinition(fields) || isAnnotationRoot(fields)) {
+            const spec = isAnnotationRoot(fields) ? fields.spec : fields;
             this.channels = {};
-            for (const [key, val] of Object.entries(fields)) {
+            for (const [key, val] of Object.entries(spec)) {
                 if (typeof val === "function") {
                     this.channels[key] = val();
                 }
@@ -152,22 +143,6 @@ function _getChannels(schema) {
     }
     return channels;
 }
-function getChannel(reducer) {
-    if (typeof reducer === "object" &&
-        reducer &&
-        "reducer" in reducer &&
-        reducer.reducer) {
-        return new BinaryOperatorAggregate(reducer.reducer, reducer.default);
-    }
-    if (typeof reducer === "object" &&
-        reducer &&
-        "value" in reducer &&
-        reducer.value) {
-        return new BinaryOperatorAggregate(reducer.value, reducer.default);
-    }
-    // @ts-expect-error - Annotation without reducer
-    return new LastValue();
-}
 export class CompiledStateGraph extends CompiledGraph {
     attachNode(key, node) {
         const stateKeys = Object.keys(this.builder.channels);
@@ -204,7 +179,7 @@ export class CompiledStateGraph extends CompiledGraph {
             });
         }
         else {
-            this.channels[key] = new EphemeralValue();
+            this.channels[key] = new EphemeralValue(false);
             this.nodes[key] = new PregelNode({
                 triggers: [],
                 // read state keys
@@ -261,10 +236,15 @@ export class CompiledStateGraph extends CompiledGraph {
             if (!filteredDests.length) {
                 return;
             }
-            const writes = filteredDests.map((dest) => ({
-                channel: `branch:${start}:${name}:${dest}`,
-                value: start,
-            }));
+            const writes = filteredDests.map((dest) => {
+                if (_isSend(dest)) {
+                    return dest;
+                }
+                return {
+                    channel: `branch:${start}:${name}:${dest}`,
+                    value: start,
+                };
+            });
             return new ChannelWrite(writes, [TAG_HIDDEN]);
         }, 
         // reader
@@ -279,7 +259,7 @@ export class CompiledStateGraph extends CompiledGraph {
             }
             const channelName = `branch:${start}:${name}:${end}`;
             this.channels[channelName] =
-                new EphemeralValue();
+                new EphemeralValue(false);
             this.nodes[end].triggers.push(channelName);
         }
     }
@@ -294,3 +274,9 @@ function isStateDefinition(obj) {
         Object.keys(obj).length > 0 &&
         Object.values(obj).every((v) => typeof v === "function" || isBaseChannel(v)));
 }
+function isAnnotationRoot(obj) {
+    return (typeof obj === "object" &&
+        obj !== null &&
+        "lc_graph_name" in obj &&
+        obj.lc_graph_name === "AnnotationRoot");
+}

package/dist/pregel/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareNextTasks = exports._applyWrites = exports._localRead = exports._shouldInterrupt = exports.Pregel = exports.Channel = void 0;
+exports._prepareNextTasks = exports._applyWrites = exports._localWrite = exports._localRead = exports._shouldInterrupt = 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");
@@ -213,7 +213,7 @@ class Pregel extends runnables_1.Runnable {
         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);
+        const [_, nextTasks] = _prepareNextTasks(checkpoint, this.nodes, channels, false, { step: -1 });
         return {
             values: (0, io_js_1.readChannels)(channels, this.streamChannelsAsIs),
             next: nextTasks.map((task) => task.name),
@@ -230,7 +230,7 @@ class Pregel extends runnables_1.Runnable {
         for await (const saved of this.checkpointer.list(config, limit, before)) {
             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);
+            const [_, nextTasks] = _prepareNextTasks(saved.checkpoint, this.nodes, channels, false, { step: -1 });
             yield {
                 values: (0, io_js_1.readChannels)(channels, this.streamChannelsAsIs),
                 next: nextTasks.map((task) => task.name),
@@ -380,7 +380,7 @@ class Pregel extends runnables_1.Runnable {
             }
             if (inputPendingWrites.length) {
                 // discard any unfinished tasks from previous checkpoint
-                const discarded = _prepareNextTasks(checkpoint, processes, channels, true);
+                const discarded = _prepareNextTasks(checkpoint, processes, channels, true, { step: -1 });
                 checkpoint = discarded[0]; // eslint-disable-line prefer-destructuring
                 // apply input writes
                 _applyWrites(checkpoint, channels, inputPendingWrites);
@@ -419,7 +419,7 @@ class Pregel extends runnables_1.Runnable {
             // 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);
+                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.`);
@@ -478,7 +478,10 @@ class Pregel extends runnables_1.Runnable {
                     yield* (0, io_js_1.mapOutputValues)(outputKeys, pendingWrites, channels);
                 }
                 else if (streamMode === "updates") {
-                    yield* (0, io_js_1.mapOutputUpdates)(outputKeys, nextTasks);
+                    // TODO: Refactor
+                    for await (const task of nextTasks) {
+                        yield* (0, io_js_1.mapOutputUpdates)(outputKeys, [task]);
+                    }
                 }
                 // save end of step checkpoint
                 if (this.checkpointer) {
@@ -587,15 +590,47 @@ function _localRead(checkpoint, channels, writes, select, fresh = false) {
     }
 }
 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 in pendingWritesByChannel) {
-            pendingWritesByChannel[chan].push(val);
+        if (chan === constants_js_1.TASKS) {
+            checkpoint.pending_sends.push({
+                node: val.node,
+                args: val.args,
+            });
         }
         else {
-            pendingWritesByChannel[chan] = [val];
+            if (chan in pendingWritesByChannel) {
+                pendingWritesByChannel[chan].push(val);
+            }
+            else {
+                pendingWritesByChannel[chan] = [val];
+            }
         }
     }
     // find the highest version of all channels
@@ -614,7 +649,7 @@ function _applyWrites(checkpoint, channels, pendingWrites) {
             }
             catch (e) {
                 if (e.name === errors_js_1.InvalidUpdateError.unminifiable_name) {
-                    throw new errors_js_1.InvalidUpdateError(`Invalid update for channel ${chan}. Values: ${vals}`);
+                    throw new errors_js_1.InvalidUpdateError(`Invalid update for channel ${chan}. Values: ${vals}\n\nError: ${e.message}`);
                 }
             }
             // side effect: update checkpoint channel versions
@@ -634,15 +669,60 @@ function _applyWrites(checkpoint, channels, pendingWrites) {
     }
 }
 exports._applyWrites = _applyWrites;
-function _prepareNextTasks(checkpoint, processes, channels, forExecution) {
+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)) {
-        // If any of the channels read by this process were updated
-        if (proc.triggers
+        const hasUpdatedChannels = proc.triggers
             .filter((chan) => {
             try {
                 (0, io_js_1.readChannel)(channels, chan, false);
@@ -653,7 +733,9 @@ function _prepareNextTasks(checkpoint, processes, channels, forExecution) {
             }
         })
             .some((chan) => (0, base_js_2.getChannelVersion)(newCheckpoint, chan) >
-            (0, base_js_2.getVersionSeen)(newCheckpoint, name, 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
@@ -718,12 +800,25 @@ function _prepareNextTasks(checkpoint, processes, channels, forExecution) {
                 });
                 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: proc.config,
+                        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),
+                            },
+                        }),
                     });
                 }
             }

package/dist/pregel/index.d.ts

@@ -108,7 +108,12 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
 }
 export declare function _shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: ReadonlyCheckpoint, interruptNodes: All | Array<N>, snapshotChannels: Array<C>, tasks: Array<PregelExecutableTask<N, C>>): boolean;
 export declare function _localRead<Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, writes: Array<[keyof Cc, unknown]>, 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, pendingWrites: Array<[keyof Cc, unknown]>): void;
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, forExecution: false): [Checkpoint, Array<PregelTaskDescription>];
-export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, forExecution: true): [Checkpoint, Array<PregelExecutableTask<keyof Nn, keyof Cc>>];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, forExecution: false, extra: {
+    step: number;
+}): [Checkpoint, Array<PregelTaskDescription>];
+export declare function _prepareNextTasks<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, processes: Nn, channels: Cc, forExecution: true, extra: {
+    step: number;
+}): [Checkpoint, Array<PregelExecutableTask<keyof Nn, keyof Cc>>];
 export {};