@langchain/langgraph 0.0.34 → 0.1.0-rc.1

package/dist/pregel/algo.js

@@ -0,0 +1,381 @@
+/* eslint-disable no-param-reassign */
+import { mergeConfigs, patchConfig, } from "@langchain/core/runnables";
+import { copyCheckpoint, uuid5, } from "@langchain/langgraph-checkpoint";
+import { createCheckpoint, emptyChannels, } from "../channels/base.js";
+import { readChannel, readChannels } from "./io.js";
+import { _isSend, _isSendInterface, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_SEND, INTERRUPT, RESERVED, TAG_HIDDEN, TASKS, } from "../constants.js";
+import { EmptyChannelError, InvalidUpdateError } from "../errors.js";
+import { _getIdMetadata, getNullChannelVersion } from "./utils.js";
+export const increment = (current) => {
+    return current !== undefined ? current + 1 : 1;
+};
+export 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];
+    }
+}
+export 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[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(TAG_HIDDEN)
+        : interruptNodes.includes(task.name));
+    return anyChannelUpdated && anyTriggeredNodeInInterruptNodes;
+}
+export function _localRead(checkpoint, channels, task, select, fresh = false) {
+    if (fresh) {
+        const newCheckpoint = createCheckpoint(checkpoint, channels, -1);
+        // create a new copy of channels
+        const newChannels = emptyChannels(channels, newCheckpoint);
+        // Note: _applyWrites contains side effects
+        _applyWrites(copyCheckpoint(newCheckpoint), newChannels, [task]);
+        return readChannels(newChannels, select);
+    }
+    else {
+        return readChannels(channels, select);
+    }
+}
+export 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 === TASKS) {
+            if (!_isSend(value)) {
+                throw new InvalidUpdateError(`Invalid packet type, expected SendProtocol, got ${JSON.stringify(value)}`);
+            }
+            if (!(value.node in processes)) {
+                throw new 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);
+}
+export 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) => !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 === 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 === InvalidUpdateError.unminifiable_name) {
+                    throw new 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]);
+            }
+        }
+    }
+}
+export 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 (!_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 = [TASKS];
+        const metadata = _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}${CHECKPOINT_NAMESPACE_SEPARATOR}${packet.node}`;
+        const taskId = 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: patchConfig(mergeConfigs(config, processes[packet.node].config, {
+                        metadata,
+                    }), {
+                        runName: packet.node,
+                        callbacks: manager?.getChild(`graph:step:${step}`),
+                        configurable: {
+                            [CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
+                            [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 = 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 = readChannel(channels, chan, false, true);
+            const isEmptyChannelError = 
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            result instanceof Error &&
+                result.name === 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 = _getIdMetadata({
+                langgraph_step: step,
+                langgraph_node: name,
+                langgraph_triggers: triggers,
+                langgraph_task_idx: forExecution
+                    ? tasks.length
+                    : taskDescriptions.length,
+            });
+            const checkpointNamespace = parentNamespace === ""
+                ? name
+                : `${parentNamespace}${CHECKPOINT_NAMESPACE_SEPARATOR}${name}`;
+            const taskId = 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: patchConfig(mergeConfigs(config, proc.config, { metadata }), {
+                            runName: name,
+                            callbacks: manager?.getChild(`graph:step:${step}`),
+                            configurable: {
+                                [CONFIG_KEY_SEND]: _localWrite.bind(undefined, (items) => writes.push(...items), processes, channels),
+                                [CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, {
+                                    name,
+                                    writes: writes,
+                                    triggers,
+                                }),
+                                [CONFIG_KEY_CHECKPOINTER]: checkpointer,
+                                [CONFIG_KEY_RESUMING]: isResuming,
+                                checkpoint_id: checkpoint.id,
+                                checkpoint_ns: checkpointNamespace,
+                            },
+                        }),
+                        id: taskId,
+                    });
+                }
+            }
+            else {
+                taskDescriptions.push({ id: taskId, name });
+            }
+        }
+    }
+    return forExecution ? tasks : taskDescriptions;
+}
+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 = readChannel(channels, chan, false);
+                successfulRead = true;
+                break;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            }
+            catch (e) {
+                if (e.name === 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] = readChannel(channels, chan, !proc.triggers.includes(chan));
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            if (e.name === 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/debug.cjs

@@ -1,26 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.printCheckpoint = exports.printStepStart = void 0;
+exports.printStepWrites = exports.printStepTasks = exports.printStepCheckpoint = exports.tasksWithWrites = exports.mapDebugCheckpoint = exports.mapDebugTaskResults = exports.mapDebugTasks = exports.printCheckpoint = void 0;
+const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
+const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
+const io_js_1 = require("./io.cjs");
+const utils_js_1 = require("./utils.cjs");
 const COLORS_MAP = {
     blue: {
         start: "\x1b[34m",
         end: "\x1b[0m",
     },
+    green: {
+        start: "\x1b[32m",
+        end: "\x1b[0m",
+    },
+    yellow: {
+        start: "\x1b[33;1m",
+        end: "\x1b[0m",
+    },
 };
 /**
  * Wrap some text in a color for printing to the console.
  */
 const wrap = (color, text) => `${color.start}${text}${color.end}`;
-function printStepStart(step, nextTasks) {
-    const nTasks = nextTasks.length;
-    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/step]")}`, `Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}. Next tasks:\n`, `\n${nextTasks
-        .map((task) => `${String(task.name)}(${JSON.stringify(task.input, null, 2)})`)
-        .join("\n")}`);
-}
-exports.printStepStart = printStepStart;
 function printCheckpoint(step, channels) {
-    console.log(`${wrap(COLORS_MAP.blue, "[langgraph/checkpoint]")}`, `Finishing step ${step}. Channel values:\n`, `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`);
+    console.log([
+        `${wrap(COLORS_MAP.blue, "[langgraph/checkpoint]")}`,
+        `Finishing step ${step}. Channel values:\n`,
+        `\n${JSON.stringify(Object.fromEntries(_readChannels(channels)), null, 2)}`,
+    ].join(""));
 }
 exports.printCheckpoint = printCheckpoint;
 function* _readChannels(channels
@@ -42,3 +51,140 @@ function* _readChannels(channels
         }
     }
 }
