@langchain/langgraph 0.1.1 → 0.1.3

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";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -14,7 +14,8 @@
   },
   "scripts": {
     "build": "yarn turbo:command build:internal --filter=@langchain/langgraph",
-    "build:internal": "yarn lc_build --create-entrypoints --pre --tree-shaking",
+    "build:internal": "yarn clean && yarn lc_build --create-entrypoints --pre --tree-shaking",
+    "clean": "rm -rf dist/ dist-cjs/ .turbo/",
     "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
@@ -31,7 +32,7 @@
   "license": "MIT",
   "dependencies": {
     "@langchain/core": ">=0.2.20 <0.3.0",
-    "@langchain/langgraph-checkpoint": "~0.0.1",
+    "@langchain/langgraph-checkpoint": "~0.0.3",
     "@langchain/langgraph-checkpoint-sqlite": "~0.0.1",
     "double-ended-queue": "^2.1.0-0",
     "uuid": "^10.0.0",
@@ -49,8 +50,9 @@
     "@jest/globals": "^29.5.0",
     "@langchain/anthropic": "^0.2.12",
     "@langchain/community": "^0.2.25",
+    "@langchain/core": "^0.2.29",
     "@langchain/openai": "^0.2.4",
-    "@langchain/scripts": ">=0.1.0 <0.2.0",
+    "@langchain/scripts": ">=0.1.2 <0.2.0",
     "@swc/core": "^1.3.90",
     "@swc/jest": "^0.2.29",
     "@tsconfig/recommended": "^1.0.3",