@langchain/langgraph 0.2.41 → 0.2.43-rc.0

package/dist/pregel/index.js

@@ -7,17 +7,18 @@ import { validateGraph, validateKeys } from "./validate.js";
 import { readChannels } from "./io.js";
 import { printStepCheckpoint, printStepTasks, printStepWrites, tasksWithWrites, } from "./debug.js";
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
-import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, CHECKPOINT_NAMESPACE_SEPARATOR, CHECKPOINT_NAMESPACE_END, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, NULL_TASK_ID, INPUT, RESUME, PUSH, } from "../constants.js";
-import { GraphRecursionError, GraphValueError, InvalidUpdateError, isGraphBubbleUp, isGraphInterrupt, } from "../errors.js";
+import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, CHECKPOINT_NAMESPACE_SEPARATOR, CHECKPOINT_NAMESPACE_END, CONFIG_KEY_STREAM, CONFIG_KEY_TASK_ID, NULL_TASK_ID, INPUT, PUSH, } from "../constants.js";
+import { GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
 import { _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
 import { _coerceToDict, getNewChannelVersions, patchCheckpointMap, } from "./utils/index.js";
 import { findSubgraphPregel } from "./utils/subgraph.js";
-import { PregelLoop, IterableReadableWritableStream } from "./loop.js";
-import { executeTasksWithRetry } from "./retry.js";
+import { PregelLoop } from "./loop.js";
 import { ChannelKeyPlaceholder, isConfiguredManagedValue, ManagedValueMapping, NoopManagedValue, } from "../managed/base.js";
 import { gatherIterator, patchConfigurable } from "../utils.js";
 import { ensureLangGraphConfig } from "./utils/config.js";
 import { StreamMessagesHandler } from "./messages.js";
+import { PregelRunner } from "./runner.js";
+import { IterableReadableWritableStream } from "./stream.js";
 function isString(value) {
     return typeof value === "string";
 }
@@ -820,92 +821,6 @@ export class Pregel extends Runnable {
             managed,
         };
     }
-    async _runLoop(params) {
-        const { loop, interruptAfter, interruptBefore, runManager, debug, config } = params;
-        let tickError;
-        try {
-            while (await loop.tick({
-                inputKeys: this.inputChannels,
-                interruptAfter,
-                interruptBefore,
-                manager: runManager,
-            })) {
-                if (debug) {
-                    printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
-                }
-                if (debug) {
-                    printStepTasks(loop.step, Object.values(loop.tasks));
-                }
-                // execute tasks, and wait for one to fail or all to finish.
-                // each task is independent from all other concurrent tasks
-                // yield updates/debug output as each task finishes
-                const taskStream = executeTasksWithRetry(Object.values(loop.tasks).filter((task) => task.writes.length === 0), {
-                    stepTimeout: this.stepTimeout,
-                    signal: config.signal,
-                    retryPolicy: this.retryPolicy,
-                });
-                let graphInterrupt;
-                for await (const { task, error } of taskStream) {
-                    if (error !== undefined) {
-                        if (isGraphBubbleUp(error)) {
-                            if (loop.isNested) {
-                                throw error;
-                            }
-                            if (isGraphInterrupt(error)) {
-                                graphInterrupt = error;
-                                if (error.interrupts.length) {
-                                    const interrupts = error.interrupts.map((interrupt) => [INTERRUPT, interrupt]);
-                                    const resumes = task.writes.filter((w) => w[0] === RESUME);
-                                    if (resumes.length) {
-                                        interrupts.push(...resumes);
-                                    }
-                                    loop.putWrites(task.id, interrupts);
-                                }
-                            }
-                        }
-                        else {
-                            loop.putWrites(task.id, [
-                                [ERROR, { message: error.message, name: error.name }],
-                            ]);
-                            throw error;
-                        }
-                    }
-                    else {
-                        loop.putWrites(task.id, task.writes);
-                    }
-                }
-                if (debug) {
-                    printStepWrites(loop.step, Object.values(loop.tasks)
-                        .map((task) => task.writes)
-                        .flat(), this.streamChannelsList);
-                }
-                if (graphInterrupt !== undefined) {
-                    throw graphInterrupt;
-                }
-            }
-            if (loop.status === "out_of_steps") {
-                throw new GraphRecursionError([
-                    `Recursion limit of ${config.recursionLimit} reached`,
-                    "without hitting a stop condition. You can increase the",
-                    `limit by setting the "recursionLimit" config key.`,
-                ].join(" "), {
-                    lc_error_code: "GRAPH_RECURSION_LIMIT",
-                });
-            }
-        }
-        catch (e) {
-            tickError = e;
-            const suppress = await loop.finishAndHandleError(tickError);
-            if (!suppress) {
-                throw e;
-            }
-        }
-        finally {
-            if (tickError === undefined) {
-                await loop.finishAndHandleError();
-            }
-        }
-    }
     async *_streamIterator(input, options) {
         const streamSubgraphs = options?.subgraphs;
         const inputConfig = ensureLangGraphConfig(this.config, options);
@@ -970,6 +885,14 @@ export class Pregel extends Runnable {
                     streamKeys: this.streamChannelsAsIs,
                     store,
                     stream,
+                    interruptAfter,
+                    interruptBefore,
+                    manager: runManager,
+                    debug: this.debug,
+                });
+                const runner = new PregelRunner({
+                    loop,
+                    nodeFinished: config.configurable?.nodeFinished,
                 });
                 if (options?.subgraphs) {
                     loop.config.configurable = {
@@ -977,14 +900,7 @@ export class Pregel extends Runnable {
                         [CONFIG_KEY_STREAM]: loop.stream,
                     };
                 }
-                await this._runLoop({
-                    loop,
-                    interruptAfter,
-                    interruptBefore,
-                    runManager,
-                    debug,
-                    config,
-                });
+                await this._runLoop({ loop, runner, debug, config });
             }
             catch (e) {
                 loopError = e;
@@ -1082,4 +998,51 @@ export class Pregel extends Runnable {
         }
         return chunks;
     }
+    async _runLoop(params) {
+        const { loop, runner, debug, config } = params;
+        let tickError;
+        try {
+            while (await loop.tick({
+                inputKeys: this.inputChannels,
+            })) {
+                if (debug) {
+                    printStepCheckpoint(loop.checkpointMetadata.step, loop.channels, this.streamChannelsList);
+                }
+                if (debug) {
+                    printStepTasks(loop.step, Object.values(loop.tasks));
+                }
+                await runner.tick({
+                    timeout: this.stepTimeout,
+                    retryPolicy: this.retryPolicy,
+                    onStepWrite: (step, writes) => {
+                        if (debug) {
+                            printStepWrites(step, writes, this.streamChannelsList);
+                        }
+                    },
+                    signal: config.signal,
+                });
+            }
+            if (loop.status === "out_of_steps") {
+                throw new GraphRecursionError([
+                    `Recursion limit of ${config.recursionLimit} reached`,
+                    "without hitting a stop condition. You can increase the",
+                    `limit by setting the "recursionLimit" config key.`,
+                ].join(" "), {
+                    lc_error_code: "GRAPH_RECURSION_LIMIT",
+                });
+            }
+        }
+        catch (e) {
+            tickError = e;
+            const suppress = await loop.finishAndHandleError(tickError);
+            if (!suppress) {
+                throw e;
+            }
+        }
+        finally {
+            if (tickError === undefined) {
+                await loop.finishAndHandleError();
+            }
+        }
+    }
 }