+function* mapDebugTasks(step, tasks) {
+    const ts = new Date().toISOString();
+    for (const { name, input, config, triggers } of tasks) {
+        if (config?.tags?.includes(constants_js_1.TAG_HIDDEN))
+            continue;
+        const metadata = { ...config?.metadata };
+        const idMetadata = (0, utils_js_1._getIdMetadata)({
+            langgraph_step: metadata.langgraph_step,
+            langgraph_node: metadata.langgraph_node,
+            langgraph_triggers: metadata.langgraph_triggers,
+            langgraph_task_idx: metadata.langgraph_task_idx,
+        });
+        yield {
+            type: "task",
+            timestamp: ts,
+            step,
+            payload: {
+                id: (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([name, step, idMetadata]), constants_js_1.TASK_NAMESPACE),
+                name,
+                input,
+                triggers,
+            },
+        };
+    }
+}
+exports.mapDebugTasks = mapDebugTasks;
+function* mapDebugTaskResults(step, tasks, streamChannelsList) {
+    const ts = new Date().toISOString();
+    for (const { name, writes, config } of tasks) {
+        if (config?.tags?.includes(constants_js_1.TAG_HIDDEN))
+            continue;
+        const metadata = { ...config?.metadata };
+        const idMetadata = (0, utils_js_1._getIdMetadata)(metadata);
+        yield {
+            type: "task_result",
+            timestamp: ts,
+            step,
+            payload: {
+                id: (0, langgraph_checkpoint_1.uuid5)(JSON.stringify([name, step, idMetadata]), constants_js_1.TASK_NAMESPACE),
+                name,
+                result: writes.filter(([channel]) => streamChannelsList.includes(channel)),
+            },
+        };
+    }
+}
+exports.mapDebugTaskResults = mapDebugTaskResults;
+function* mapDebugCheckpoint(step, config, channels, streamChannels, metadata, tasks, pendingWrites) {
+    function formatConfig(config) {
+        // make sure the config is consistent with Python
+        const pyConfig = {};
+        if (config.callbacks != null)
+            pyConfig.callbacks = config.callbacks;
+        if (config.configurable != null)
+            pyConfig.configurable = config.configurable;
+        if (config.maxConcurrency != null)
+            pyConfig.max_concurrency = config.maxConcurrency;
+        if (config.metadata != null)
+            pyConfig.metadata = config.metadata;
+        if (config.recursionLimit != null)
+            pyConfig.recursion_limit = config.recursionLimit;
+        if (config.runId != null)
+            pyConfig.run_id = config.runId;
+        if (config.runName != null)
+            pyConfig.run_name = config.runName;
+        if (config.tags != null)
+            pyConfig.tags = config.tags;
+        return pyConfig;
+    }
+    function getCurrentUTC() {
+        const now = new Date();
+        return new Date(now.getTime() - now.getTimezoneOffset() * 60 * 1000);
+    }
+    const ts = getCurrentUTC().toISOString();
+    yield {
+        type: "checkpoint",
+        timestamp: ts,
+        step,
+        payload: {
+            config: formatConfig(config),
+            values: (0, io_js_1.readChannels)(channels, streamChannels),
+            metadata,
+            next: tasks.map((task) => task.name),
+            tasks: tasksWithWrites(tasks, pendingWrites),
+        },
+    };
+}
+exports.mapDebugCheckpoint = mapDebugCheckpoint;
+function tasksWithWrites(tasks, pendingWrites) {
+    return tasks.map((task) => {
+        const error = pendingWrites.find(([id, n]) => id === task.id && n === constants_js_1.ERROR)?.[2];
+        if (error)
+            return { id: task.id, name: task.name, error };
+        return { id: task.id, name: task.name };
+    });
+}
+exports.tasksWithWrites = tasksWithWrites;
+function printStepCheckpoint(step, channels, whitelist) {
+    console.log([
+        `${wrap(COLORS_MAP.blue, `[${step}:checkpoint]`)}`,
+        `\x1b[1m State at the end of step ${step}:\x1b[0m\n`,
+        JSON.stringify((0, io_js_1.readChannels)(channels, whitelist), null, 2),
+    ].join(""));
+}
+exports.printStepCheckpoint = printStepCheckpoint;
+function printStepTasks(step, nextTasks) {
+    const nTasks = nextTasks.length;
+    console.log([
+        `${wrap(COLORS_MAP.blue, `[${step}:tasks]`)}`,
+        `\x1b[1m Starting step ${step} with ${nTasks} task${nTasks === 1 ? "" : "s"}:\x1b[0m\n`,
+        nextTasks
+            .map((task) => `- ${wrap(COLORS_MAP.green, String(task.name))} -> ${JSON.stringify(task.input, null, 2)}`)
+            .join("\n"),
+    ].join(""));
+}
+exports.printStepTasks = printStepTasks;
+function printStepWrites(step, writes, whitelist) {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const byChannel = {};
+    for (const [channel, value] of writes) {
+        if (whitelist.includes(channel)) {
+            if (!byChannel[channel]) {
+                byChannel[channel] = [];
+            }
+            byChannel[channel].push(value);
+        }
+    }
+    console.log([
+        `${wrap(COLORS_MAP.blue, `[${step}:writes]`)}`,
+        `\x1b[1m Finished step ${step} with writes to ${Object.keys(byChannel).length} channel${Object.keys(byChannel).length !== 1 ? "s" : ""}:\x1b[0m\n`,
+        Object.entries(byChannel)
+            .map(([name, vals]) => `- ${wrap(COLORS_MAP.yellow, name)} -> ${vals
+            .map((v) => JSON.stringify(v))
+            .join(", ")}`)
+            .join("\n"),
+    ].join(""));
+}
+exports.printStepWrites = printStepWrites;

