@langchain/langgraph 0.1.0 → 0.1.2

package/dist/graph/state.cjs

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CompiledStateGraph = exports.StateGraph = void 0;
+/* eslint-disable @typescript-eslint/no-use-before-define */
+const runnables_1 = require("@langchain/core/runnables");
 const graph_js_1 = require("./graph.cjs");
 const write_js_1 = require("../pregel/write.cjs");
 const read_js_1 = require("../pregel/read.cjs");
@@ -11,6 +13,68 @@ const constants_js_1 = require("../constants.cjs");
 const errors_js_1 = require("../errors.cjs");
 const annotation_js_1 = require("./annotation.cjs");
 const ROOT = "__root__";
+/**
+ * A graph whose nodes communicate by reading and writing to a shared state.
+ * Each node takes a defined `State` as input and returns a `Partial<State>`.
+ *
+ * Each state key can optionally be annotated with a reducer function that
+ * will be used to aggregate the values of that key received from multiple nodes.
+ * The signature of a reducer function is (left: Value, right: UpdateValue) => Value.
+ *
+ * See {@link Annotation} for more on defining state.
+ *
+ * After adding nodes and edges to your graph, you must call `.compile()` on it before
+ * you can use it.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   type BaseMessage,
+ *   AIMessage,
+ *   HumanMessage,
+ * } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const StateAnnotation = Annotation.Root({
+ *   sentiment: Annotation<string>,
+ *   messages: Annotation<BaseMessage[]>({
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(StateAnnotation);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof StateAnnotation.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *     sentiment: "positive",
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   .addEdge("__start__", "myNode")
+ *   .addEdge("myNode", "__end__")
+ *   .compile();
+ *
+ * await graph.invoke({ messages: [new HumanMessage("how are you?")] });
+ *
+ * // {
+ * //   messages: [HumanMessage("how are you?"), AIMessage("Some new response")],
+ * //   sentiment: "positive",
+ * // }
+ * ```
+ */
 class StateGraph extends graph_js_1.Graph {
     constructor(fields) {
         super();
@@ -55,11 +119,27 @@ class StateGraph extends graph_js_1.Graph {
             ...Array.from(this.waitingEdges).flatMap(([starts, end]) => starts.map((start) => [start, end])),
         ]);
     }
-    addNode(key, action) {
+    addNode(key, action, options) {
         if (key in this.channels) {
             throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
         }
-        return super.addNode(key, action);
+        if (key.includes(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR)) {
+            throw new Error(`"${constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR}" is a reserved character and is not allowed in node names.`);
+        }
+        this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
+        if (key in this.nodes) {
+            throw new Error(`Node \`${key}\` already present.`);
+        }
+        if (key === graph_js_1.END || key === graph_js_1.START) {
+            throw new Error(`Node \`${key}\` is reserved.`);
+        }
+        const nodeSpec = {
+            runnable: (0, runnables_1._coerceToRunnable)(action),
+            retryPolicy: options?.retryPolicy,
+            metadata: options?.metadata,
+        };
+        this.nodes[key] = nodeSpec;
+        return this;
     }
     addEdge(startKey, endKey) {
         if (typeof startKey === "string") {
@@ -198,7 +278,8 @@ class CompiledStateGraph extends graph_js_1.CompiledGraph {
                 writers: [
                     new write_js_1.ChannelWrite(stateWriteEntries.concat({ channel: key, value: key }), [constants_js_1.TAG_HIDDEN]),
                 ],
-                bound: node,
+                bound: node?.runnable,
+                retryPolicy: node?.retryPolicy,
             });
         }
     }

package/dist/graph/state.d.ts

@@ -1,9 +1,10 @@
-import { Runnable, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
+import { RunnableLike } from "@langchain/core/runnables";
 import { BaseCheckpointSaver } from "@langchain/langgraph-checkpoint";
 import { BaseChannel } from "../channels/base.js";
-import { END, CompiledGraph, Graph, START, Branch } from "./graph.js";
+import { END, CompiledGraph, Graph, START, Branch, AddNodeOptions, NodeSpec } from "./graph.js";
 import { All } from "../pregel/types.js";
 import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
+import type { RetryPolicy } from "../pregel/utils.js";
 export type ChannelReducers<Channels extends object> = {
     [K in keyof Channels]: SingleReducer<Channels[K], any>;
 };
@@ -14,12 +15,81 @@ export interface StateGraphArgs<Channels extends object | unknown> {
         __root__: Channels;
     }>;
 }
