@langchain/langgraph 0.2.40 → 0.2.42

package/dist/pregel/retry.cjs

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.executeTasksWithRetry = exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MAX_INTERVAL = exports.DEFAULT_BACKOFF_FACTOR = exports.DEFAULT_INITIAL_INTERVAL = void 0;
+exports._runWithRetry = exports.DEFAULT_MAX_RETRIES = exports.DEFAULT_MAX_INTERVAL = exports.DEFAULT_BACKOFF_FACTOR = exports.DEFAULT_INITIAL_INTERVAL = void 0;
 const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
+const index_js_1 = require("./utils/index.cjs");
 exports.DEFAULT_INITIAL_INTERVAL = 500;
 exports.DEFAULT_BACKOFF_FACTOR = 2;
 exports.DEFAULT_MAX_INTERVAL = 128000;
@@ -41,47 +42,9 @@ const DEFAULT_RETRY_ON_HANDLER = (error) => {
     }
     return true;
 };
-async function* executeTasksWithRetry(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-tasks, options) {
-    const { stepTimeout, retryPolicy } = options ?? {};
-    let signal = options?.signal;
-    // Start tasks
-    const executingTasksMap = Object.fromEntries(tasks.map((pregelTask) => {
-        return [pregelTask.id, _runWithRetry(pregelTask, retryPolicy)];
-    }));
-    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();
-    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(executingTasksMap).length > 0) {
-        const settledTask = await Promise.race([
-            ...Object.values(executingTasksMap),
-            signalPromise,
-        ]);
-        yield settledTask;
-        delete executingTasksMap[settledTask.task.id];
-    }
-}
-exports.executeTasksWithRetry = executeTasksWithRetry;
 async function _runWithRetry(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-pregelTask, retryPolicy) {
+pregelTask, retryPolicy, configurable, signal) {
     const resolvedRetryPolicy = pregelTask.retry_policy ?? retryPolicy;
     let interval = resolvedRetryPolicy !== undefined
         ? resolvedRetryPolicy.initialInterval ?? exports.DEFAULT_INITIAL_INTERVAL
@@ -89,28 +52,34 @@ pregelTask, retryPolicy) {
     let attempts = 0;
     let error;
     let result;
+    let { config } = pregelTask;
+    if (configurable) {
+        config = (0, index_js_1.patchConfigurable)(config, configurable);
+    }
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        // Modify writes in place to clear any previous retries
-        while (pregelTask.writes.length > 0) {
-            pregelTask.writes.pop();
+        if (signal?.aborted) {
+            // no need to throw here - we'll throw from the runner, instead.
+            // there's just no point in retrying if the user has requested an abort.
+            break;
         }
+        // Clear any writes from previous attempts
+        pregelTask.writes.splice(0, pregelTask.writes.length);
         error = undefined;
         try {
-            result = await pregelTask.proc.invoke(pregelTask.input, pregelTask.config);
+            result = await pregelTask.proc.invoke(pregelTask.input, config);
             break;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
             if ((0, errors_js_1.isParentCommand)(error)) {
-                const ns = pregelTask.config?.configurable?.checkpoint_ns;
+                const ns = config?.configurable?.checkpoint_ns;
                 const cmd = error.command;
                 if (cmd.graph === ns) {
                     // this command is for the current graph, handle it
                     for (const writer of pregelTask.writers) {
-                        await writer.invoke(cmd, pregelTask.config);
+                        await writer.invoke(cmd, config);
                     }
                     break;
                 }
@@ -153,11 +122,13 @@ pregelTask, retryPolicy) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 error.constructor.unminifiable_name ??
                 error.constructor.name;
-            console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)}ms (attempt ${attempts}) after ${errorName}: ${error}`);
+            console.log(`Retrying task "${String(pregelTask.name)}" after ${interval.toFixed(2)}ms (attempt ${attempts}) after ${errorName}: ${error}`);
+            // signal subgraphs to resume (if available)
+            config = (0, index_js_1.patchConfigurable)(config, { [constants_js_1.CONFIG_KEY_RESUMING]: true });
         }
         finally {
             // Clear checkpoint_ns seen (for subgraph detection)
-            const checkpointNs = pregelTask.config?.configurable?.checkpoint_ns;
+            const checkpointNs = config?.configurable?.checkpoint_ns;
             if (checkpointNs) {
                 (0, errors_js_1.getSubgraphsSeenSet)().delete(checkpointNs);
             }
@@ -166,6 +137,7 @@ pregelTask, retryPolicy) {
     return {
         task: pregelTask,
         result,
-        error,
+        error: error,
     };
 }
+exports._runWithRetry = _runWithRetry;

package/dist/pregel/retry.d.ts

@@ -1,5 +1,5 @@
 import { PregelExecutableTask } from "./types.js";
-import type { RetryPolicy } from "./utils/index.js";
+import { type RetryPolicy } from "./utils/index.js";
 export declare const DEFAULT_INITIAL_INTERVAL = 500;
 export declare const DEFAULT_BACKOFF_FACTOR = 2;
 export declare const DEFAULT_MAX_INTERVAL = 128000;
@@ -8,8 +8,8 @@ export type SettledPregelTask = {
     task: PregelExecutableTask<any, any>;
     error: Error;
 };
-export declare function executeTasksWithRetry(tasks: PregelExecutableTask<any, any>[], options?: {
-    stepTimeout?: number;
-    signal?: AbortSignal;
-    retryPolicy?: RetryPolicy;
-}): AsyncGenerator<SettledPregelTask>;
+export declare function _runWithRetry<N extends PropertyKey, C extends PropertyKey>(pregelTask: PregelExecutableTask<N, C>, retryPolicy?: RetryPolicy, configurable?: Record<string, unknown>, signal?: AbortSignal): Promise<{
+    task: PregelExecutableTask<N, C>;
+    result: unknown;
+    error: Error | undefined;
+}>;

package/dist/pregel/retry.js

@@ -1,5 +1,6 @@
-import { CHECKPOINT_NAMESPACE_SEPARATOR, Command } from "../constants.js";
+import { CHECKPOINT_NAMESPACE_SEPARATOR, Command, CONFIG_KEY_RESUMING, } from "../constants.js";
 import { getSubgraphsSeenSet, isGraphBubbleUp, isParentCommand, } from "../errors.js";
+import { patchConfigurable } from "./utils/index.js";
 export const DEFAULT_INITIAL_INTERVAL = 500;
 export const DEFAULT_BACKOFF_FACTOR = 2;
 export const DEFAULT_MAX_INTERVAL = 128000;
@@ -38,46 +39,9 @@ const DEFAULT_RETRY_ON_HANDLER = (error) => {
     }
     return true;
 };
-export async function* executeTasksWithRetry(
+export async function _runWithRetry(
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-tasks, options) {
-    const { stepTimeout, retryPolicy } = options ?? {};
-    let signal = options?.signal;
-    // Start tasks
-    const executingTasksMap = Object.fromEntries(tasks.map((pregelTask) => {
-        return [pregelTask.id, _runWithRetry(pregelTask, retryPolicy)];
-    }));
-    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();
-    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(executingTasksMap).length > 0) {
-        const settledTask = await Promise.race([
-            ...Object.values(executingTasksMap),
-            signalPromise,
-        ]);
-        yield settledTask;
-        delete executingTasksMap[settledTask.task.id];
-    }
-}
-async function _runWithRetry(
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-pregelTask, retryPolicy) {
+pregelTask, retryPolicy, configurable, signal) {
     const resolvedRetryPolicy = pregelTask.retry_policy ?? retryPolicy;
     let interval = resolvedRetryPolicy !== undefined
         ? resolvedRetryPolicy.initialInterval ?? DEFAULT_INITIAL_INTERVAL
@@ -85,28 +49,34 @@ pregelTask, retryPolicy) {
     let attempts = 0;
     let error;
     let result;
+    let { config } = pregelTask;
+    if (configurable) {
+        config = patchConfigurable(config, configurable);
+    }
     // eslint-disable-next-line no-constant-condition
     while (true) {
-        // Modify writes in place to clear any previous retries
-        while (pregelTask.writes.length > 0) {
-            pregelTask.writes.pop();
+        if (signal?.aborted) {
+            // no need to throw here - we'll throw from the runner, instead.
+            // there's just no point in retrying if the user has requested an abort.
+            break;
         }
+        // Clear any writes from previous attempts
+        pregelTask.writes.splice(0, pregelTask.writes.length);
         error = undefined;
         try {
-            result = await pregelTask.proc.invoke(pregelTask.input, pregelTask.config);
+            result = await pregelTask.proc.invoke(pregelTask.input, config);
             break;
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
         catch (e) {
             error = e;
             error.pregelTaskId = pregelTask.id;
             if (isParentCommand(error)) {
-                const ns = pregelTask.config?.configurable?.checkpoint_ns;
+                const ns = config?.configurable?.checkpoint_ns;
                 const cmd = error.command;
                 if (cmd.graph === ns) {
                     // this command is for the current graph, handle it
                     for (const writer of pregelTask.writers) {
-                        await writer.invoke(cmd, pregelTask.config);
+                        await writer.invoke(cmd, config);
                     }
                     break;
                 }
@@ -149,11 +119,13 @@ pregelTask, retryPolicy) {
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 error.constructor.unminifiable_name ??
                 error.constructor.name;
-            console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)}ms (attempt ${attempts}) after ${errorName}: ${error}`);
+            console.log(`Retrying task "${String(pregelTask.name)}" after ${interval.toFixed(2)}ms (attempt ${attempts}) after ${errorName}: ${error}`);
+            // signal subgraphs to resume (if available)
+            config = patchConfigurable(config, { [CONFIG_KEY_RESUMING]: true });
         }
         finally {
             // Clear checkpoint_ns seen (for subgraph detection)
-            const checkpointNs = pregelTask.config?.configurable?.checkpoint_ns;
+            const checkpointNs = config?.configurable?.checkpoint_ns;
             if (checkpointNs) {
                 getSubgraphsSeenSet().delete(checkpointNs);
             }
@@ -162,6 +134,6 @@ pregelTask, retryPolicy) {
     return {
         task: pregelTask,
         result,
-        error,
+        error: error,
     };
 }