package/dist/pregel/debug.d.ts

@@ -1,4 +1,42 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+import { CheckpointMetadata, CheckpointPendingWrite, PendingWrite } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
-import { PregelExecutableTask } from "./types.js";
-export declare function printStepStart<N extends PropertyKey, C extends PropertyKey>(step: number, nextTasks: readonly PregelExecutableTask<N, C>[]): void;
+import { PregelExecutableTask, PregelTaskDescription } from "./types.js";
 export declare function printCheckpoint<Value>(step: number, channels: Record<string, BaseChannel<Value>>): void;
+export declare function mapDebugTasks<N extends PropertyKey, C extends PropertyKey>(step: number, tasks: readonly PregelExecutableTask<N, C>[]): Generator<{
+    type: string;
+    timestamp: string;
+    step: number;
+    payload: {
+        id: string;
+        name: N;
+        input: unknown;
+        triggers: string[];
+    };
+}, void, unknown>;
+export declare function mapDebugTaskResults<N extends PropertyKey, C extends PropertyKey>(step: number, tasks: readonly PregelExecutableTask<N, C>[], streamChannelsList: Array<PropertyKey>): Generator<{
+    type: string;
+    timestamp: string;
+    step: number;
+    payload: {
+        id: string;
+        name: N;
+        result: PendingWrite<C>[];
+    };
+}, void, unknown>;
+export declare function mapDebugCheckpoint<N extends PropertyKey, C extends PropertyKey>(step: number, config: RunnableConfig, channels: Record<string, BaseChannel>, streamChannels: string | string[], metadata: CheckpointMetadata, tasks: readonly PregelExecutableTask<N, C>[], pendingWrites: CheckpointPendingWrite[]): Generator<{
+    type: string;
+    timestamp: string;
+    step: number;
+    payload: {
+        config: Partial<Record<"tags" | "configurable" | "timeout" | "signal" | "metadata" | "callbacks" | "recursion_limit" | "max_concurrency" | "run_name" | "run_id", unknown>>;
+        values: any;
+        metadata: CheckpointMetadata;
+        next: N[];
+        tasks: PregelTaskDescription[];
+    };
+}, void, unknown>;
+export declare function tasksWithWrites<N extends PropertyKey, C extends PropertyKey>(tasks: PregelTaskDescription[] | readonly PregelExecutableTask<N, C>[], pendingWrites: CheckpointPendingWrite[]): PregelTaskDescription[];
+export declare function printStepCheckpoint(step: number, channels: Record<string, BaseChannel<unknown>>, whitelist: string[]): void;
+export declare function printStepTasks<N extends PropertyKey, C extends PropertyKey>(step: number, nextTasks: readonly PregelExecutableTask<N, C>[]): void;
+export declare function printStepWrites(step: number, writes: PendingWrite[], whitelist: string[]): void;