@langchain/langgraph 0.1.1 → 0.1.2

package/dist/pregel/index.js

@@ -9,10 +9,11 @@ import { mapDebugTaskResults, printStepCheckpoint, printStepTasks, printStepWrit
 import { ChannelWrite, PASSTHROUGH } from "./write.js";
 import { CONFIG_KEY_CHECKPOINTER, CONFIG_KEY_READ, CONFIG_KEY_SEND, ERROR, INTERRUPT, } from "../constants.js";
 import { GraphRecursionError, GraphValueError, InvalidUpdateError, } from "../errors.js";
-import { executeTasks, _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
+import { _prepareNextTasks, _localRead, _applyWrites, } from "./algo.js";
 import { prefixGenerator } from "../utils.js";
 import { _coerceToDict, getNewChannelVersions } from "./utils.js";
 import { PregelLoop } from "./loop.js";
+import { executeTasksWithRetry } from "./retry.js";
 function isString(value) {
     return typeof value === "string";
 }
@@ -155,6 +156,12 @@ export class Pregel extends Runnable {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "retryPolicy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         let { streamMode } = fields;
         if (streamMode != null && !Array.isArray(streamMode)) {
             streamMode = [streamMode];
@@ -171,6 +178,7 @@ export class Pregel extends Runnable {
         this.stepTimeout = fields.stepTimeout ?? this.stepTimeout;
         this.debug = fields.debug ?? this.debug;
         this.checkpointer = fields.checkpointer;
+        this.retryPolicy = fields.retryPolicy;
         if (this.autoValidate) {
             this.validate();
         }
@@ -340,12 +348,11 @@ export class Pregel extends Runnable {
             writers.length > 1 ? RunnableSequence.from(writers) : writers[0],
             writes: [],
             triggers: [INTERRUPT],
-            config: undefined,
             id: uuid5(INTERRUPT, checkpoint.id),
         };
         // execute task
         await task.proc.invoke(task.input, patchConfig(config, {
-            runName: `${this.name}UpdateState`,
+            runName: config.runName ?? `${this.getName()}UpdateState`,
             configurable: {
                 [CONFIG_KEY_SEND]: (items) => task.writes.push(...items),
                 [CONFIG_KEY_READ]: _localRead.bind(undefined, checkpoint, channels, 
@@ -486,35 +493,15 @@ export class Pregel extends Runnable {
                 if (debug) {
                     printStepTasks(loop.step, 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 tasks = Object.fromEntries(loop.tasks
-                    .filter((task) => task.writes.length === 0)
-                    .map((pregelTask) => {
-                    return [
-                        pregelTask.id,
-                        async () => {
-                            let error;
-                            let result;
-                            try {
-                                result = await pregelTask.proc.invoke(pregelTask.input, pregelTask.config);
-                                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            }
-                            catch (e) {
-                                error = e;
-                                error.pregelTaskId = pregelTask.id;
-                            }
-                            return {
-                                task: pregelTask,
-                                result,
-                                error,
-                            };
-                        },
-                    ];
-                }));
                 try {
-                    for await (const task of executeTasks(tasks, this.stepTimeout, config.signal)) {
+                    // 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
+                    for await (const task of executeTasksWithRetry(loop.tasks.filter((task) => task.writes.length === 0), {
+                        stepTimeout: this.stepTimeout,
+                        signal: config.signal,
+                        retryPolicy: this.retryPolicy,
+                    })) {
                         loop.putWrites(task.id, task.writes);
                         if (streamMode.includes("updates")) {
                             yield* prefixGenerator(mapOutputUpdates(outputKeys, [task]), streamMode.length > 1 ? "updates" : undefined);

package/dist/pregel/loop.cjs

@@ -269,7 +269,7 @@ class PregelLoop {
                 : (0, io_js_1.mapOutputValues)(outputKeys, writes, this.channels).next().value;
             await this._putCheckpoint({
                 source: "loop",
-                writes: metadataWrites,
+                writes: metadataWrites ?? null,
             });
             // after execution, check if we should interrupt
             if ((0, algo_js_1.shouldInterrupt)(this.checkpoint, interruptAfter, this.tasks)) {
@@ -377,7 +377,10 @@ class PregelLoop {
                 },
             ]), this.checkpointerGetNextVersion);
             // save input checkpoint
-            await this._putCheckpoint({ source: "input", writes: this.input });
+            await this._putCheckpoint({
+                source: "input",
+                writes: this.input ?? null,
+            });
         }
         // done with input
         this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;

package/dist/pregel/loop.js

@@ -263,7 +263,7 @@ export class PregelLoop {
                 : mapOutputValues(outputKeys, writes, this.channels).next().value;
             await this._putCheckpoint({
                 source: "loop",
-                writes: metadataWrites,
+                writes: metadataWrites ?? null,
             });
             // after execution, check if we should interrupt
             if (shouldInterrupt(this.checkpoint, interruptAfter, this.tasks)) {
@@ -371,7 +371,10 @@ export class PregelLoop {
                 },
             ]), this.checkpointerGetNextVersion);
             // save input checkpoint
-            await this._putCheckpoint({ source: "input", writes: this.input });
+            await this._putCheckpoint({
+                source: "input",
+                writes: this.input ?? null,
+            });
         }
         // done with input
         this.input = isResuming ? INPUT_RESUMING : INPUT_DONE;

package/dist/pregel/read.cjs

@@ -63,7 +63,7 @@ const defaultRunnableBound =
 /* #__PURE__ */ new runnables_1.RunnablePassthrough();
 class PregelNode extends runnables_1.RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(fields.tags ? fields.tags : []),
@@ -121,12 +121,26 @@ class PregelNode extends runnables_1.RunnableBinding {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "retryPolicy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channels = channels;
         this.triggers = triggers;
         this.mapper = mapper;
         this.writers = writers ?? this.writers;
         this.bound = bound ?? this.bound;
         this.kwargs = kwargs ?? this.kwargs;
+        this.metadata = metadata ?? this.metadata;
+        this.retryPolicy = retryPolicy;
     }
     getWriters() {
         const newWriters = [...this.writers];
@@ -188,6 +202,7 @@ class PregelNode extends runnables_1.RunnableBinding {
             bound: this.bound,
             kwargs: this.kwargs,
             config: this.config,
+            retryPolicy: this.retryPolicy,
         });
     }
     pipe(coerceable) {
@@ -200,6 +215,7 @@ class PregelNode extends runnables_1.RunnableBinding {
                 bound: this.bound,
                 config: this.config,
                 kwargs: this.kwargs,
+                retryPolicy: this.retryPolicy,
             });
         }
         else if (this.bound === defaultRunnableBound) {
@@ -211,6 +227,7 @@ class PregelNode extends runnables_1.RunnableBinding {
                 bound: (0, runnables_1._coerceToRunnable)(coerceable),
                 config: this.config,
                 kwargs: this.kwargs,
+                retryPolicy: this.retryPolicy,
             });
         }
         else {
@@ -222,6 +239,7 @@ class PregelNode extends runnables_1.RunnableBinding {
                 bound: this.bound.pipe(coerceable),
                 config: this.config,
                 kwargs: this.kwargs,
+                retryPolicy: this.retryPolicy,
             });
         }
     }

package/dist/pregel/read.d.ts

@@ -1,5 +1,6 @@
 import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 import { RunnableCallable } from "../utils.js";
+import type { RetryPolicy } from "./utils.js";
 export declare class ChannelRead<RunInput = any> extends RunnableCallable {
     lc_graph_name: string;
     channel: string | Array<string>;
@@ -17,6 +18,8 @@ interface PregelNodeArgs<RunInput, RunOutput> extends Partial<RunnableBindingArg
     bound?: Runnable<RunInput, RunOutput>;
     kwargs?: Record<string, any>;
     config?: RunnableConfig;
+    metadata?: Record<string, unknown>;
+    retryPolicy?: RetryPolicy;
 }
 export type PregelNodeInputType = any;
 export type PregelNodeOutputType = any;
@@ -28,6 +31,8 @@ export declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = Preg
     writers: Runnable[];
     bound: Runnable<RunInput, RunOutput>;
     kwargs: Record<string, any>;
+    metadata: Record<string, unknown>;
+    retryPolicy?: RetryPolicy;
     constructor(fields: PregelNodeArgs<RunInput, RunOutput>);
     getWriters(): Array<Runnable>;
     getNode(): Runnable<RunInput, RunOutput> | undefined;

package/dist/pregel/read.js

@@ -59,7 +59,7 @@ const defaultRunnableBound =
 /* #__PURE__ */ new RunnablePassthrough();
 export class PregelNode extends RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
             ...(fields.tags ? fields.tags : []),
@@ -117,12 +117,26 @@ export class PregelNode extends RunnableBinding {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "metadata", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "retryPolicy", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.channels = channels;
         this.triggers = triggers;
         this.mapper = mapper;
         this.writers = writers ?? this.writers;
         this.bound = bound ?? this.bound;
         this.kwargs = kwargs ?? this.kwargs;
+        this.metadata = metadata ?? this.metadata;
+        this.retryPolicy = retryPolicy;
     }
     getWriters() {
         const newWriters = [...this.writers];
@@ -184,6 +198,7 @@ export class PregelNode extends RunnableBinding {
             bound: this.bound,
             kwargs: this.kwargs,
             config: this.config,
+            retryPolicy: this.retryPolicy,
         });
     }
     pipe(coerceable) {
@@ -196,6 +211,7 @@ export class PregelNode extends RunnableBinding {
                 bound: this.bound,
                 config: this.config,
                 kwargs: this.kwargs,
+                retryPolicy: this.retryPolicy,
             });
         }
         else if (this.bound === defaultRunnableBound) {
@@ -207,6 +223,7 @@ export class PregelNode extends RunnableBinding {
                 bound: _coerceToRunnable(coerceable),
                 config: this.config,
                 kwargs: this.kwargs,
+                retryPolicy: this.retryPolicy,
             });
         }
         else {
@@ -218,6 +235,7 @@ export class PregelNode extends RunnableBinding {
                 bound: this.bound.pipe(coerceable),
                 config: this.config,
                 kwargs: this.kwargs,
+                retryPolicy: this.retryPolicy,
             });
         }
     }

package/dist/pregel/retry.cjs

@@ -0,0 +1,147 @@
+"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;
+const errors_js_1 = require("../errors.cjs");
+exports.DEFAULT_INITIAL_INTERVAL = 500;
+exports.DEFAULT_BACKOFF_FACTOR = 2;
+exports.DEFAULT_MAX_INTERVAL = 128000;
+exports.DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_STATUS_NO_RETRY = [
+    400,
+    401,
+    402,
+    403,
+    404,
+    405,
+    406,
+    407,
+    409, // Conflict
+];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const DEFAULT_RETRY_ON_HANDLER = (error) => {
+    if (error.message.startsWith("Cancel") ||
+        error.message.startsWith("AbortError") ||
+        error.name === "AbortError") {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.code === "ECONNABORTED") {
+        return false;
+    }
+    const status = 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error?.response?.status ?? error?.status;
+    if (status && DEFAULT_STATUS_NO_RETRY.includes(+status)) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.error?.code === "insufficient_quota") {
+        return false;
+    }
+    return true;
+};
+async function* executeTasksWithRetry(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tasks, options
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    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 { task, error } = await Promise.race([
+            ...Object.values(executingTasksMap),
+            signalPromise,
+        ]);
+        if (error !== undefined) {
+            // TODO: don't stop others if exception is interrupt
+            throw error;
+        }
+        yield task;
+        delete executingTasksMap[task.id];
+    }
+}
+exports.executeTasksWithRetry = executeTasksWithRetry;
+async function _runWithRetry(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+pregelTask, retryPolicy) {
+    const resolvedRetryPolicy = pregelTask.retry_policy ?? retryPolicy;
+    let interval = resolvedRetryPolicy !== undefined
+        ? resolvedRetryPolicy.initialInterval ?? exports.DEFAULT_INITIAL_INTERVAL
+        : 0;
+    let attempts = 0;
+    let error;
+    let result;
+    // 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();
+        }
+        error = undefined;
+        try {
+            result = await pregelTask.proc.invoke(pregelTask.input, pregelTask.config);
+            break;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            error = e;
+            error.pregelTaskId = pregelTask.id;
+            if (error.name === errors_js_1.GraphInterrupt.unminifiable_name) {
+                break;
+            }
+            if (resolvedRetryPolicy === undefined) {
+                break;
+            }
+            attempts += 1;
+            // check if we should give up
+            if (attempts >= (resolvedRetryPolicy.maxAttempts ?? exports.DEFAULT_MAX_RETRIES)) {
+                break;
+            }
+            const retryOn = resolvedRetryPolicy.retryOn ?? DEFAULT_RETRY_ON_HANDLER;
+            if (!retryOn(error)) {
+                break;
+            }
+            interval = Math.min(resolvedRetryPolicy.maxInterval ?? exports.DEFAULT_MAX_INTERVAL, interval * (resolvedRetryPolicy.backoffFactor ?? exports.DEFAULT_BACKOFF_FACTOR));
+            const intervalWithJitter = resolvedRetryPolicy.jitter
+                ? Math.floor(interval + Math.random() * 1000)
+                : interval;
+            // sleep before retrying
+            // eslint-disable-next-line no-promise-executor-return
+            await new Promise((resolve) => setTimeout(resolve, intervalWithJitter));
+            // log the retry
+            const errorName = error.name ??
+                // 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)} seconds (attempt ${attempts}) after ${errorName}: ${error}`);
+        }
+    }
+    return {
+        task: pregelTask,
+        result,
+        error,
+    };
+}