-export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START> extends Graph<N, S, U> {
+export type StateGraphNodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput> & {
+    input?: any;
+    retryPolicy?: RetryPolicy;
+};
+export type StateGraphAddNodeOptions = {
+    retryPolicy?: RetryPolicy;
+} & AddNodeOptions;
+/**
+ * A graph whose nodes communicate by reading and writing to a shared state.
+ * Each node takes a defined `State` as input and returns a `Partial<State>`.
+ *
+ * Each state key can optionally be annotated with a reducer function that
+ * will be used to aggregate the values of that key received from multiple nodes.
+ * The signature of a reducer function is (left: Value, right: UpdateValue) => Value.
+ *
+ * See {@link Annotation} for more on defining state.
+ *
+ * After adding nodes and edges to your graph, you must call `.compile()` on it before
+ * you can use it.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   type BaseMessage,
+ *   AIMessage,
+ *   HumanMessage,
+ * } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const StateAnnotation = Annotation.Root({
+ *   sentiment: Annotation<string>,
+ *   messages: Annotation<BaseMessage[]>({
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(StateAnnotation);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof StateAnnotation.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *     sentiment: "positive",
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   .addEdge("__start__", "myNode")
+ *   .addEdge("myNode", "__end__")
+ *   .compile();
+ *
+ * await graph.invoke({ messages: [new HumanMessage("how are you?")] });
+ *
+ * // {
+ * //   messages: [HumanMessage("how are you?"), AIMessage("Some new response")],
+ * //   sentiment: "positive",
+ * // }
+ * ```
+ */
+export declare class StateGraph<SD extends StateDefinition | unknown, S = SD extends StateDefinition ? StateType<SD> : SD, U = SD extends StateDefinition ? UpdateType<SD> : Partial<S>, N extends string = typeof START> extends Graph<N, S, U, StateGraphNodeSpec<S, U>> {
     channels: Record<string, BaseChannel>;
     waitingEdges: Set<[N[], N]>;
     constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> : StateGraphArgs<S>);
     get allEdges(): Set<[string, string]>;
-    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U>): StateGraph<SD, S, U, N | K>;
+    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
     compile({ checkpointer, interruptBefore, interruptAfter, }?: {
         checkpointer?: BaseCheckpointSaver;
@@ -30,7 +100,7 @@ export declare class StateGraph<SD extends StateDefinition | unknown, S = SD ext
 export declare class CompiledStateGraph<S, U, N extends string = typeof START> extends CompiledGraph<N, S, U> {
     builder: StateGraph<unknown, S, U, N>;
     attachNode(key: typeof START, node?: never): void;
-    attachNode(key: N, node: Runnable<S, U, RunnableConfig>): void;
+    attachNode(key: N, node: StateGraphNodeSpec<S, U>): void;
     attachEdge(start: N | N[] | "__start__", end: N | "__end__"): void;
     attachBranch(start: N | typeof START, name: string, branch: Branch<S, N>): void;
 }

package/dist/graph/state.js

@@ -1,13 +1,77 @@
-import { END, CompiledGraph, Graph, START } from "./graph.js";
+/* eslint-disable @typescript-eslint/no-use-before-define */
+import { _coerceToRunnable, } from "@langchain/core/runnables";
+import { END, CompiledGraph, Graph, START, } from "./graph.js";
 import { ChannelWrite, PASSTHROUGH, SKIP_WRITE, } from "../pregel/write.js";
 import { ChannelRead, PregelNode } from "../pregel/read.js";
 import { NamedBarrierValue } from "../channels/named_barrier_value.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { RunnableCallable } from "../utils.js";
-import { _isSend, TAG_HIDDEN } from "../constants.js";
+import { _isSend, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
 import { InvalidUpdateError } from "../errors.js";
 import { getChannel, } from "./annotation.js";
 const ROOT = "__root__";
+/**
+ * A graph whose nodes communicate by reading and writing to a shared state.
+ * Each node takes a defined `State` as input and returns a `Partial<State>`.
+ *
+ * Each state key can optionally be annotated with a reducer function that
+ * will be used to aggregate the values of that key received from multiple nodes.
+ * The signature of a reducer function is (left: Value, right: UpdateValue) => Value.
+ *
+ * See {@link Annotation} for more on defining state.
+ *
+ * After adding nodes and edges to your graph, you must call `.compile()` on it before
+ * you can use it.
+ *
+ * @example
+ * ```ts
+ * import {
+ *   type BaseMessage,
+ *   AIMessage,
+ *   HumanMessage,
+ * } from "@langchain/core/messages";
+ * import { StateGraph, Annotation } from "@langchain/langgraph";
+ *
+ * // Define a state with a single key named "messages" that will
+ * // combine a returned BaseMessage or arrays of BaseMessages
+ * const StateAnnotation = Annotation.Root({
+ *   sentiment: Annotation<string>,
+ *   messages: Annotation<BaseMessage[]>({
+ *     reducer: (left: BaseMessage[], right: BaseMessage | BaseMessage[]) => {
+ *       if (Array.isArray(right)) {
+ *         return left.concat(right);
+ *       }
+ *       return left.concat([right]);
+ *     },
+ *     default: () => [],
+ *   }),
+ * });
+ *
+ * const graphBuilder = new StateGraph(StateAnnotation);
+ *
+ * // A node in the graph that returns an object with a "messages" key
+ * // will update the state by combining the existing value with the returned one.
+ * const myNode = (state: typeof StateAnnotation.State) => {
+ *   return {
+ *     messages: [new AIMessage("Some new response")],
+ *     sentiment: "positive",
+ *   };
+ * };
+ *
+ * const graph = graphBuilder
+ *   .addNode("myNode", myNode)
+ *   .addEdge("__start__", "myNode")
+ *   .addEdge("myNode", "__end__")
+ *   .compile();
+ *
+ * await graph.invoke({ messages: [new HumanMessage("how are you?")] });
+ *
+ * // {
+ * //   messages: [HumanMessage("how are you?"), AIMessage("Some new response")],
+ * //   sentiment: "positive",
+ * // }
+ * ```
+ */
 export class StateGraph extends Graph {
     constructor(fields) {
         super();
@@ -52,11 +116,27 @@ export class StateGraph extends Graph {
             ...Array.from(this.waitingEdges).flatMap(([starts, end]) => starts.map((start) => [start, end])),
         ]);
     }
-    addNode(key, action) {
+    addNode(key, action, options) {
         if (key in this.channels) {
             throw new Error(`${key} is already being used as a state attribute (a.k.a. a channel), cannot also be used as a node name.`);
         }
-        return super.addNode(key, action);
+        if (key.includes(CHECKPOINT_NAMESPACE_SEPARATOR)) {
+            throw new Error(`"${CHECKPOINT_NAMESPACE_SEPARATOR}" is a reserved character and is not allowed in node names.`);
+        }
+        this.warnIfCompiled(`Adding a node to a graph that has already been compiled. This will not be reflected in the compiled graph.`);
+        if (key in this.nodes) {
+            throw new Error(`Node \`${key}\` already present.`);
+        }
+        if (key === END || key === START) {
+            throw new Error(`Node \`${key}\` is reserved.`);
+        }
+        const nodeSpec = {
+            runnable: _coerceToRunnable(action),
+            retryPolicy: options?.retryPolicy,
+            metadata: options?.metadata,
+        };
+        this.nodes[key] = nodeSpec;
+        return this;
     }
     addEdge(startKey, endKey) {
         if (typeof startKey === "string") {
@@ -194,7 +274,8 @@ export class CompiledStateGraph extends CompiledGraph {
                 writers: [
                     new ChannelWrite(stateWriteEntries.concat({ channel: key, value: key }), [TAG_HIDDEN]),
                 ],
-                bound: node,
+                bound: node?.runnable,
+                retryPolicy: node?.retryPolicy,
             });
         }
     }

package/dist/prebuilt/agent_executor.cjs

@@ -4,6 +4,7 @@ exports.createAgentExecutor = void 0;
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
 const index_js_1 = require("../graph/index.cjs");
+/** @ignore */
 function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
     if (!Array.isArray(tools)) {

package/dist/prebuilt/agent_executor.d.ts

@@ -7,12 +7,14 @@ interface Step {
     action: AgentAction | AgentFinish;
     observation: unknown;
 }
+/** @ignore */
 export interface AgentExecutorState {
     agentOutcome?: AgentAction | AgentFinish;
     steps: Array<Step>;
     input: string;
     chatHistory?: BaseMessage[];
 }
+/** @ignore */
 export declare function createAgentExecutor({ agentRunnable, tools, }: {
     agentRunnable: Runnable;
     tools: Array<Tool> | ToolExecutor;

package/dist/prebuilt/agent_executor.js

@@ -1,6 +1,7 @@
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph } from "../graph/state.js";
 import { END, START } from "../graph/index.js";
+/** @ignore */
 export function createAgentExecutor({ agentRunnable, tools, }) {
     let toolExecutor;
     if (!Array.isArray(tools)) {

package/dist/prebuilt/chat_agent_executor.cjs

@@ -7,6 +7,7 @@ const runnables_1 = require("@langchain/core/runnables");
 const tool_executor_js_1 = require("./tool_executor.cjs");
 const state_js_1 = require("../graph/state.cjs");
 const index_js_1 = require("../graph/index.cjs");
+/** @ignore */
 function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;
     let toolClasses;

package/dist/prebuilt/chat_agent_executor.d.ts

@@ -4,9 +4,11 @@ import { RunnableToolLike } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { CompiledStateGraph } from "../graph/state.js";
 import { START } from "../graph/index.js";
+/** @ignore */
 export type FunctionCallingExecutorState = {
     messages: Array<BaseMessage>;
 };
+/** @ignore */
 export declare function createFunctionCallingExecutor<Model extends object>({ model, tools, }: {
     model: Model;
     tools: Array<StructuredToolInterface | RunnableToolLike> | ToolExecutor;

package/dist/prebuilt/chat_agent_executor.js

@@ -4,6 +4,7 @@ import { RunnableLambda, } from "@langchain/core/runnables";
 import { ToolExecutor } from "./tool_executor.js";
 import { StateGraph, } from "../graph/state.js";
 import { END, START } from "../graph/index.js";
+/** @ignore */
 export function createFunctionCallingExecutor({ model, tools, }) {
     let toolExecutor;
     let toolClasses;

package/dist/pregel/algo.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._prepareNextTasks = exports._applyWrites = exports._localWrite = exports._localRead = exports.shouldInterrupt = exports.executeTasks = exports.increment = void 0;
+exports._prepareNextTasks = exports._applyWrites = exports._localWrite = exports._localRead = exports.shouldInterrupt = exports.increment = void 0;
 /* eslint-disable no-param-reassign */
 const runnables_1 = require("@langchain/core/runnables");
 const langgraph_checkpoint_1 = require("@langchain/langgraph-checkpoint");
@@ -13,46 +13,6 @@ const increment = (current) => {
     return current !== undefined ? current + 1 : 1;
 };
 exports.increment = increment;
-async function* executeTasks(tasks, stepTimeout, signal
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    if (stepTimeout && signal) {
-        if ("any" in AbortSignal) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            signal = AbortSignal.any([
-                signal,
-                AbortSignal.timeout(stepTimeout),
-            ]);
-        }
-    }
-    else if (stepTimeout) {
-        signal = AbortSignal.timeout(stepTimeout);
-    }
-    // Abort if signal is aborted
-    signal?.throwIfAborted();
-    // Start all tasks
-    const executingTasks = Object.fromEntries(Object.entries(tasks).map(([taskId, task]) => {
-        return [taskId, task()];
-    }));
-    let listener;
-    const signalPromise = new Promise((_resolve, reject) => {
-        listener = () => reject(new Error("Abort"));
-        signal?.addEventListener("abort", listener);
-    }).finally(() => signal?.removeEventListener("abort", listener));
-    while (Object.keys(executingTasks).length > 0) {
-        const { task, error } = await Promise.race([
-            ...Object.values(executingTasks),
-            signalPromise,
-        ]);
-        if (error !== undefined) {
-            // TODO: don't stop others if exception is interrupt
-            throw error;
-        }
-        yield task;
-        delete executingTasks[task.id];
-    }
-}
-exports.executeTasks = executeTasks;
 function shouldInterrupt(checkpoint, interruptNodes, tasks) {
     const versionValues = Object.values(checkpoint.channel_versions);
     const versionType = versionValues.length > 0 ? typeof versionValues[0] : undefined;
@@ -253,6 +213,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                         },
                     }),
                     id: taskId,
+                    retry_policy: proc.retryPolicy,
                 });
             }
         }
@@ -325,6 +286,7 @@ function _prepareNextTasks(checkpoint, processes, channels, config, forExecution
                             },
                         }),
                         id: taskId,
+                        retry_policy: proc.retryPolicy,
                     });
                 }
             }