package/dist/pregel/io.cjs

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

package/dist/pregel/io.js

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

package/dist/pregel/loop.cjs

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PregelLoop = exports.IterableReadableWritableStream = void 0;
-const stream_1 = require("@langchain/core/utils/stream");
+exports.PregelLoop = void 0;
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
 const base_js_1 = require("../channels/base.cjs");
 const constants_js_1 = require("../constants.cjs");
@@ -11,66 +10,12 @@ const io_js_1 = require("./io.cjs");
 const errors_js_1 = require("../errors.cjs");
 const index_js_1 = require("./utils/index.cjs");
 const debug_js_1 = require("./debug.cjs");
+const stream_js_1 = require("./stream.cjs");
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
-class IterableReadableWritableStream extends stream_1.IterableReadableStream {
-    constructor(params) {
-        let streamControllerPromiseResolver;
-        const streamControllerPromise = new Promise((resolve) => {
-            streamControllerPromiseResolver = resolve;
-        });
-        super({
-            start: (controller) => {
-                streamControllerPromiseResolver(controller);
-            },
-        });
-        Object.defineProperty(this, "modes", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "controller", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "passthroughFn", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        // .start() will always be called before the stream can be interacted
-        // with anyway
-        void streamControllerPromise.then((controller) => {
-            this.controller = controller;
-        });
-        this.passthroughFn = params.passthroughFn;
-        this.modes = params.modes;
-    }
-    push(chunk) {
-        this.passthroughFn?.(chunk);
-        this.controller.enqueue(chunk);
-    }
-    close() {
-        try {
-            this.controller.close();
-        }
-        catch (e) {
-            // pass
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    error(e) {
-        this.controller.error(e);
-    }
-}
-exports.IterableReadableWritableStream = IterableReadableWritableStream;
 function createDuplexStream(...streams) {
-    return new IterableReadableWritableStream({
+    return new stream_js_1.IterableReadableWritableStream({
         passthroughFn: (value) => {
             for (const stream of streams) {
                 if (stream.modes.has(value[1])) {
@@ -249,6 +194,36 @@ class PregelLoop {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "manager", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interruptAfter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "interruptBefore", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "toInterrupt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
+        Object.defineProperty(this, "debug", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: false
+        });
         this.input = params.input;
         this.checkpointer = params.checkpointer;
         // TODO: if managed values no longer needs graph we can replace with
@@ -270,6 +245,7 @@ class PregelLoop {
         this.config = params.config;
         this.checkpointConfig = params.checkpointConfig;
         this.isNested = params.isNested;
+        this.manager = params.manager;
         this.outputKeys = params.outputKeys;
         this.streamKeys = params.streamKeys;
         this.nodes = params.nodes;
@@ -278,6 +254,9 @@ class PregelLoop {
         this.stream = params.stream;
         this.checkpointNamespace = params.checkpointNamespace;
         this.prevCheckpointConfig = params.prevCheckpointConfig;
+        this.interruptAfter = params.interruptAfter;
+        this.interruptBefore = params.interruptBefore;
+        this.debug = params.debug;
     }
     static async initialize(params) {
         let { config, stream } = params;
@@ -368,6 +347,7 @@ class PregelLoop {
             channels,
             managed: params.managed,
             isNested,
+            manager: params.manager,
             skipDoneTasks,
             step,
             stop,
@@ -378,6 +358,9 @@ class PregelLoop {
             nodes: params.nodes,
             stream,
             store,
+            interruptAfter: params.interruptAfter,
+            interruptBefore: params.interruptBefore,
+            debug: params.debug,
         });
     }
     _checkpointerPutAfterPrevious(input) {
@@ -458,7 +441,7 @@ class PregelLoop {
         if (this.store && !this.store.isRunning) {
             this.store?.start();
         }
-        const { inputKeys = [], interruptAfter = [], interruptBefore = [], manager, } = params;
+        const { inputKeys = [] } = params;
         if (this.status !== "pending") {
             throw new Error(`Cannot tick when status is no longer "pending". Current status: "${this.status}"`);
         }
@@ -482,7 +465,7 @@ class PregelLoop {
                 writes: (0, io_js_1.mapOutputUpdates)(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
             });
             // after execution, check if we should interrupt
-            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+            if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptAfter, Object.values(this.tasks))) {
                 this.status = "interrupt_after";
                 throw new errors_js_1.GraphInterrupt();
             }
@@ -498,8 +481,9 @@ class PregelLoop {
             step: this.step,
             checkpointer: this.checkpointer,
             isResuming: this.input === INPUT_RESUMING,
-            manager,
+            manager: this.manager,
             store: this.store,
+            stream: this.stream,
         });
         this.tasks = nextTasks;
         // Produce debug output
@@ -530,15 +514,10 @@ class PregelLoop {
         }
         // if all tasks have finished, re-tick
         if (Object.values(this.tasks).every((task) => task.writes.length > 0)) {
-            return this.tick({
-                inputKeys,
-                interruptAfter,
-                interruptBefore,
-                manager,
-            });
+            return this.tick({ inputKeys });
         }
         // Before execution, check if we should interrupt
-        if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+        if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptBefore, Object.values(this.tasks))) {
             this.status = "interrupt_before";
             throw new errors_js_1.GraphInterrupt();
         }
@@ -575,20 +554,59 @@ class PregelLoop {
         }
         return suppress;
     }
+    acceptPush(task, writeIdx, call) {
+        if (this.interruptAfter?.length > 0 &&
+            (0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptAfter, [task])) {
+            this.toInterrupt.push(task);
+            return;
+        }
+        const pushed = (0, algo_js_1._prepareSingleTask)([constants_js_1.PUSH, task.path ?? [], writeIdx, task.id, call], this.checkpoint, this.checkpointPendingWrites, this.nodes, this.channels, this.managed, this.config, true, {
+            step: this.step,
+            checkpointer: this.checkpointer,
+            manager: this.manager,
+            store: this.store,
+            stream: this.stream,
+        });
+        if (pushed) {
+            if (this.interruptBefore?.length > 0 &&
+                (0, algo_js_1.shouldInterrupt)(this.checkpoint, this.interruptBefore, [pushed])) {
+                this.toInterrupt.push(pushed);
+                return;
+            }
+            this._emit((0, utils_js_1.gatherIteratorSync)((0, utils_js_1.prefixGenerator)((0, debug_js_1.mapDebugTasks)(this.step, [pushed]), "debug")));
+            if (this.debug) {
+                (0, debug_js_1.printStepTasks)(this.step, [pushed]);
+            }
+            this.tasks[pushed.id] = pushed;
+            if (this.skipDoneTasks) {
+                this._matchWrites({ [pushed.id]: pushed });
+            }
+            return pushed;
+        }
+    }
     _suppressInterrupt(e) {
         return (0, errors_js_1.isGraphInterrupt)(e) && !this.isNested;
     }
-    /**
-     * Resuming from previous checkpoint requires
-     * - finding a previous checkpoint
-     * - receiving null input (outer graph) or RESUMING flag (subgraph)
-     */
     async _first(inputKeys) {
+        /*
+         * Resuming from previous checkpoint requires
+         * - finding a previous checkpoint
+         * - receiving null input (outer graph) or RESUMING flag (subgraph)
+         */
+        const { configurable } = this.config;
         const isResuming = Object.keys(this.checkpoint.channel_versions).length !== 0 &&
             (this.config.configurable?.[constants_js_1.CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
                 (0, constants_js_1.isCommand)(this.input));
+        // take resume value from parent
+        const scratchpad = configurable?.[constants_js_1.CONFIG_KEY_SCRATCHPAD];
+        if (scratchpad && scratchpad.nullResume !== undefined) {
+            this.putWrites(constants_js_1.NULL_TASK_ID, [[constants_js_1.RESUME, scratchpad.nullResume]]);
+        }
         if ((0, constants_js_1.isCommand)(this.input)) {
+            if (this.input.resume != null && this.checkpointer == null) {
+                throw new Error("Cannot use Command(resume=...) without checkpointer");
+            }
             const writes = {};
             // group writes by task id
             for (const [tid, key, value] of (0, io_js_1.mapCommand)(this.input, this.checkpointPendingWrites)) {
@@ -653,10 +671,10 @@ class PregelLoop {
             });
         }
         // done with input
-        this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;
+        this.input = this.input === INPUT_RESUMING ? INPUT_RESUMING : INPUT_DONE;
         if (!this.isNested) {
             this.config = (0, index_js_1.patchConfigurable)(this.config, {
-                [constants_js_1.CONFIG_KEY_RESUMING]: isResuming,
+                [constants_js_1.CONFIG_KEY_RESUMING]: this.input === INPUT_RESUMING,
             });
         }
     }
@@ -717,5 +735,21 @@ class PregelLoop {
         }
         this.step += 1;
     }
+    _matchWrites(tasks) {
+        for (const [tid, k, v] of this.checkpointPendingWrites) {
+            if (k === constants_js_1.ERROR || k === constants_js_1.INTERRUPT || k === constants_js_1.RESUME) {
+                continue;
+            }
+            const task = Object.values(tasks).find((t) => t.id === tid);
+            if (task) {
+                task.writes.push([k, v]);
+            }
+        }
+        for (const task of Object.values(tasks)) {
+            if (task.writes.length > 0) {
+                this._outputWrites(task.id, task.writes, true);
+            }
+        }
+    }
 }
 exports.PregelLoop = PregelLoop;

package/dist/pregel/loop.d.ts

@@ -1,14 +1,13 @@
 import type { RunnableConfig } from "@langchain/core/runnables";
 import type { CallbackManagerForChainRun } from "@langchain/core/callbacks/manager";
-import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { BaseCheckpointSaver, Checkpoint, PendingWrite, CheckpointPendingWrite, CheckpointMetadata, All, BaseStore, AsyncBatchedStore } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
-import { PregelExecutableTask, StreamMode } from "./types.js";
+import { Call, PregelExecutableTask, StreamMode } from "./types.js";
 import { Command } from "../constants.js";
 import { PregelNode } from "./read.js";
 import { ManagedValueMapping } from "../managed/base.js";
 import { LangGraphRunnableConfig } from "./runnable_types.js";
-export type StreamChunk = [string[], StreamMode, unknown];
+import { IterableReadableWritableStream } from "./stream.js";
 export type PregelLoopInitializeParams = {
     input?: any | Command;
     config: RunnableConfig;
@@ -21,6 +20,10 @@ export type PregelLoopInitializeParams = {
     stream: IterableReadableWritableStream;
     store?: BaseStore;
     checkSubgraphs?: boolean;
+    interruptAfter: string[] | All;
+    interruptBefore: string[] | All;
+    manager?: CallbackManagerForChainRun;
+    debug: boolean;
 };
 type PregelLoopParams = {
     input?: any | Command;
@@ -41,22 +44,14 @@ type PregelLoopParams = {
     checkpointNamespace: string[];
     skipDoneTasks: boolean;
     isNested: boolean;
+    manager?: CallbackManagerForChainRun;
     stream: IterableReadableWritableStream;
     store?: AsyncBatchedStore;
     prevCheckpointConfig: RunnableConfig | undefined;
+    interruptAfter: string[] | All;
+    interruptBefore: string[] | All;
+    debug: boolean;
 };
-export declare class IterableReadableWritableStream extends IterableReadableStream<StreamChunk> {
-    modes: Set<StreamMode>;
-    private controller;
-    private passthroughFn?;
-    constructor(params: {
-        passthroughFn?: (chunk: StreamChunk) => void;
-        modes: Set<StreamMode>;
-    });
-    push(chunk: StreamChunk): void;
-    close(): void;
-    error(e: any): void;
-}
 export declare class PregelLoop {
     protected input?: any | Command;
     output: any;
@@ -85,6 +80,11 @@ export declare class PregelLoop {
     isNested: boolean;
     protected _checkpointerChainedPromise: Promise<unknown>;
     store?: AsyncBatchedStore;
+    manager?: CallbackManagerForChainRun;
+    interruptAfter: string[] | All;
+    interruptBefore: string[] | All;
+    toInterrupt: PregelExecutableTask<string, string>[];
+    debug: boolean;
     constructor(params: PregelLoopParams);
     static initialize(params: PregelLoopInitializeParams): Promise<PregelLoop>;
     protected _checkpointerPutAfterPrevious(input: {
@@ -108,19 +108,13 @@ export declare class PregelLoop {
      */
     tick(params: {
         inputKeys?: string | string[];
-        interruptAfter: string[] | All;
-        interruptBefore: string[] | All;
-        manager?: CallbackManagerForChainRun;
     }): Promise<boolean>;
     finishAndHandleError(error?: Error): Promise<boolean>;
+    acceptPush(task: PregelExecutableTask<string, string>, writeIdx: number, call?: Call): PregelExecutableTask<string, string> | void;
     protected _suppressInterrupt(e?: Error): boolean;
-    /**
-     * Resuming from previous checkpoint requires
-     * - finding a previous checkpoint
-     * - receiving null input (outer graph) or RESUMING flag (subgraph)
-     */
     protected _first(inputKeys: string | string[]): Promise<void>;
     protected _emit(values: [StreamMode, unknown][]): void;
     protected _putCheckpoint(inputMetadata: Omit<CheckpointMetadata, "step" | "parents">): Promise<void>;
+    protected _matchWrites(tasks: Record<string, PregelExecutableTask<string, string>>): void;
 }
 export {};