@langchain/langgraph 0.2.13 → 0.2.14

package/dist/errors.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = void 0;
+exports.getSubgraphsSeenSet = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = void 0;
 class GraphRecursionError extends Error {
     constructor(message) {
         super(message);
@@ -92,3 +92,27 @@ class InvalidUpdateError extends Error {
     }
 }
 exports.InvalidUpdateError = InvalidUpdateError;
+class MultipleSubgraphsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MultipleSubgraphError";
+    }
+    static get unminifiable_name() {
+        return "MultipleSubgraphError";
+    }
+}
+exports.MultipleSubgraphsError = MultipleSubgraphsError;
+/**
+ * Used for subgraph detection.
+ */
+const getSubgraphsSeenSet = () => {
+    if (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")] === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")] = new Set();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")];
+};
+exports.getSubgraphsSeenSet = getSubgraphsSeenSet;

package/dist/errors.d.ts

@@ -30,3 +30,11 @@ export declare class InvalidUpdateError extends Error {
     constructor(message?: string);
     static get unminifiable_name(): string;
 }
+export declare class MultipleSubgraphsError extends Error {
+    constructor(message?: string);
+    static get unminifiable_name(): string;
+}
+/**
+ * Used for subgraph detection.
+ */
+export declare const getSubgraphsSeenSet: () => any;

package/dist/errors.js

@@ -81,3 +81,25 @@ export class InvalidUpdateError extends Error {
         return "InvalidUpdateError";
     }
 }
+export class MultipleSubgraphsError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "MultipleSubgraphError";
+    }
+    static get unminifiable_name() {
+        return "MultipleSubgraphError";
+    }
+}
+/**
+ * Used for subgraph detection.
+ */
+export const getSubgraphsSeenSet = () => {
+    if (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")] === undefined) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")] = new Set();
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    return globalThis[Symbol.for("LG_CHECKPOINT_SEEN_NS_SET")];
+};

package/dist/graph/graph.cjs