package/dist/pregel/algo.d.ts

@@ -16,11 +16,6 @@ export type WritesProtocol<C = string> = {
     triggers: string[];
 };
 export declare const increment: (current?: number) => number;
-export declare function executeTasks(tasks: Record<string, () => Promise<{
-    task: PregelExecutableTask<any, any>;
-    result: any;
-    error: Error;
-}>>, stepTimeout?: number, signal?: AbortSignal): AsyncGenerator<PregelExecutableTask<any, any>>;
 export declare function shouldInterrupt<N extends PropertyKey, C extends PropertyKey>(checkpoint: Checkpoint, interruptNodes: All | N[], tasks: PregelExecutableTask<N, C>[]): boolean;
 export declare function _localRead<Cc extends StrRecord<string, BaseChannel>>(checkpoint: ReadonlyCheckpoint, channels: Cc, task: WritesProtocol<keyof Cc>, select: Array<keyof Cc> | keyof Cc, fresh?: boolean): Record<string, unknown> | unknown;
 export declare function _localWrite(commit: (writes: [string, any][]) => void, processes: Record<string, PregelNode>, channels: Record<string, BaseChannel>, writes: [string, any][]): void;

package/dist/pregel/algo.js

@@ -9,45 +9,6 @@ import { _getIdMetadata, getNullChannelVersion } from "./utils.js";
 export const increment = (current) => {
     return current !== undefined ? current + 1 : 1;
 };