package/dist/pregel/runner.cjs

@@ -0,0 +1,275 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PregelRunner = void 0;
+const types_js_1 = require("./types.cjs");
+const constants_js_1 = require("../constants.cjs");
+const errors_js_1 = require("../errors.cjs");
+const retry_js_1 = require("./retry.cjs");
+/**
+ * Responsible for handling task execution on each tick of the {@link PregelLoop}.
+ */
+class PregelRunner {
+    /**
+     * Construct a new PregelRunner, which executes tasks from the provided PregelLoop.
+     * @param loop - The PregelLoop that produces tasks for this runner to execute.
+     */
+    constructor({ loop, nodeFinished, }) {
+        Object.defineProperty(this, "nodeFinished", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "loop", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.loop = loop;
+        this.nodeFinished = nodeFinished;
+    }
+    /**
+     * Execute tasks from the current step of the PregelLoop.
+     *
+     * Note: this method does NOT call {@link PregelLoop}#tick. That must be handled externally.
+     * @param options - Options for the execution.
+     */
+    async tick(options = {}) {
+        const { timeout, signal, retryPolicy, onStepWrite } = options;
+        let graphInterrupt;
+        // Start task execution
+        const pendingTasks = Object.values(this.loop.tasks).filter((t) => t.writes.length === 0);
+        const taskStream = this._executeTasksWithRetry(pendingTasks, {
+            stepTimeout: timeout,
+            signal,
+            retryPolicy,
+        });
+        for await (const { task, error } of taskStream) {
+            graphInterrupt = this._commit(task, error) ?? graphInterrupt;
+        }
+        onStepWrite?.(this.loop.step, Object.values(this.loop.tasks)
+            .map((task) => task.writes)
+            .flat());
+        if (graphInterrupt) {
+            throw graphInterrupt;
+        }
+    }
+    /**
+     * Concurrently executes tasks with the requested retry policy, yielding a {@link SettledPregelTask} for each task as it completes.
+     * @param tasks - The tasks to execute.
+     * @param options - Options for the execution.
+     */
+    async *_executeTasksWithRetry(tasks, options) {
+        const { stepTimeout, retryPolicy } = options ?? {};
+        let signal = options?.signal;
+        const promiseAddedSymbol = Symbol.for("promiseAdded");
+        let addedPromiseSignal;
+        let addedPromiseWait;
+        function waitHandler(resolve) {
+            addedPromiseSignal = () => {
+                addedPromiseWait = new Promise(waitHandler);
+                resolve(promiseAddedSymbol);
+            };
+        }
+        addedPromiseWait = new Promise(waitHandler);
+        const executingTasksMap = {};
+        const writer = (task, writes, { calls } = {}) => {
+            if (writes.every(([channel]) => channel !== constants_js_1.PUSH)) {
+                return task.config?.configurable?.[constants_js_1.CONFIG_KEY_SEND]?.(writes) ?? [];
+            }
+            // Schedule PUSH tasks, collect promises
+            const scratchpad = task.config?.configurable?.[constants_js_1.CONFIG_KEY_SCRATCHPAD];
+            const rtn = {};
+            for (const [idx, write] of writes.entries()) {
+                const [channel] = write;
+                if (channel !== constants_js_1.PUSH) {
+                    continue;
+                }
+                const wcall = calls?.[idx];
+                const cnt = scratchpad.callCounter;
+                scratchpad.callCounter += 1;
+                if (wcall == null) {
+                    throw new Error("BUG: No call found");
+                }
+                const nextTask = this.loop.acceptPush(task, cnt, wcall);
+                if (!nextTask) {
+                    continue;
+                }
+                // Check if this task is already running
+                const existingPromise = executingTasksMap[nextTask.id];
+                if (existingPromise !== undefined) {
+                    // If the parent task was retried, the next task might already be running
+                    rtn[idx] = existingPromise;
+                }
+                else if (nextTask.writes.length > 0) {
+                    // If it already ran, return the result
+                    const returns = nextTask.writes.filter(([c]) => c === constants_js_1.RETURN);
+                    const errors = nextTask.writes.filter(([c]) => c === constants_js_1.ERROR);
+                    if (returns.length > 0) {
+                        // Task completed successfully
+                        if (returns.length === 1) {
+                            rtn[idx] = Promise.resolve(returns[0][1]);
+                        }
+                        else {
+                            // should be unreachable
+                            throw new Error(`BUG: multiple returns found for task ${nextTask.name}__${nextTask.id}`);
+                        }
+                    }
+                    else if (errors.length > 0) {
+                        if (errors.length === 1) {
+                            const errorValue = errors[0][1];
+                            // Task failed
+                            const error = 
+                            // eslint-disable-next-line no-instanceof/no-instanceof
+                            errorValue instanceof Error
+                                ? errorValue
+                                : new Error(String(errorValue));
+                            rtn[idx] = Promise.reject(error);
+                        }
+                        else {
+                            // the only way this should happen is if the task executes multiple times and writes aren't cleared
+                            throw new Error(`BUG: multiple errors found for task ${nextTask.name}__${nextTask.id}`);
+                        }
+                    }
+                }
+                else {
+                    // Schedule the next task with retry
+                    const prom = (0, retry_js_1._runWithRetry)(nextTask, retryPolicy, {
+                        [constants_js_1.CONFIG_KEY_SEND]: writer.bind(this, nextTask),
+                        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+                        [constants_js_1.CONFIG_KEY_CALL]: call.bind(this, nextTask),
+                    });
+                    executingTasksMap[nextTask.id] = prom;
+                    addedPromiseSignal();
+                    rtn[idx] = prom.then(({ result, error }) => {
+                        if (error) {
+                            return Promise.reject(error);
+                        }
+                        return result;
+                    });
+                }
+            }
+            return Object.values(rtn);
+        };
+        const call = (task, func, name, input, options = {}) => {
+            const result = writer(task, [[constants_js_1.PUSH, null]], {
+                calls: [
+                    new types_js_1.Call({
+                        func,
+                        name,
+                        input,
+                        retry: options.retry,
+                        callbacks: options.callbacks,
+                    }),
+                ],
+            });
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (result !== undefined) {
+                if (result.length === 1) {
+                    return result[0];
+                }
+                return Promise.all(result);
+            }
+            return Promise.resolve();
+        };
+        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);
+        }
+        if (signal?.aborted) {
+            // note: don't use throwIfAborted here because it throws a DOMException,
+            // which isn't consistent with how we throw on abort below.
+            throw new Error("Abort");
+        }
+        // Start tasks
+        Object.assign(executingTasksMap, Object.fromEntries(tasks.map((pregelTask) => {
+            return [
+                pregelTask.id,
+                (0, retry_js_1._runWithRetry)(pregelTask, retryPolicy, {
+                    [constants_js_1.CONFIG_KEY_SEND]: writer?.bind(this, pregelTask),
+                    [constants_js_1.CONFIG_KEY_CALL]: call?.bind(this, pregelTask),
+                }).catch((error) => {
+                    return { task: pregelTask, error };
+                }),
+            ];
+        })));
+        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(executingTasksMap).length > 0) {
+            const settledTask = await Promise.race([
+                ...Object.values(executingTasksMap),
+                signalPromise,
+                addedPromiseWait,
+            ]);
+            if (settledTask === promiseAddedSymbol) {
+                continue;
+            }
+            yield settledTask;
+            delete executingTasksMap[settledTask.task.id];
+        }
+    }
+    /**
+     * Determines what writes to apply based on whether the task completed successfully, and what type of error occurred.
+     *
+     * Throws an error if the error is a {@link GraphBubbleUp} error and {@link PregelLoop}#isNested is true.
+     *
+     * Note that in the case of a {@link GraphBubbleUp} error that is not a {@link GraphInterrupt}, like a {@link Command}, this method does not apply any writes.
+     *
+     * @param task - The task to commit.
+     * @param error - The error that occurred, if any.
+     * @returns The {@link GraphInterrupt} that occurred, if the user's code threw one.
+     */
+    _commit(task, error) {
+        let graphInterrupt;
+        if (error !== undefined) {
+            if ((0, errors_js_1.isGraphBubbleUp)(error)) {
+                if (this.loop.isNested) {
+                    throw error;
+                }
+                if ((0, errors_js_1.isGraphInterrupt)(error)) {
+                    graphInterrupt = error;
+                    if (error.interrupts.length) {
+                        const interrupts = error.interrupts.map((interrupt) => [constants_js_1.INTERRUPT, interrupt]);
+                        const resumes = task.writes.filter((w) => w[0] === constants_js_1.RESUME);
+                        if (resumes.length) {
+                            interrupts.push(...resumes);
+                        }
+                        this.loop.putWrites(task.id, interrupts);
+                    }
+                }
+            }
+            else {
+                this.loop.putWrites(task.id, [
+                    [constants_js_1.ERROR, { message: error.message, name: error.name }],
+                ]);
+                throw error;
+            }
+        }
+        else {
+            if (this.nodeFinished &&
+                (task.config?.tags == null || !task.config.tags.includes(constants_js_1.TAG_HIDDEN))) {
+                this.nodeFinished(String(task.name));
+            }
+            if (task.writes.length === 0) {
+                // Add no writes marker
+                task.writes.push([constants_js_1.NO_WRITES, null]);
+            }
+            // Save task writes to checkpointer
+            this.loop.putWrites(task.id, task.writes);
+        }
+        return graphInterrupt;
+    }
+}
+exports.PregelRunner = PregelRunner;