@@ -93,6 +93,7 @@ class Graph {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "branches", {
             enumerable: true,
             configurable: true,

package/dist/graph/graph.d.ts

@@ -7,21 +7,23 @@ import type { PregelParams } from "../pregel/types.js";
 import { BaseChannel } from "../channels/base.js";
 import { Send } from "../constants.js";
 import { RunnableCallable } from "../utils.js";
+import { StateDefinition, StateType } from "./annotation.js";
+import type { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
 /** Special reserved node name denoting the start of a graph. */
 export declare const START = "__start__";
 /** Special reserved node name denoting the end of a graph. */
 export declare const END = "__end__";
-export interface BranchOptions<IO, N extends string> {
+export interface BranchOptions<IO, N extends string, CallOptions extends LangGraphRunnableConfig = LangGraphRunnableConfig> {
     source: N;
-    path: Branch<IO, N>["condition"];
+    path: Branch<IO, N, CallOptions>["condition"];
     pathMap?: Record<string, N | typeof END> | (N | typeof END)[];
 }
-export declare class Branch<IO, N extends string> {
-    condition: (input: IO, config?: RunnableConfig) => string | Send | (string | Send)[] | Promise<string | Send | (string | Send)[]>;
+export declare class Branch<IO, N extends string, CallOptions extends LangGraphRunnableConfig = LangGraphRunnableConfig> {
+    condition: (input: IO, config: CallOptions) => string | Send | (string | Send)[] | Promise<string | Send | (string | Send)[]>;
     ends?: Record<string, N | typeof END>;
-    constructor(options: Omit<BranchOptions<IO, N>, "source">);
-    compile(writer: (dests: (string | Send)[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): RunnableCallable<unknown, unknown>;
-    _route(input: IO, config: RunnableConfig, writer: (dests: (string | Send)[]) => Runnable | undefined, reader?: (config: RunnableConfig) => IO): Promise<Runnable | undefined>;
+    constructor(options: Omit<BranchOptions<IO, N, CallOptions>, "source">);
+    compile(writer: (dests: (string | Send)[]) => Runnable | undefined, reader?: (config: CallOptions) => IO): RunnableCallable<unknown, unknown>;
+    _route(input: IO, config: CallOptions, writer: (dests: (string | Send)[]) => Runnable | undefined, reader?: (config: CallOptions) => IO): Promise<Runnable | undefined>;
 }
 export type NodeSpec<RunInput, RunOutput> = {
     runnable: Runnable<RunInput, RunOutput>;
@@ -30,19 +32,19 @@ export type NodeSpec<RunInput, RunOutput> = {
 export type AddNodeOptions = {
     metadata?: Record<string, unknown>;
 };
-export declare class Graph<N extends string = typeof END, RunInput = any, RunOutput = any, NodeSpecType extends NodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput>> {
+export declare class Graph<N extends string = typeof END, RunInput = any, RunOutput = any, NodeSpecType extends NodeSpec<RunInput, RunOutput> = NodeSpec<RunInput, RunOutput>, C extends StateDefinition = StateDefinition> {
     nodes: Record<N, NodeSpecType>;
     edges: Set<[N | typeof START, N | typeof END]>;
-    branches: Record<string, Record<string, Branch<RunInput, N>>>;
+    branches: Record<string, Record<string, Branch<RunInput, N, any>>>;
     entryPoint?: string;
     compiled: boolean;
     constructor();
     protected warnIfCompiled(message: string): void;
     get allEdges(): Set<[string, string]>;
-    addNode<K extends string, NodeInput = RunInput>(key: K, action: RunnableLike<NodeInput, RunOutput>, options?: AddNodeOptions): Graph<N | K, RunInput, RunOutput>;
+    addNode<K extends string, NodeInput = RunInput>(key: K, action: RunnableLike<NodeInput, RunOutput extends object ? RunOutput & Record<string, any> : RunOutput, LangGraphRunnableConfig<StateType<C>>>, options?: AddNodeOptions): Graph<N | K, RunInput, RunOutput>;
     addEdge(startKey: N | typeof START, endKey: N | typeof END): this;
-    addConditionalEdges(source: BranchOptions<RunInput, N>): this;
-    addConditionalEdges(source: N, path: Branch<RunInput, N>["condition"], pathMap?: BranchOptions<RunInput, N>["pathMap"]): this;
+    addConditionalEdges(source: BranchOptions<RunInput, N, LangGraphRunnableConfig<StateType<C>>>): this;
+    addConditionalEdges(source: N, path: Branch<RunInput, N, LangGraphRunnableConfig<StateType<C>>>["condition"], pathMap?: BranchOptions<RunInput, N, LangGraphRunnableConfig<StateType<C>>>["pathMap"]): this;
     /**
      * @deprecated use `addEdge(START, key)` instead
      */
@@ -52,7 +54,7 @@ export declare class Graph<N extends string = typeof END, RunInput = any, RunOut
      */
     setFinishPoint(key: N): this;
     compile({ checkpointer, interruptBefore, interruptAfter, }?: {
-        checkpointer?: BaseCheckpointSaver;
+        checkpointer?: BaseCheckpointSaver | false;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;
     }): CompiledGraph<N>;

package/dist/graph/graph.js

@@ -89,6 +89,7 @@ export class Graph {
             writable: true,
             value: void 0
         });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         Object.defineProperty(this, "branches", {
             enumerable: true,
             configurable: true,

package/dist/graph/state.d.ts

@@ -5,6 +5,7 @@ import { END, CompiledGraph, Graph, START, Branch, AddNodeOptions, NodeSpec } fr
 import { AnnotationRoot, SingleReducer, StateDefinition, StateType, UpdateType } from "./annotation.js";
 import type { RetryPolicy } from "../pregel/utils/index.js";
 import { ManagedValueSpec } from "../managed/base.js";
+import type { LangGraphRunnableConfig } from "../pregel/runnable_types.js";
 export type ChannelReducers<Channels extends object> = {
     [K in keyof Channels]: SingleReducer<Channels[K], any>;
 };
@@ -94,7 +95,7 @@ export type StateGraphArgsWithInputOutputSchemas<SD extends StateDefinition, O e
  * // }
  * ```
  */
-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, I extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, O extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, C extends StateDefinition = StateDefinition> extends Graph<N, S, U, StateGraphNodeSpec<S, U>> {
+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, I extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, O extends StateDefinition = SD extends StateDefinition ? SD : StateDefinition, C extends StateDefinition = StateDefinition> extends Graph<N, S, U, StateGraphNodeSpec<S, U>, C> {
     channels: Record<string, BaseChannel | ManagedValueSpec>;
     waitingEdges: Set<[N[], N]>;
     /** @internal */
@@ -113,10 +114,10 @@ export declare class StateGraph<SD extends StateDefinition | unknown, S = SD ext
     constructor(fields: SD extends StateDefinition ? SD | AnnotationRoot<SD> | StateGraphArgs<S> | StateGraphArgsWithStateSchema<SD, I, O> | StateGraphArgsWithInputOutputSchemas<SD, O> : StateGraphArgs<S>, configSchema?: AnnotationRoot<C>);
     get allEdges(): Set<[string, string]>;
     _addSchema(stateDefinition: StateDefinition): void;
-    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U extends object ? U & Record<string, any> : U>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C>;
+    addNode<K extends string, NodeInput = S>(key: K, action: RunnableLike<NodeInput, U extends object ? U & Record<string, any> : U, LangGraphRunnableConfig<StateType<C>>>, options?: StateGraphAddNodeOptions): StateGraph<SD, S, U, N | K, I, O, C>;
     addEdge(startKey: typeof START | N | N[], endKey: N | typeof END): this;
     compile({ checkpointer, store, interruptBefore, interruptAfter, }?: {
-        checkpointer?: BaseCheckpointSaver;
+        checkpointer?: BaseCheckpointSaver | false;
         store?: BaseStore;
         interruptBefore?: N[] | All;
         interruptAfter?: N[] | All;

package/dist/pregel/index.cjs

@@ -609,7 +609,10 @@ class Pregel extends runnables_1.Runnable {
             defaultStreamMode = ["values"];
         }
         let defaultCheckpointer;
-        if (config !== undefined &&
+        if (this.checkpointer === false) {
+            defaultCheckpointer = undefined;
+        }
+        else if (config !== undefined &&
             config.configurable?.[constants_js_1.CONFIG_KEY_CHECKPOINTER] !== undefined) {
             defaultCheckpointer = config.configurable[constants_js_1.CONFIG_KEY_CHECKPOINTER];
         }
@@ -699,6 +702,7 @@ class Pregel extends runnables_1.Runnable {
             throw new Error(`Passed "recursionLimit" must be at least 1.`);
         }
         if (this.checkpointer !== undefined &&
+            this.checkpointer !== false &&
             inputConfig.configurable === undefined) {
             throw new Error(`Checkpointer requires one or more of the following "configurable" keys: "thread_id", "checkpoint_ns", "checkpoint_id"`);
         }

package/dist/pregel/index.d.ts

@@ -56,7 +56,7 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
     interruptBefore?: Array<keyof Nn> | All;
     stepTimeout?: number;
     debug: boolean;
-    checkpointer?: BaseCheckpointSaver;
+    checkpointer?: BaseCheckpointSaver | false;
     retryPolicy?: RetryPolicy;
     config?: LangGraphRunnableConfig;
     store?: BaseStore;

package/dist/pregel/index.js

@@ -602,7 +602,10 @@ export class Pregel extends Runnable {
             defaultStreamMode = ["values"];
         }
         let defaultCheckpointer;
-        if (config !== undefined &&
+        if (this.checkpointer === false) {
+            defaultCheckpointer = undefined;
+        }
+        else if (config !== undefined &&
             config.configurable?.[CONFIG_KEY_CHECKPOINTER] !== undefined) {
             defaultCheckpointer = config.configurable[CONFIG_KEY_CHECKPOINTER];
         }
@@ -692,6 +695,7 @@ export class Pregel extends Runnable {
             throw new Error(`Passed "recursionLimit" must be at least 1.`);
         }
         if (this.checkpointer !== undefined &&
+            this.checkpointer !== false &&
             inputConfig.configurable === undefined) {
             throw new Error(`Checkpointer requires one or more of the following "configurable" keys: "thread_id", "checkpoint_ns", "checkpoint_id"`);
         }

package/dist/pregel/io.cjs

@@ -64,7 +64,7 @@ chunk
             }
         }
         else if (Array.isArray(inputChannels)) {
-            throw new Error("Input chunk must be an object when inputChannels is an array");
+            throw new Error(`Input chunk must be an object when "inputChannels" is an array`);
         }
         else {
             yield [inputChannels, chunk];

package/dist/pregel/io.js

@@ -59,7 +59,7 @@ chunk
             }
         }
         else if (Array.isArray(inputChannels)) {
-            throw new Error("Input chunk must be an object when inputChannels is an array");
+            throw new Error(`Input chunk must be an object when "inputChannels" is an array`);
         }
         else {
             yield [inputChannels, chunk];

package/dist/pregel/loop.cjs

@@ -241,6 +241,7 @@ class PregelLoop {
     }
     static async initialize(params) {
         let { config, stream } = params;
+        const { checkSubgraphs = true } = params;
         if (stream !== undefined &&
             config.configurable?.[constants_js_1.CONFIG_KEY_STREAM] !== undefined) {
             stream = createDuplexStream(stream, config.configurable[constants_js_1.CONFIG_KEY_STREAM]);
@@ -297,6 +298,19 @@ class PregelLoop {
             // Start the store. This is a batch store, so it will run continuously
             store.start();
         }
+        if (checkSubgraphs && isNested && params.checkpointer !== undefined) {
+            if ((0, errors_js_1.getSubgraphsSeenSet)().has(config.configurable?.checkpoint_ns)) {
+                throw new errors_js_1.MultipleSubgraphsError([
+                    "Detected the same subgraph called multiple times by the same node.",
+                    "This is not allowed if checkpointing is enabled.",
+                    "",
+                    `You can disable checkpointing for a subgraph by compiling it with ".compile({ checkpointer: false });"`,
+                ].join("\n"));
+            }
+            else {
+                (0, errors_js_1.getSubgraphsSeenSet)().add(config.configurable?.checkpoint_ns);
+            }
+        }
         return new PregelLoop({
             input: params.input,
             config,

package/dist/pregel/loop.d.ts

@@ -18,6 +18,7 @@ export type PregelLoopInitializeParams = {
     managed: ManagedValueMapping;
     stream: StreamProtocol;
     store?: BaseStore;
+    checkSubgraphs?: boolean;
 };
 type PregelLoopParams = {
     input?: any;

package/dist/pregel/loop.js

@@ -4,7 +4,7 @@ import { CHECKPOINT_NAMESPACE_SEPARATOR, CONFIG_KEY_CHECKPOINT_MAP, CONFIG_KEY_R
 import { _applyWrites, _prepareNextTasks, increment, shouldInterrupt, } from "./algo.js";
 import { gatherIterator, gatherIteratorSync, prefixGenerator, } from "../utils.js";
 import { mapInput, mapOutputUpdates, mapOutputValues, readChannels, } from "./io.js";
-import { EmptyInputError, GraphInterrupt, isGraphInterrupt, } from "../errors.js";
+import { getSubgraphsSeenSet, EmptyInputError, GraphInterrupt, isGraphInterrupt, MultipleSubgraphsError, } from "../errors.js";
 import { getNewChannelVersions, patchConfigurable } from "./utils/index.js";
 import { mapDebugTasks, mapDebugCheckpoint, mapDebugTaskResults, } from "./debug.js";
 const INPUT_DONE = Symbol.for("INPUT_DONE");
@@ -237,6 +237,7 @@ export class PregelLoop {
     }
     static async initialize(params) {
         let { config, stream } = params;
+        const { checkSubgraphs = true } = params;
         if (stream !== undefined &&
             config.configurable?.[CONFIG_KEY_STREAM] !== undefined) {
             stream = createDuplexStream(stream, config.configurable[CONFIG_KEY_STREAM]);
@@ -293,6 +294,19 @@ export class PregelLoop {
             // Start the store. This is a batch store, so it will run continuously
             store.start();
         }
+        if (checkSubgraphs && isNested && params.checkpointer !== undefined) {
+            if (getSubgraphsSeenSet().has(config.configurable?.checkpoint_ns)) {
+                throw new MultipleSubgraphsError([
+                    "Detected the same subgraph called multiple times by the same node.",
+                    "This is not allowed if checkpointing is enabled.",
+                    "",
+                    `You can disable checkpointing for a subgraph by compiling it with ".compile({ checkpointer: false });"`,
+                ].join("\n"));
+            }
+            else {
+                getSubgraphsSeenSet().add(config.configurable?.checkpoint_ns);
+            }
+        }
         return new PregelLoop({
             input: params.input,
             config,

package/dist/pregel/retry.cjs

@@ -131,6 +131,17 @@ pregelTask, retryPolicy) {
                 error.constructor.unminifiable_name ??
                 error.constructor.name;
             console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)} seconds (attempt ${attempts}) after ${errorName}: ${error}`);
+            // Clear checkpoint_ns seen (for subgraph detection)
+            const checkpointNs = pregelTask.config?.configurable?.checkpoint_ns;
+            if (checkpointNs) {
+                (0, errors_js_1.getSubgraphsSeenSet)().delete(checkpointNs);
+            }
+        }
+        finally {
+            const checkpointNs = pregelTask.config?.configurable?.checkpoint_ns;
+            if (checkpointNs) {
+                (0, errors_js_1.getSubgraphsSeenSet)().delete(checkpointNs);
+            }
         }
     }
     return {

package/dist/pregel/retry.js

@@ -1,4 +1,4 @@
-import { isGraphInterrupt } from "../errors.js";
+import { getSubgraphsSeenSet, isGraphInterrupt } from "../errors.js";
 export const DEFAULT_INITIAL_INTERVAL = 500;
 export const DEFAULT_BACKOFF_FACTOR = 2;
 export const DEFAULT_MAX_INTERVAL = 128000;
@@ -127,6 +127,17 @@ pregelTask, retryPolicy) {
                 error.constructor.unminifiable_name ??
                 error.constructor.name;
             console.log(`Retrying task "${pregelTask.name}" after ${interval.toFixed(2)} seconds (attempt ${attempts}) after ${errorName}: ${error}`);
+            // Clear checkpoint_ns seen (for subgraph detection)
+            const checkpointNs = pregelTask.config?.configurable?.checkpoint_ns;
+            if (checkpointNs) {
+                getSubgraphsSeenSet().delete(checkpointNs);
+            }
+        }
+        finally {
+            const checkpointNs = pregelTask.config?.configurable?.checkpoint_ns;
+            if (checkpointNs) {
+                getSubgraphsSeenSet().delete(checkpointNs);
+            }
         }
     }
     return {

package/dist/pregel/runnable_types.d.ts

@@ -1,5 +1,5 @@
 import { RunnableConfig } from "@langchain/core/runnables";
 import { BaseStore } from "@langchain/langgraph-checkpoint";
-export interface LangGraphRunnableConfig extends RunnableConfig {
+export interface LangGraphRunnableConfig<ConfigurableType extends Record<string, any> = Record<string, any>> extends RunnableConfig<ConfigurableType> {
     store?: BaseStore;
 }

package/dist/pregel/types.d.ts

@@ -44,7 +44,7 @@ export interface PregelInterface<Nn extends StrRecord<string, PregelNode>, Cc ex
      * @default false
      */
     debug?: boolean;
-    checkpointer?: BaseCheckpointSaver;
+    checkpointer?: BaseCheckpointSaver | false;
     retryPolicy?: RetryPolicy;
     config?: LangGraphRunnableConfig;
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "LangGraph",
   "type": "module",
   "engines": {
@@ -31,13 +31,13 @@
   "author": "LangChain",
   "license": "MIT",
   "dependencies": {
-    "@langchain/langgraph-checkpoint": "~0.0.9",
+    "@langchain/langgraph-checkpoint": "~0.0.10",
     "double-ended-queue": "^2.1.0-0",
     "uuid": "^10.0.0",
     "zod": "^3.23.8"
   },
   "peerDependencies": {
-    "@langchain/core": ">=0.2.35 <0.3.0 || >=0.3.8 < 0.4.0"
+    "@langchain/core": ">=0.2.36 <0.3.0 || >=0.3.9 < 0.4.0"
   },
   "devDependencies": {
     "@jest/globals": "^29.5.0",