-export async function* executeTasks(tasks, stepTimeout, signal
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-) {
-    if (stepTimeout && signal) {
-        if ("any" in AbortSignal) {
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            signal = AbortSignal.any([
-                signal,
-                AbortSignal.timeout(stepTimeout),
-            ]);
-        }
-    }
-    else if (stepTimeout) {
-        signal = AbortSignal.timeout(stepTimeout);
-    }
-    // Abort if signal is aborted
-    signal?.throwIfAborted();
-    // Start all tasks
-    const executingTasks = Object.fromEntries(Object.entries(tasks).map(([taskId, task]) => {
-        return [taskId, task()];
-    }));
-    let listener;
-    const signalPromise = new Promise((_resolve, reject) => {
-        listener = () => reject(new Error("Abort"));
-        signal?.addEventListener("abort", listener);
-    }).finally(() => signal?.removeEventListener("abort", listener));
-    while (Object.keys(executingTasks).length > 0) {
-        const { task, error } = await Promise.race([
-            ...Object.values(executingTasks),
-            signalPromise,
-        ]);
-        if (error !== undefined) {
-            // TODO: don't stop others if exception is interrupt
-            throw error;
-        }
-        yield task;
-        delete executingTasks[task.id];
-    }
-}
 export function shouldInterrupt(checkpoint, interruptNodes, tasks) {
     const versionValues = Object.values(checkpoint.channel_versions);
     const versionType = versionValues.length > 0 ? typeof versionValues[0] : undefined;
@@ -244,6 +205,7 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
                         },
                     }),
                     id: taskId,