package/dist/pregel/retry.d.ts

@@ -0,0 +1,11 @@
+import { PregelExecutableTask } from "./types.js";
+import type { RetryPolicy } from "./utils.js";
+export declare const DEFAULT_INITIAL_INTERVAL = 500;
+export declare const DEFAULT_BACKOFF_FACTOR = 2;
+export declare const DEFAULT_MAX_INTERVAL = 128000;
+export declare const DEFAULT_MAX_RETRIES = 3;
+export declare function executeTasksWithRetry(tasks: PregelExecutableTask<any, any>[], options?: {
+    stepTimeout?: number;
+    signal?: AbortSignal;
+    retryPolicy?: RetryPolicy;
+}): AsyncGenerator<PregelExecutableTask<any, any>>;

package/dist/pregel/retry.js

@@ -0,0 +1,143 @@
+import { GraphInterrupt } from "../errors.js";
+export const DEFAULT_INITIAL_INTERVAL = 500;
+export const DEFAULT_BACKOFF_FACTOR = 2;
+export const DEFAULT_MAX_INTERVAL = 128000;
+export const DEFAULT_MAX_RETRIES = 3;
+const DEFAULT_STATUS_NO_RETRY = [
+    400,
+    401,
+    402,
+    403,
+    404,
+    405,
+    406,
+    407,
+    409, // Conflict
+];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const DEFAULT_RETRY_ON_HANDLER = (error) => {
+    if (error.message.startsWith("Cancel") ||
+        error.message.startsWith("AbortError") ||
+        error.name === "AbortError") {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.code === "ECONNABORTED") {
+        return false;
+    }
+    const status = 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error?.response?.status ?? error?.status;
+    if (status && DEFAULT_STATUS_NO_RETRY.includes(+status)) {
+        return false;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.error?.code === "insufficient_quota") {
+        return false;
+    }
+    return true;
+};
+export async function* executeTasksWithRetry(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+tasks, options
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+) {
+    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 { task, error } = await Promise.race([
+            ...Object.values(executingTasksMap),
+            signalPromise,
+        ]);
+        if (error !== undefined) {
+            // TODO: don't stop others if exception is interrupt
+            throw error;
+        }
+        yield task;
+        delete executingTasksMap[task.id];
+    }
+}
+async function _runWithRetry(
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+pregelTask, retryPolicy) {
+    const resolvedRetryPolicy = pregelTask.retry_policy ?? retryPolicy;
+    let interval = resolvedRetryPolicy !== undefined
+        ? resolvedRetryPolicy.initialInterval ?? DEFAULT_INITIAL_INTERVAL
+        : 0;
+    let attempts = 0;
+    let error;
+    let result;
+    // 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();
+        }
+        error = undefined;
+        try {
+            result = await pregelTask.proc.invoke(pregelTask.input, pregelTask.config);
+            break;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        }
+        catch (e) {
+            error = e;
+            error.pregelTaskId = pregelTask.id;
+            if (error.name === GraphInterrupt.unminifiable_name) {
+                break;
+            }
+            if (resolvedRetryPolicy === undefined) {
+                break;
+            }
+            attempts += 1;
+            // check if we should give up
+            if (attempts >= (resolvedRetryPolicy.maxAttempts ?? DEFAULT_MAX_RETRIES)) {
+                break;
+            }
+            const retryOn = resolvedRetryPolicy.retryOn ?? DEFAULT_RETRY_ON_HANDLER;
+            if (!retryOn(error)) {
+                break;
+            }
+            interval = Math.min(resolvedRetryPolicy.maxInterval ?? DEFAULT_MAX_INTERVAL, interval * (resolvedRetryPolicy.backoffFactor ?? DEFAULT_BACKOFF_FACTOR));
+            const intervalWithJitter = resolvedRetryPolicy.jitter
+                ? Math.floor(interval + Math.random() * 1000)
+                : interval;
+            // sleep before retrying
+            // eslint-disable-next-line no-promise-executor-return
+            await new Promise((resolve) => setTimeout(resolve, intervalWithJitter));
+            // log the retry
+            const errorName = error.name ??
+                // 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)} seconds (attempt ${attempts}) after ${errorName}: ${error}`);
+        }
+    }
+    return {
+        task: pregelTask,
+        result,
+        error,
+    };
+}

