@langchain/langgraph 0.2.8 → 0.2.9

package/dist/pregel/read.d.ts

@@ -1,6 +1,6 @@
 import { Runnable, RunnableBinding, RunnableBindingArgs, RunnableConfig, RunnableLike } from "@langchain/core/runnables";
 import { RunnableCallable } from "../utils.js";
-import type { RetryPolicy } from "./utils.js";
+import type { RetryPolicy } from "./utils/index.js";
 export declare class ChannelRead<RunInput = any> extends RunnableCallable {
     lc_graph_name: string;
     channel: string | Array<string>;
@@ -32,6 +32,7 @@ export declare class PregelNode<RunInput = PregelNodeInputType, RunOutput = Preg
     bound: Runnable<RunInput, RunOutput>;
     kwargs: Record<string, any>;
     metadata: Record<string, unknown>;
+    tags: string[];
     retryPolicy?: RetryPolicy;
     constructor(fields: PregelNodeArgs<RunInput, RunOutput>);
     getWriters(): Array<Runnable>;

package/dist/pregel/read.js

@@ -59,10 +59,10 @@ const defaultRunnableBound =
 /* #__PURE__ */ new RunnablePassthrough();
 export class PregelNode extends RunnableBinding {
     constructor(fields) {
-        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, } = fields;
+        const { channels, triggers, mapper, writers, bound, kwargs, metadata, retryPolicy, tags, } = fields;
         const mergedTags = [
             ...(fields.config?.tags ? fields.config.tags : []),
-            ...(fields.tags ? fields.tags : []),
+            ...(tags ?? []),
         ];
         super({
             ...fields,
@@ -123,6 +123,12 @@ export class PregelNode extends RunnableBinding {
             writable: true,
             value: {}
         });
+        Object.defineProperty(this, "tags", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: []
+        });
         Object.defineProperty(this, "retryPolicy", {
             enumerable: true,
             configurable: true,
@@ -136,6 +142,7 @@ export class PregelNode extends RunnableBinding {
         this.bound = bound ?? this.bound;
         this.kwargs = kwargs ?? this.kwargs;
         this.metadata = metadata ?? this.metadata;
+        this.tags = mergedTags;
         this.retryPolicy = retryPolicy;
     }
     getWriters() {

package/dist/pregel/retry.d.ts

@@ -1,5 +1,5 @@
 import { PregelExecutableTask } from "./types.js";
-import type { RetryPolicy } from "./utils.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;

package/dist/pregel/types.d.ts

@@ -2,7 +2,7 @@ import type { Runnable, RunnableConfig } from "@langchain/core/runnables";
 import type { All, 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";
+import { RetryPolicy } from "./utils/index.js";
 import { Interrupt } from "../constants.js";
 import { BaseStore } from "../store/base.js";
 import { type ManagedValueSpec } from "../managed/base.js";
@@ -46,6 +46,7 @@ export interface PregelInterface<Nn extends StrRecord<string, PregelNode>, Cc ex
     debug?: boolean;
     checkpointer?: BaseCheckpointSaver;
     retryPolicy?: RetryPolicy;
+    config?: RunnableConfig;
     /**
      * Memory store to use for SharedValues.
      */
@@ -57,6 +58,8 @@ export interface PregelTaskDescription {
     readonly name: string;
     readonly error?: unknown;
     readonly interrupts: Interrupt[];
+    readonly state?: RunnableConfig | StateSnapshot;
+    readonly path?: [string, ...(string | number)[]];
 }
 export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyKey> {
     readonly name: N;
@@ -67,6 +70,7 @@ export interface PregelExecutableTask<N extends PropertyKey, C extends PropertyK
     readonly triggers: Array<string>;
     readonly retry_policy?: RetryPolicy;
     readonly id: string;
+    readonly path?: [string, ...(string | number)[]];
 }
 export interface StateSnapshot {
     /**

package/dist/pregel/utils/config.cjs

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ensureLangGraphConfig = void 0;
+const singletons_1 = require("@langchain/core/singletons");
+const COPIABLE_KEYS = ["tags", "metadata", "callbacks", "configurable"];
+const CONFIG_KEYS = [
+    "tags",
+    "metadata",
+    "callbacks",
+    "runName",
+    "maxConcurrency",
+    "recursionLimit",
+    "configurable",
+    "runId",
+    "outputKeys",
+    "streamMode",
+];
+const DEFAULT_RECURSION_LIMIT = 25;
+function ensureLangGraphConfig(...configs) {
+    const empty = {
+        tags: [],
+        metadata: {},
+        callbacks: undefined,
+        recursionLimit: DEFAULT_RECURSION_LIMIT,
+        configurable: {},
+    };
+    const implicitConfig = singletons_1.AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    if (implicitConfig !== undefined) {
+        for (const [k, v] of Object.entries(implicitConfig)) {
+            if (v !== undefined) {
+                if (COPIABLE_KEYS.includes(k)) {
+                    let copiedValue;
+                    if (Array.isArray(v)) {
+                        copiedValue = [...v];
+                    }
+                    else if (typeof v === "object") {
+                        copiedValue = { ...v };
+                    }
+                    else {
+                        copiedValue = v;
+                    }
+                    empty[k] = copiedValue;
+                }
+                else {
+                    empty[k] = v;
+                }
+            }
+        }
+    }
+    for (const config of configs) {
+        if (config === undefined) {
+            continue;
+        }
+        for (const [k, v] of Object.entries(config)) {
+            if (v !== undefined && CONFIG_KEYS.includes(k)) {
+                empty[k] = v;
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(empty.configurable)) {
+        empty.metadata = empty.metadata ?? {};
+        if (!key.startsWith("__") &&
+            (typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean") &&
+            !(key in empty.metadata)) {
+            empty.metadata[key] = value;
+        }
+    }
+    return empty;
+}
+exports.ensureLangGraphConfig = ensureLangGraphConfig;

package/dist/pregel/utils/config.d.ts

@@ -0,0 +1,2 @@
+import { RunnableConfig } from "@langchain/core/runnables";
+export declare function ensureLangGraphConfig(...configs: (RunnableConfig | undefined)[]): RunnableConfig;

package/dist/pregel/utils/config.js

@@ -0,0 +1,68 @@
+import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+const COPIABLE_KEYS = ["tags", "metadata", "callbacks", "configurable"];
+const CONFIG_KEYS = [
+    "tags",
+    "metadata",
+    "callbacks",
+    "runName",
+    "maxConcurrency",
+    "recursionLimit",
+    "configurable",
+    "runId",
+    "outputKeys",
+    "streamMode",
+];
+const DEFAULT_RECURSION_LIMIT = 25;
+export function ensureLangGraphConfig(...configs) {
+    const empty = {
+        tags: [],
+        metadata: {},
+        callbacks: undefined,
+        recursionLimit: DEFAULT_RECURSION_LIMIT,
+        configurable: {},
+    };
+    const implicitConfig = AsyncLocalStorageProviderSingleton.getRunnableConfig();
+    if (implicitConfig !== undefined) {
+        for (const [k, v] of Object.entries(implicitConfig)) {
+            if (v !== undefined) {
+                if (COPIABLE_KEYS.includes(k)) {
+                    let copiedValue;
+                    if (Array.isArray(v)) {
+                        copiedValue = [...v];
+                    }
+                    else if (typeof v === "object") {
+                        copiedValue = { ...v };
+                    }
+                    else {
+                        copiedValue = v;
+                    }
+                    empty[k] = copiedValue;
+                }
+                else {
+                    empty[k] = v;
+                }
+            }
+        }
+    }
+    for (const config of configs) {
+        if (config === undefined) {
+            continue;
+        }
+        for (const [k, v] of Object.entries(config)) {
+            if (v !== undefined && CONFIG_KEYS.includes(k)) {
+                empty[k] = v;
+            }
+        }
+    }
+    for (const [key, value] of Object.entries(empty.configurable)) {
+        empty.metadata = empty.metadata ?? {};
+        if (!key.startsWith("__") &&
+            (typeof value === "string" ||
+                typeof value === "number" ||
+                typeof value === "boolean") &&
+            !(key in empty.metadata)) {
+            empty.metadata[key] = value;
+        }
+    }
+    return empty;
+}

package/dist/pregel/{utils.cjs → utils/index.cjs}

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports._getIdMetadata = exports._coerceToDict = exports.getNewChannelVersions = exports.getNullChannelVersion = void 0;
+exports.patchCheckpointMap = exports.patchConfigurable = exports._coerceToDict = exports.getNewChannelVersions = exports.getNullChannelVersion = void 0;
+const constants_js_1 = require("../../constants.cjs");
 function getNullChannelVersion(currentVersions) {
     const versionValues = Object.values(currentVersions);
     const versionType = versionValues.length > 0 ? typeof versionValues[0] : undefined;
@@ -36,13 +37,35 @@ function _coerceToDict(value, defaultKey) {
         : { [defaultKey]: value };
 }
 exports._coerceToDict = _coerceToDict;
-// Order matters
-function _getIdMetadata(metadata) {
-    return {
-        langgraph_step: metadata.langgraph_step,
-        langgraph_node: metadata.langgraph_node,
-        langgraph_triggers: metadata.langgraph_triggers,
-        langgraph_task_idx: metadata.langgraph_task_idx,
-    };
+function patchConfigurable(config, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+patch) {
+    if (config === null) {
+        return { configurable: patch };
+    }
+    else if (config?.configurable === undefined) {
+        return { ...config, configurable: patch };
+    }
+    else {
+        return {
+            ...config,
+            configurable: { ...config.configurable, ...patch },
+        };
+    }
+}
+exports.patchConfigurable = patchConfigurable;
+function patchCheckpointMap(config, metadata) {
+    const parents = metadata?.parents ?? {};
+    if (Object.keys(parents).length > 0) {
+        return patchConfigurable(config, {
+            [constants_js_1.CONFIG_KEY_CHECKPOINT_MAP]: {
+                ...parents,
+                [config.configurable?.checkpoint_ns ?? ""]: config.configurable?.checkpoint_id,
+            },
+        });
+    }
+    else {
+        return config;
+    }
 }
-exports._getIdMetadata = _getIdMetadata;
+exports.patchCheckpointMap = patchCheckpointMap;

package/dist/pregel/{utils.d.ts → utils/index.d.ts}

@@ -1,13 +1,8 @@
-import type { ChannelVersions } from "@langchain/langgraph-checkpoint";
+import { RunnableConfig } from "@langchain/core/runnables";
+import type { ChannelVersions, CheckpointMetadata } from "@langchain/langgraph-checkpoint";
 export declare function getNullChannelVersion(currentVersions: ChannelVersions): string | number | undefined;
 export declare function getNewChannelVersions(previousVersions: ChannelVersions, currentVersions: ChannelVersions): ChannelVersions;
 export declare function _coerceToDict(value: any, defaultKey: string): any;
-export declare function _getIdMetadata(metadata: Record<string, unknown>): {
-    langgraph_step: unknown;
-    langgraph_node: unknown;
-    langgraph_triggers: unknown;
-    langgraph_task_idx: unknown;
-};
 export type RetryPolicy = {
     /**
      * Amount of time that must elapse before the first retry occurs in milliseconds.
@@ -34,3 +29,5 @@ export type RetryPolicy = {
     /** A function that returns True for exceptions that should trigger a retry. */
     retryOn?: (e: any) => boolean;
 };
+export declare function patchConfigurable(config: RunnableConfig | undefined, patch: Record<string, any>): RunnableConfig;
+export declare function patchCheckpointMap(config: RunnableConfig, metadata?: CheckpointMetadata): RunnableConfig;

package/dist/pregel/{utils.js → utils/index.js}

@@ -1,3 +1,4 @@
+import { CONFIG_KEY_CHECKPOINT_MAP } from "../../constants.js";
 export function getNullChannelVersion(currentVersions) {
     const versionValues = Object.values(currentVersions);
     const versionType = versionValues.length > 0 ? typeof versionValues[0] : undefined;
@@ -30,12 +31,33 @@ export function _coerceToDict(value, defaultKey) {
         ? value
         : { [defaultKey]: value };
 }
-// Order matters
-export function _getIdMetadata(metadata) {
-    return {
-        langgraph_step: metadata.langgraph_step,
-        langgraph_node: metadata.langgraph_node,
-        langgraph_triggers: metadata.langgraph_triggers,
-        langgraph_task_idx: metadata.langgraph_task_idx,
-    };
+export function patchConfigurable(config, 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+patch) {
+    if (config === null) {
+        return { configurable: patch };
+    }
+    else if (config?.configurable === undefined) {
+        return { ...config, configurable: patch };
+    }
+    else {
+        return {
+            ...config,
+            configurable: { ...config.configurable, ...patch },
+        };
+    }
+}
+export function patchCheckpointMap(config, metadata) {
+    const parents = metadata?.parents ?? {};
+    if (Object.keys(parents).length > 0) {
+        return patchConfigurable(config, {
+            [CONFIG_KEY_CHECKPOINT_MAP]: {
+                ...parents,
+                [config.configurable?.checkpoint_ns ?? ""]: config.configurable?.checkpoint_id,
+            },
+        });
+    }
+    else {
+        return config;
+    }
 }

package/dist/utils.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.patchConfigurable = exports.gatherIteratorSync = exports.gatherIterator = exports.prefixGenerator = exports.RunnableCallable = void 0;
 const runnables_1 = require("@langchain/core/runnables");
 const singletons_1 = require("@langchain/core/singletons");
+const config_js_1 = require("./pregel/utils/config.cjs");
 class RunnableCallable extends runnables_1.Runnable {
     constructor(fields) {
         super();
@@ -72,14 +73,15 @@ class RunnableCallable extends runnables_1.Runnable {
     ) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
+        const config = (0, config_js_1.ensureLangGraphConfig)(options);
         if (this.trace) {
-            returnValue = await this._callWithConfig(this._tracedInvoke, input, (0, runnables_1.mergeConfigs)(this.config, options));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, (0, runnables_1.mergeConfigs)(this.config, config));
         }
         else {
-            returnValue = await this.func(input, (0, runnables_1.mergeConfigs)(this.config, options));
+            returnValue = await this.func(input, (0, runnables_1.mergeConfigs)(this.config, config));
         }
         if (runnables_1.Runnable.isRunnable(returnValue) && this.recurse) {
-            return await returnValue.invoke(input, options);
+            return await returnValue.invoke(input, config);
         }
         return returnValue;
     }

package/dist/utils.js

@@ -1,5 +1,6 @@
 import { mergeConfigs, patchConfig, Runnable, } from "@langchain/core/runnables";
 import { AsyncLocalStorageProviderSingleton } from "@langchain/core/singletons";
+import { ensureLangGraphConfig } from "./pregel/utils/config.js";
 export class RunnableCallable extends Runnable {
     constructor(fields) {
         super();
@@ -69,14 +70,15 @@ export class RunnableCallable extends Runnable {
     ) {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let returnValue;
+        const config = ensureLangGraphConfig(options);
         if (this.trace) {
-            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergeConfigs(this.config, options));
+            returnValue = await this._callWithConfig(this._tracedInvoke, input, mergeConfigs(this.config, config));
         }
         else {
-            returnValue = await this.func(input, mergeConfigs(this.config, options));
+            returnValue = await this.func(input, mergeConfigs(this.config, config));
         }
         if (Runnable.isRunnable(returnValue) && this.recurse) {
-            return await returnValue.invoke(input, options);
+            return await returnValue.invoke(input, config);
         }
         return returnValue;
     }

package/dist/web.d.ts

@@ -1,8 +1,9 @@
 export { END, Graph, type StateGraphArgs, START, StateGraph, type CompiledStateGraph, MessageGraph, messagesStateReducer, type Messages, Annotation, type StateType, type UpdateType, type NodeType, type StateDefinition, type SingleReducer, type CompiledGraph, } from "./graph/index.js";
+export type { StateSnapshot } from "./pregel/types.js";
 export * from "./errors.js";
 export { BaseChannel, type BinaryOperator, BinaryOperatorAggregate, type AnyValue, type WaitForNames, type DynamicBarrierValue, type LastValue, type NamedBarrierValue, type Topic, } from "./channels/index.js";
 export { type AnnotationRoot as _INTERNAL_ANNOTATION_ROOT } from "./graph/index.js";
-export { type RetryPolicy } from "./pregel/utils.js";
+export { type RetryPolicy } from "./pregel/utils/index.js";
 export { Send } from "./constants.js";
 export { MemorySaver, type Checkpoint, type CheckpointMetadata, type CheckpointTuple, copyCheckpoint, emptyCheckpoint, BaseCheckpointSaver, } from "@langchain/langgraph-checkpoint";
 export * from "./store/index.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/langgraph",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "description": "LangGraph",
   "type": "module",
   "engines": {