+                    retry_policy: proc.retryPolicy,
                 });
             }
         }
@@ -316,6 +278,7 @@ export function _prepareNextTasks(checkpoint, processes, channels, config, forEx
                             },
                         }),
                         id: taskId,
+                        retry_policy: proc.retryPolicy,
                     });
                 }
             }

package/dist/pregel/debug.d.ts

@@ -29,7 +29,7 @@ export declare function mapDebugCheckpoint<N extends PropertyKey, C extends Prop
     timestamp: string;
     step: number;
     payload: {
-        config: Partial<Record<"tags" | "configurable" | "timeout" | "signal" | "metadata" | "callbacks" | "recursion_limit" | "max_concurrency" | "run_name" | "run_id", unknown>>;
+        config: Partial<Record<"configurable" | "timeout" | "signal" | "tags" | "metadata" | "callbacks" | "recursion_limit" | "max_concurrency" | "run_name" | "run_id", unknown>>;
         values: any;
         metadata: CheckpointMetadata;
         next: N[];

package/dist/pregel/index.cjs

@@ -16,6 +16,7 @@ const algo_js_1 = require("./algo.cjs");
 const utils_js_1 = require("../utils.cjs");
 const utils_js_2 = require("./utils.cjs");
 const loop_js_1 = require("./loop.cjs");
+const retry_js_1 = require("./retry.cjs");
 function isString(value) {
     return typeof value === "string";
 }
@@ -159,6 +160,12 @@ class Pregel extends runnables_1.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];
@@ -175,6 +182,7 @@ class Pregel extends runnables_1.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();
         }