package/dist/pregel/types.d.ts

@@ -2,6 +2,7 @@ import type { Runnable, RunnableConfig } from "@langchain/core/runnables";
 import type { PendingWrite, CheckpointMetadata, BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import type { BaseChannel } from "../channels/base.js";
 import type { PregelNode } from "./read.js";
+import { RetryPolicy } from "./utils.js";
 export type StreamMode = "values" | "updates" | "debug";
 /**
  * Construct a type with a set of properties K of type T
@@ -41,6 +42,7 @@ export interface PregelInterface<Nn extends StrRecord<string, PregelNode>, Cc ex
      */
     debug?: boolean;
     checkpointer?: BaseCheckpointSaver;
+    retryPolicy?: RetryPolicy;
 }
 export type PregelParams<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel>> = Omit<PregelInterface<Nn, Cc>, "streamChannelsAsIs">;
 export interface PregelTaskDescription {
@@ -53,9 +55,9 @@ export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyK
     readonly input: unknown;
     readonly proc: Runnable;
     readonly writes: PendingWrite<C>[];
-    readonly config: RunnableConfig | undefined;
+    readonly config?: RunnableConfig;
     readonly triggers: Array<string>;
-    readonly retry_policy?: string;
+    readonly retry_policy?: RetryPolicy;
     readonly id: string;
 }
 export interface StateSnapshot {

package/dist/pregel/utils.d.ts

@@ -8,3 +8,29 @@ export declare function _getIdMetadata(metadata: Record<string, unknown>): {
     langgraph_triggers: unknown;
     langgraph_task_idx: unknown;
 };
+export type RetryPolicy = {
+    /**
+     * Amount of time that must elapse before the first retry occurs in milliseconds.
+     * @default 500
+     */
+    initialInterval?: number;
+    /**
+     * Multiplier by which the interval increases after each retry.
+     * @default 2
+     */
+    backoffFactor?: number;
+    /**
+     * Maximum amount of time that may elapse between retries in milliseconds.
+     * @default 128000
+     */
+    maxInterval?: number;
+    /**
+     * Maximum amount of time that may elapse between retries.
+     * @default 3
+     */
+    maxAttempts?: number;
+    /** Whether to add random jitter to the interval between retries. */
+    jitter?: boolean;
+    /** A function that returns True for exceptions that should trigger a retry. */
+    retryOn?: (e: any) => boolean;
+};

package/dist/web.d.ts

@@ -1,4 +1,5 @@
 export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, messagesStateReducer, Annotation, type StateType, type UpdateType, type CompiledGraph, } from "./graph/index.js";
 export { GraphRecursionError, GraphValueError, InvalidUpdateError, EmptyChannelError, } from "./errors.js";
+export { type RetryPolicy } from "./pregel/utils.js";
 export { Send } from "./constants.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "@langchain/langgraph-checkpoint";