@langchain/langgraph 0.2.41 → 0.2.43-rc.0

package/dist/pregel/loop.js

@@ -1,70 +1,16 @@
-import { IterableReadableStream } from "@langchain/core/utils/stream";
 import { copyCheckpoint, emptyCheckpoint, AsyncBatchedStore, WRITES_IDX_MAP, } from "@langchain/langgraph-checkpoint";
 import { createCheckpoint, emptyChannels, } from "../channels/base.js";
-import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, } from "../constants.js";
-import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
+import { isCommand, CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_READ, CONFIG_KEY_RESUMING, CONFIG_KEY_STREAM, ERROR, INPUT, INTERRUPT, NULL_TASK_ID, RESUME, TAG_HIDDEN, PUSH, CONFIG_KEY_SCRATCHPAD, } from "../constants.js";
+import { _applyWrites, _prepareNextTasks, _prepareSingleTask, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapCommand, mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
 import { getSubgraphsSeenSet, EmptyInputError, GraphInterrupt, isGraphInterrupt, MultipleSubgraphsError, } from "../errors.js";
 import { getNewChannelVersions, patchConfigurable } from "./utils/index.js";
-import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, } from "./debug.js";
+import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, printStepTasks, } from "./debug.js";
+import { IterableReadableWritableStream } from "./stream.js";
 const INPUT_DONE = Symbol.for("INPUT_DONE");
 const INPUT_RESUMING = Symbol.for("INPUT_RESUMING");
 const DEFAULT_LOOP_LIMIT = 25;
-export class IterableReadableWritableStream extends 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);
-    }
-}
 function createDuplexStream(...streams) {
     return new IterableReadableWritableStream({
         passthroughFn: (value) => {
@@ -245,6 +191,36 @@ export 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
@@ -266,6 +242,7 @@ export 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;
@@ -274,6 +251,9 @@ export 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;
@@ -364,6 +344,7 @@ export class PregelLoop {
             channels,
             managed: params.managed,
             isNested,
+            manager: params.manager,
             skipDoneTasks,
             step,
             stop,
@@ -374,6 +355,9 @@ export class PregelLoop {
             nodes: params.nodes,
             stream,
             store,
+            interruptAfter: params.interruptAfter,
+            interruptBefore: params.interruptBefore,
+            debug: params.debug,
         });
     }
     _checkpointerPutAfterPrevious(input) {
@@ -454,7 +438,7 @@ export 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}"`);
         }
@@ -478,7 +462,7 @@ export class PregelLoop {
                 writes: mapOutputUpdates(this.outputKeys, Object.values(this.tasks).map((task) => [task, task.writes])).next().value ?? null,
             });
             // after execution, check if we should interrupt
-            if (shouldInterrupt(this.checkpoint, interruptAfter, Object.values(this.tasks))) {
+            if (shouldInterrupt(this.checkpoint, this.interruptAfter, Object.values(this.tasks))) {
                 this.status = "interrupt_after";
                 throw new GraphInterrupt();
             }
@@ -494,8 +478,9 @@ export 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
@@ -526,15 +511,10 @@ export 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 (shouldInterrupt(this.checkpoint, interruptBefore, Object.values(this.tasks))) {
+        if (shouldInterrupt(this.checkpoint, this.interruptBefore, Object.values(this.tasks))) {
             this.status = "interrupt_before";
             throw new GraphInterrupt();
         }
@@ -571,20 +551,59 @@ export class PregelLoop {
         }
         return suppress;
     }
+    acceptPush(task, writeIdx, call) {
+        if (this.interruptAfter?.length > 0 &&
+            shouldInterrupt(this.checkpoint, this.interruptAfter, [task])) {
+            this.toInterrupt.push(task);
+            return;
+        }
+        const pushed = _prepareSingleTask([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 &&
+                shouldInterrupt(this.checkpoint, this.interruptBefore, [pushed])) {
+                this.toInterrupt.push(pushed);
+                return;
+            }
+            this._emit(gatherIteratorSync(prefixGenerator(mapDebugTasks(this.step, [pushed]), "debug")));
+            if (this.debug) {
+                printStepTasks(this.step, [pushed]);
+            }
+            this.tasks[pushed.id] = pushed;
+            if (this.skipDoneTasks) {
+                this._matchWrites({ [pushed.id]: pushed });
+            }
+            return pushed;
+        }
+    }
     _suppressInterrupt(e) {
         return 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?.[CONFIG_KEY_RESUMING] !== undefined ||
                 this.input === null ||
                 isCommand(this.input));
+        // take resume value from parent
+        const scratchpad = configurable?.[CONFIG_KEY_SCRATCHPAD];
+        if (scratchpad && scratchpad.nullResume !== undefined) {
+            this.putWrites(NULL_TASK_ID, [[RESUME, scratchpad.nullResume]]);
+        }
         if (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 mapCommand(this.input, this.checkpointPendingWrites)) {
@@ -649,10 +668,10 @@ export 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 = patchConfigurable(this.config, {
-                [CONFIG_KEY_RESUMING]: isResuming,
+                [CONFIG_KEY_RESUMING]: this.input === INPUT_RESUMING,
             });
         }
     }
@@ -713,4 +732,20 @@ export class PregelLoop {
         }
         this.step += 1;
     }
+    _matchWrites(tasks) {
+        for (const [tid, k, v] of this.checkpointPendingWrites) {
+            if (k === ERROR || k === INTERRUPT || k === 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);
+            }
+        }
+    }
 }

package/dist/pregel/messages.d.ts

@@ -3,7 +3,7 @@ import { BaseMessage } from "@langchain/core/messages";
 import { Serialized } from "@langchain/core/load/serializable";
 import { LLMResult } from "@langchain/core/outputs";
 import { ChainValues } from "@langchain/core/utils/types";
-import { StreamChunk } from "./loop.js";
+import { StreamChunk } from "./stream.js";
 type Meta = [string[], Record<string, any>];
 /**
  * A callback handler that implements stream_mode=messages.

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,
     };
 }