@@ -344,12 +352,11 @@ class Pregel extends runnables_1.Runnable {
             writers.length > 1 ? runnables_1.RunnableSequence.from(writers) : writers[0],
             writes: [],
             triggers: [constants_js_1.INTERRUPT],
-            config: undefined,
             id: (0, langgraph_checkpoint_1.uuid5)(constants_js_1.INTERRUPT, checkpoint.id),
         };
         // execute task
         await task.proc.invoke(task.input, (0, runnables_1.patchConfig)(config, {
-            runName: `${this.name}UpdateState`,
+            runName: config.runName ?? `${this.getName()}UpdateState`,
             configurable: {
                 [constants_js_1.CONFIG_KEY_SEND]: (items) => task.writes.push(...items),
                 [constants_js_1.CONFIG_KEY_READ]: algo_js_1._localRead.bind(undefined, checkpoint, channels, 
@@ -490,35 +497,15 @@ class Pregel extends runnables_1.Runnable {
                 if (debug) {
                     (0, debug_js_1.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 (0, algo_js_1.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 (0, retry_js_1.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* (0, utils_js_1.prefixGenerator)((0, io_js_1.mapOutputUpdates)(outputKeys, [task]), streamMode.length > 1 ? "updates" : undefined);

package/dist/pregel/index.d.ts

@@ -6,6 +6,7 @@ import { PregelNode } from "./read.js";
 import { ChannelWrite } from "./write.js";
 import { All, PregelInterface, PregelParams, StateSnapshot, StreamMode } from "./types.js";
 import { StrRecord } from "./algo.js";
+import { RetryPolicy } from "./utils.js";
 type WriteValue = Runnable | RunnableFunc<unknown, unknown> | unknown;
 export declare class Channel {
     static subscribeTo(channels: string, options?: {
@@ -50,6 +51,7 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
     stepTimeout?: number;
     debug: boolean;
     checkpointer?: BaseCheckpointSaver;
+    retryPolicy?: RetryPolicy;
     constructor(fields: PregelParams<Nn, Cc>);
     validate(): this;
     get streamChannelsList(): Array<keyof Cc>;