package/dist/pregel/runner.d.ts

@@ -0,0 +1,64 @@
+import { PendingWrite } from "@langchain/langgraph-checkpoint";
+import { RetryPolicy } from "./utils/index.js";
+import { PregelLoop } from "./loop.js";
+/**
+ * Options for the {@link PregelRunner#tick} method.
+ */
+export type TickOptions = {
+    /**
+     * The deadline before which all tasks must be completed.
+     */
+    timeout?: number;
+    /**
+     * An optional {@link AbortSignal} to cancel processing of tasks.
+     */
+    signal?: AbortSignal;
+    /**
+     * The {@link RetryPolicy} to use for the tick.
+     */
+    retryPolicy?: RetryPolicy;
+    /**
+     * An optional callback to be called after all task writes are completed.
+     */
+    onStepWrite?: (step: number, writes: PendingWrite[]) => void;
+};
+/**
+ * Responsible for handling task execution on each tick of the {@link PregelLoop}.
+ */
+export declare class PregelRunner {
+    private nodeFinished?;
+    private loop;
+    /**
+     * Construct a new PregelRunner, which executes tasks from the provided PregelLoop.
+     * @param loop - The PregelLoop that produces tasks for this runner to execute.
+     */
+    constructor({ loop, nodeFinished, }: {
+        loop: PregelLoop;
+        nodeFinished?: (id: string) => void;
+    });
+    /**
+     * Execute tasks from the current step of the PregelLoop.
+     *
+     * Note: this method does NOT call {@link PregelLoop}#tick. That must be handled externally.
+     * @param options - Options for the execution.
+     */
+    tick(options?: TickOptions): Promise<void>;
+    /**
+     * Concurrently executes tasks with the requested retry policy, yielding a {@link SettledPregelTask} for each task as it completes.
+     * @param tasks - The tasks to execute.
+     * @param options - Options for the execution.
+     */
+    private _executeTasksWithRetry;
+    /**
+     * Determines what writes to apply based on whether the task completed successfully, and what type of error occurred.
+     *
+     * Throws an error if the error is a {@link GraphBubbleUp} error and {@link PregelLoop}#isNested is true.
+     *
+     * Note that in the case of a {@link GraphBubbleUp} error that is not a {@link GraphInterrupt}, like a {@link Command}, this method does not apply any writes.
+     *
+     * @param task - The task to commit.
+     * @param error - The error that occurred, if any.
+     * @returns The {@link GraphInterrupt} that occurred, if the user's code threw one.
+     */
+    private _commit;
+}