@langchain/langgraph 0.2.18-rc.0 → 0.2.19

package/dist/errors.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getSubgraphsSeenSet = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = exports.BaseLangGraphError = void 0;
+exports.getSubgraphsSeenSet = exports.RemoteException = exports.MultipleSubgraphsError = exports.InvalidUpdateError = exports.EmptyChannelError = exports.EmptyInputError = exports.isGraphInterrupt = exports.NodeInterrupt = exports.GraphInterrupt = exports.GraphValueError = exports.GraphRecursionError = exports.BaseLangGraphError = void 0;
 // TODO: Merge with base LangChain error class when we drop support for core@0.2.0
 class BaseLangGraphError extends Error {
     constructor(message, fields) {
@@ -120,6 +120,19 @@ class MultipleSubgraphsError extends BaseLangGraphError {
     }
 }
 exports.MultipleSubgraphsError = MultipleSubgraphsError;
+/**
+ * Exception raised when an error occurs in the remote graph.
+ */
+class RemoteException extends BaseLangGraphError {
+    constructor(message, fields) {
+        super(message, fields);
+        this.name = "RemoteException";
+    }
+    static get unminifiable_name() {
+        return "RemoteException";
+    }
+}
+exports.RemoteException = RemoteException;
 /**
  * Used for subgraph detection.
  */

package/dist/errors.d.ts

@@ -41,6 +41,13 @@ export declare class MultipleSubgraphsError extends BaseLangGraphError {
     constructor(message?: string, fields?: BaseLangGraphErrorFields);
     static get unminifiable_name(): string;
 }
+/**
+ * Exception raised when an error occurs in the remote graph.
+ */
+export declare class RemoteException extends BaseLangGraphError {
+    constructor(message?: string, fields?: BaseLangGraphErrorFields);
+    static get unminifiable_name(): string;
+}
 /**
  * Used for subgraph detection.
  */

package/dist/errors.js

@@ -107,6 +107,18 @@ export class MultipleSubgraphsError extends BaseLangGraphError {
         return "MultipleSubgraphError";
     }
 }
+/**
+ * Exception raised when an error occurs in the remote graph.
+ */
+export class RemoteException extends BaseLangGraphError {
+    constructor(message, fields) {
+        super(message, fields);
+        this.name = "RemoteException";
+    }
+    static get unminifiable_name() {
+        return "RemoteException";
+    }
+}
 /**
  * Used for subgraph detection.
  */

package/dist/graph/graph.cjs

@@ -357,6 +357,156 @@ class CompiledGraph extends index_js_1.Pregel {
     /**
      * Returns a drawable representation of the computation graph.
      */
+    async getGraphAsync(config) {
+        const xray = config?.xray;
+        const graph = new graph_1.Graph();
+        const startNodes = {
+            [exports.START]: graph.addNode({
+                schema: zod_1.z.any(),
+            }, exports.START),
+        };
+        const endNodes = {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let subgraphs = {};
+        if (xray) {
+            subgraphs = Object.fromEntries((await (0, utils_js_1.gatherIterator)(this.getSubgraphsAsync())).filter(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (x) => isCompiledGraph(x[1])));
+        }
+        function addEdge(start, end, label, conditional = false) {
+            if (end === exports.END && endNodes[exports.END] === undefined) {
+                endNodes[exports.END] = graph.addNode({ schema: zod_1.z.any() }, exports.END);
+            }
+            return graph.addEdge(startNodes[start], endNodes[end], label !== end ? label : undefined, conditional);
+        }
+        for (const [key, nodeSpec] of Object.entries(this.builder.nodes)) {
+            const displayKey = _escapeMermaidKeywords(key);
+            const node = nodeSpec.runnable;
+            const metadata = nodeSpec.metadata ?? {};
+            if (this.interruptBefore?.includes(key) &&
+                this.interruptAfter?.includes(key)) {
+                metadata.__interrupt = "before,after";
+            }
+            else if (this.interruptBefore?.includes(key)) {
+                metadata.__interrupt = "before";
+            }
+            else if (this.interruptAfter?.includes(key)) {
+                metadata.__interrupt = "after";
+            }
+            if (xray) {
+                const newXrayValue = typeof xray === "number" ? xray - 1 : xray;
+                const drawableSubgraph = subgraphs[key] !== undefined
+                    ? await subgraphs[key].getGraphAsync({
+                        ...config,
+                        xray: newXrayValue,
+                    })
+                    : node.getGraph(config);
+                drawableSubgraph.trimFirstNode();
+                drawableSubgraph.trimLastNode();
+                if (Object.keys(drawableSubgraph.nodes).length > 1) {
+                    const [e, s] = graph.extend(drawableSubgraph, displayKey);
+                    if (e === undefined) {
+                        throw new Error(`Could not extend subgraph "${key}" due to missing entrypoint.`);
+                    }
+                    // TODO: Remove default name once we stop supporting core 0.2.0
+                    // eslint-disable-next-line no-inner-declarations
+                    function _isRunnableInterface(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    thing) {
+                        return thing ? thing.lc_runnable : false;
+                    }
+                    // eslint-disable-next-line no-inner-declarations
+                    function _nodeDataStr(id, data) {
+                        if (id !== undefined && !(0, uuid_1.validate)(id)) {
+                            return id;
+                        }
+                        else if (_isRunnableInterface(data)) {
+                            try {
+                                let dataStr = data.getName();
+                                dataStr = dataStr.startsWith("Runnable")
+                                    ? dataStr.slice("Runnable".length)
+                                    : dataStr;
+                                return dataStr;
+                            }
+                            catch (error) {
+                                return data.getName();
+                            }
+                        }
+                        else {
+                            return data.name ?? "UnknownSchema";
+                        }
+                    }
+                    // TODO: Remove casts when we stop supporting core 0.2.0
+                    if (s !== undefined) {
+                        startNodes[displayKey] = {
+                            name: _nodeDataStr(s.id, s.data),
+                            ...s,
+                        };
+                    }
+                    endNodes[displayKey] = {
+                        name: _nodeDataStr(e.id, e.data),
+                        ...e,
+                    };
+                }
+                else {
+                    // TODO: Remove when we stop supporting core 0.2.0
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    const newNode = graph.addNode(node, displayKey, metadata);
+                    startNodes[displayKey] = newNode;
+                    endNodes[displayKey] = newNode;
+                }
+            }
+            else {
+                // TODO: Remove when we stop supporting core 0.2.0
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                const newNode = graph.addNode(node, displayKey, metadata);
+                startNodes[displayKey] = newNode;
+                endNodes[displayKey] = newNode;
+            }
+        }
+        const sortedEdges = [...this.builder.allEdges].sort(([a], [b]) => {
+            if (a < b) {
+                return -1;
+            }
+            else if (b > a) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+        for (const [start, end] of sortedEdges) {
+            addEdge(_escapeMermaidKeywords(start), _escapeMermaidKeywords(end));
+        }
+        for (const [start, branches] of Object.entries(this.builder.branches)) {
+            const defaultEnds = {
+                ...Object.fromEntries(Object.keys(this.builder.nodes)
+                    .filter((k) => k !== start)
+                    .map((k) => [_escapeMermaidKeywords(k), _escapeMermaidKeywords(k)])),
+                [exports.END]: exports.END,
+            };
+            for (const branch of Object.values(branches)) {
+                let ends;
+                if (branch.ends !== undefined) {
+                    ends = branch.ends;
+                }
+                else {
+                    ends = defaultEnds;
+                }
+                for (const [label, end] of Object.entries(ends)) {
+                    addEdge(_escapeMermaidKeywords(start), _escapeMermaidKeywords(end), label, true);
+                }
+            }
+        }
+        return graph;
+    }
+    /**
+     * Returns a drawable representation of the computation graph.
+     *
+     * @deprecated Use getGraphAsync instead. The async method will be the default in the next minor core release.
+     */
     getGraph(config) {
         const xray = config?.xray;
         const graph = new graph_1.Graph();

package/dist/graph/graph.d.ts

@@ -76,6 +76,14 @@ export declare class CompiledGraph<N extends string, RunInput = any, RunOutput =
     /**
      * Returns a drawable representation of the computation graph.
      */
+    getGraphAsync(config?: RunnableConfig & {
+        xray?: boolean | number;
+    }): Promise<DrawableGraph>;
+    /**
+     * Returns a drawable representation of the computation graph.
+     *
+     * @deprecated Use getGraphAsync instead. The async method will be the default in the next minor core release.
+     */
     getGraph(config?: RunnableConfig & {
         xray?: boolean | number;
     }): DrawableGraph;

package/dist/graph/graph.js

@@ -8,7 +8,7 @@ import { Channel, Pregel } from "../pregel/index.js";
 import { EphemeralValue } from "../channels/ephemeral_value.js";
 import { ChannelWrite, PASSTHROUGH } from "../pregel/write.js";
 import { _isSend, CHECKPOINT_NAMESPACE_END, CHECKPOINT_NAMESPACE_SEPARATOR, TAG_HIDDEN, } from "../constants.js";
-import { gatherIteratorSync, RunnableCallable } from "../utils.js";
+import { gatherIterator, gatherIteratorSync, RunnableCallable, } from "../utils.js";
 import { InvalidUpdateError, NodeInterrupt } from "../errors.js";
 import { isPregelLike } from "../pregel/utils/subgraph.js";
 /** Special reserved node name denoting the start of a graph. */
@@ -352,6 +352,156 @@ export class CompiledGraph extends Pregel {
     /**
      * Returns a drawable representation of the computation graph.
      */
+    async getGraphAsync(config) {
+        const xray = config?.xray;
+        const graph = new DrawableGraph();
+        const startNodes = {
+            [START]: graph.addNode({
+                schema: z.any(),
+            }, START),
+        };
+        const endNodes = {};
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        let subgraphs = {};
+        if (xray) {
+            subgraphs = Object.fromEntries((await gatherIterator(this.getSubgraphsAsync())).filter(
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            (x) => isCompiledGraph(x[1])));
+        }
+        function addEdge(start, end, label, conditional = false) {
+            if (end === END && endNodes[END] === undefined) {
+                endNodes[END] = graph.addNode({ schema: z.any() }, END);
+            }
+            return graph.addEdge(startNodes[start], endNodes[end], label !== end ? label : undefined, conditional);
+        }
+        for (const [key, nodeSpec] of Object.entries(this.builder.nodes)) {
+            const displayKey = _escapeMermaidKeywords(key);
+            const node = nodeSpec.runnable;
+            const metadata = nodeSpec.metadata ?? {};
+            if (this.interruptBefore?.includes(key) &&
+                this.interruptAfter?.includes(key)) {
+                metadata.__interrupt = "before,after";
+            }
+            else if (this.interruptBefore?.includes(key)) {
+                metadata.__interrupt = "before";
+            }
+            else if (this.interruptAfter?.includes(key)) {
+                metadata.__interrupt = "after";
+            }
+            if (xray) {
+                const newXrayValue = typeof xray === "number" ? xray - 1 : xray;
+                const drawableSubgraph = subgraphs[key] !== undefined
+                    ? await subgraphs[key].getGraphAsync({
+                        ...config,
+                        xray: newXrayValue,
+                    })
+                    : node.getGraph(config);
+                drawableSubgraph.trimFirstNode();
+                drawableSubgraph.trimLastNode();
+                if (Object.keys(drawableSubgraph.nodes).length > 1) {
+                    const [e, s] = graph.extend(drawableSubgraph, displayKey);
+                    if (e === undefined) {
+                        throw new Error(`Could not extend subgraph "${key}" due to missing entrypoint.`);
+                    }
+                    // TODO: Remove default name once we stop supporting core 0.2.0
+                    // eslint-disable-next-line no-inner-declarations
+                    function _isRunnableInterface(
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    thing) {
+                        return thing ? thing.lc_runnable : false;
+                    }
+                    // eslint-disable-next-line no-inner-declarations
+                    function _nodeDataStr(id, data) {
+                        if (id !== undefined && !isUuid(id)) {
+                            return id;
+                        }
+                        else if (_isRunnableInterface(data)) {
+                            try {
+                                let dataStr = data.getName();
+                                dataStr = dataStr.startsWith("Runnable")
+                                    ? dataStr.slice("Runnable".length)
+                                    : dataStr;
+                                return dataStr;
+                            }
+                            catch (error) {
+                                return data.getName();
+                            }
+                        }
+                        else {
+                            return data.name ?? "UnknownSchema";
+                        }
+                    }
+                    // TODO: Remove casts when we stop supporting core 0.2.0
+                    if (s !== undefined) {
+                        startNodes[displayKey] = {
+                            name: _nodeDataStr(s.id, s.data),
+                            ...s,
+                        };
+                    }
+                    endNodes[displayKey] = {
+                        name: _nodeDataStr(e.id, e.data),
+                        ...e,
+                    };
+                }
+                else {
+                    // TODO: Remove when we stop supporting core 0.2.0
+                    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                    // @ts-ignore
+                    const newNode = graph.addNode(node, displayKey, metadata);
+                    startNodes[displayKey] = newNode;
+                    endNodes[displayKey] = newNode;
+                }
+            }
+            else {
+                // TODO: Remove when we stop supporting core 0.2.0
+                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+                // @ts-ignore
+                const newNode = graph.addNode(node, displayKey, metadata);
+                startNodes[displayKey] = newNode;
+                endNodes[displayKey] = newNode;
+            }
+        }
+        const sortedEdges = [...this.builder.allEdges].sort(([a], [b]) => {
+            if (a < b) {
+                return -1;
+            }
+            else if (b > a) {
+                return 1;
+            }
+            else {
+                return 0;
+            }
+        });
+        for (const [start, end] of sortedEdges) {
+            addEdge(_escapeMermaidKeywords(start), _escapeMermaidKeywords(end));
+        }
+        for (const [start, branches] of Object.entries(this.builder.branches)) {
+            const defaultEnds = {
+                ...Object.fromEntries(Object.keys(this.builder.nodes)
+                    .filter((k) => k !== start)
+                    .map((k) => [_escapeMermaidKeywords(k), _escapeMermaidKeywords(k)])),
+                [END]: END,
+            };
+            for (const branch of Object.values(branches)) {
+                let ends;
+                if (branch.ends !== undefined) {
+                    ends = branch.ends;
+                }
+                else {
+                    ends = defaultEnds;
+                }
+                for (const [label, end] of Object.entries(ends)) {
+                    addEdge(_escapeMermaidKeywords(start), _escapeMermaidKeywords(end), label, true);
+                }
+            }
+        }
+        return graph;
+    }
+    /**
+     * Returns a drawable representation of the computation graph.
+     *
+     * @deprecated Use getGraphAsync instead. The async method will be the default in the next minor core release.
+     */
     getGraph(config) {
         const xray = config?.xray;
         const graph = new DrawableGraph();

package/dist/pregel/index.cjs

@@ -95,6 +95,12 @@ class Pregel extends runnables_1.Runnable {
             writable: true,
             value: ["langgraph", "pregel"]
         });
+        Object.defineProperty(this, "lg_is_pregel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "nodes", {
             enumerable: true,
             configurable: true,
@@ -211,8 +217,9 @@ class Pregel extends runnables_1.Runnable {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore Remove ignore when we remove support for 0.2 versions of core
     withConfig(config) {
+        const mergedConfig = (0, runnables_1.mergeConfigs)(this.config, config);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return new this.constructor({ ...this, config });
+        return new this.constructor({ ...this, config: mergedConfig });
     }
     validate() {
         (0, validate_js_1.validateGraph)({
@@ -245,6 +252,10 @@ class Pregel extends runnables_1.Runnable {
             return Object.keys(this.channels);
         }
     }
+    async getGraphAsync(config) {
+        return this.getGraph(config);
+    }
+    /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */
     *getSubgraphs(namespace, recurse
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
@@ -282,6 +293,11 @@ class Pregel extends runnables_1.Runnable {
             }
         }
     }
+    async *getSubgraphsAsync(namespace, recurse
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        yield* this.getSubgraphs(namespace, recurse);
+    }
     async _prepareStateSnapshot({ config, saved, subgraphCheckpointer, }) {
         if (saved === undefined) {
             return {
@@ -295,7 +311,7 @@ class Pregel extends runnables_1.Runnable {
         const { managed } = await this.prepareSpecs(config, { skipManaged: true });
         const channels = (0, base_js_1.emptyChannels)(this.channels, saved.checkpoint);
         const nextTasks = Object.values((0, algo_js_1._prepareNextTasks)(saved.checkpoint, this.nodes, channels, managed, saved.config, false, { step: (saved.metadata?.step ?? -1) + 1 }));
-        const subgraphs = await (0, utils_js_1.gatherIterator)(this.getSubgraphs());
+        const subgraphs = await (0, utils_js_1.gatherIterator)(this.getSubgraphsAsync());
         const parentNamespace = saved.config.configurable?.checkpoint_ns ?? "";
         const taskStates = {};
         for (const task of nextTasks) {
@@ -359,7 +375,7 @@ class Pregel extends runnables_1.Runnable {
                 .split(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR)
                 .map((part) => part.split(constants_js_1.CHECKPOINT_NAMESPACE_END)[0])
                 .join(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR);
-            for (const [name, subgraph] of this.getSubgraphs(recastCheckpointNamespace, true)) {
+            for await (const [name, subgraph] of this.getSubgraphsAsync(recastCheckpointNamespace, true)) {
                 if (name === recastCheckpointNamespace) {
                     return await subgraph.getState((0, utils_js_1.patchConfigurable)(config, {
                         [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer,
@@ -393,7 +409,7 @@ class Pregel extends runnables_1.Runnable {
                 .map((part) => part.split(constants_js_1.CHECKPOINT_NAMESPACE_END)[0])
                 .join(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR);
             // find the subgraph with the matching name
-            for (const [name, pregel] of this.getSubgraphs(recastCheckpointNamespace, true)) {
+            for await (const [name, pregel] of this.getSubgraphsAsync(recastCheckpointNamespace, true)) {
                 if (name === recastCheckpointNamespace) {
                     yield* pregel.getStateHistory((0, utils_js_1.patchConfigurable)(config, {
                         [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer,
@@ -436,7 +452,7 @@ class Pregel extends runnables_1.Runnable {
                 .join(constants_js_1.CHECKPOINT_NAMESPACE_SEPARATOR);
             // find the subgraph with the matching name
             // eslint-disable-next-line no-unreachable-loop
-            for (const [, pregel] of this.getSubgraphs(recastCheckpointNamespace, true)) {
+            for await (const [, pregel] of this.getSubgraphsAsync(recastCheckpointNamespace, true)) {
                 return await pregel.updateState((0, utils_js_1.patchConfigurable)(inputConfig, {
                     [constants_js_1.CONFIG_KEY_CHECKPOINTER]: checkpointer,
                 }), values, asNode);

package/dist/pregel/index.d.ts

@@ -4,7 +4,7 @@ import { All, BaseCheckpointSaver, BaseStore, CheckpointListOptions, CheckpointT
 import { BaseChannel } from "../channels/base.js";
 import { PregelNode } from "./read.js";
 import { ChannelWrite } from "./write.js";
-import { PregelInterface, PregelParams, StateSnapshot, StreamMode } from "./types.js";
+import { PregelInterface, PregelParams, StateSnapshot, StreamMode, PregelInputType, PregelOutputType, PregelOptions } from "./types.js";
 import { StrRecord } from "./algo.js";
 import { RetryPolicy } from "./utils/index.js";
 import { ManagedValueMapping, type ManagedValueSpec } from "../managed/base.js";
@@ -20,31 +20,11 @@ export declare class Channel {
     }): PregelNode;
     static writeTo(channels: string[], kwargs?: Record<string, WriteValue>): ChannelWrite;
 }
-/**
- * Config for executing the graph.
- */
-export interface PregelOptions<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel | ManagedValueSpec>, ConfigurableFieldType extends Record<string, any> = Record<string, any>> extends RunnableConfig<ConfigurableFieldType> {
-    /** The stream mode for the graph run. Default is ["values"]. */
-    streamMode?: StreamMode | StreamMode[];
-    inputKeys?: keyof Cc | Array<keyof Cc>;
-    /** The output keys to retrieve from the graph run. */
-    outputKeys?: keyof Cc | Array<keyof Cc>;
-    /** The nodes to interrupt the graph run before. */
-    interruptBefore?: All | Array<keyof Nn>;
-    /** The nodes to interrupt the graph run after. */
-    interruptAfter?: All | Array<keyof Nn>;
-    /** Enable debug mode for the graph run. */
-    debug?: boolean;
-    /** Whether to stream subgraphs. */
-    subgraphs?: boolean;
-    /** The shared value store */
-    store?: BaseStore;
-}
-export type PregelInputType = any;
-export type PregelOutputType = any;
-export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel | ManagedValueSpec>, ConfigurableFieldType extends Record<string, any> = StrRecord<string, any>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc, ConfigurableFieldType>> implements PregelInterface<Nn, Cc> {
+export type { PregelInputType, PregelOutputType, PregelOptions };
+export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends StrRecord<string, BaseChannel | ManagedValueSpec>, ConfigurableFieldType extends Record<string, any> = StrRecord<string, any>> extends Runnable<PregelInputType, PregelOutputType, PregelOptions<Nn, Cc, ConfigurableFieldType>> implements PregelInterface<Nn, Cc, ConfigurableFieldType>, PregelParams<Nn, Cc> {
     static lc_name(): string;
     lc_namespace: string[];
+    lg_is_pregel: boolean;
     nodes: Nn;
     channels: Cc;
     inputChannels: keyof Cc | Array<keyof Cc>;
@@ -65,7 +45,10 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
     validate(): this;
     get streamChannelsList(): Array<keyof Cc>;
     get streamChannelsAsIs(): keyof Cc | Array<keyof Cc>;
+    getGraphAsync(config: RunnableConfig): Promise<import("@langchain/core/runnables/graph").Graph>;
+    /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */
     getSubgraphs(namespace?: string, recurse?: boolean): Generator<[string, Pregel<any, any>]>;
+    getSubgraphsAsync(namespace?: string, recurse?: boolean): AsyncGenerator<[string, Pregel<any, any>]>;
     protected _prepareStateSnapshot({ config, saved, subgraphCheckpointer, }: {
         config: RunnableConfig;
         saved?: CheckpointTuple;
@@ -143,4 +126,3 @@ export declare class Pregel<Nn extends StrRecord<string, PregelNode>, Cc extends
      */
     invoke(input: PregelInputType, options?: Partial<PregelOptions<Nn, Cc, ConfigurableFieldType>>): Promise<PregelOutputType>;
 }
-export {};

package/dist/pregel/index.js

@@ -88,6 +88,12 @@ export class Pregel extends Runnable {
             writable: true,
             value: ["langgraph", "pregel"]
         });
+        Object.defineProperty(this, "lg_is_pregel", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
         Object.defineProperty(this, "nodes", {
             enumerable: true,
             configurable: true,
@@ -204,8 +210,9 @@ export class Pregel extends Runnable {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-ignore Remove ignore when we remove support for 0.2 versions of core
     withConfig(config) {
+        const mergedConfig = mergeConfigs(this.config, config);
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        return new this.constructor({ ...this, config });
+        return new this.constructor({ ...this, config: mergedConfig });
     }
     validate() {
         validateGraph({
@@ -238,6 +245,10 @@ export class Pregel extends Runnable {
             return Object.keys(this.channels);
         }
     }
+    async getGraphAsync(config) {
+        return this.getGraph(config);
+    }
+    /** @deprecated Use getSubgraphsAsync instead. The async method will become the default in the next minor release. */
     *getSubgraphs(namespace, recurse
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
@@ -275,6 +286,11 @@ export class Pregel extends Runnable {
             }
         }
     }
+    async *getSubgraphsAsync(namespace, recurse
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ) {
+        yield* this.getSubgraphs(namespace, recurse);
+    }
     async _prepareStateSnapshot({ config, saved, subgraphCheckpointer, }) {
         if (saved === undefined) {
             return {
@@ -288,7 +304,7 @@ export class Pregel extends Runnable {
         const { managed } = await this.prepareSpecs(config, { skipManaged: true });
         const channels = emptyChannels(this.channels, saved.checkpoint);
         const nextTasks = Object.values(_prepareNextTasks(saved.checkpoint, this.nodes, channels, managed, saved.config, false, { step: (saved.metadata?.step ?? -1) + 1 }));
-        const subgraphs = await gatherIterator(this.getSubgraphs());
+        const subgraphs = await gatherIterator(this.getSubgraphsAsync());
         const parentNamespace = saved.config.configurable?.checkpoint_ns ?? "";
         const taskStates = {};
         for (const task of nextTasks) {
@@ -352,7 +368,7 @@ export class Pregel extends Runnable {
                 .split(CHECKPOINT_NAMESPACE_SEPARATOR)
                 .map((part) => part.split(CHECKPOINT_NAMESPACE_END)[0])
                 .join(CHECKPOINT_NAMESPACE_SEPARATOR);
-            for (const [name, subgraph] of this.getSubgraphs(recastCheckpointNamespace, true)) {
+            for await (const [name, subgraph] of this.getSubgraphsAsync(recastCheckpointNamespace, true)) {
                 if (name === recastCheckpointNamespace) {
                     return await subgraph.getState(patchConfigurable(config, {
                         [CONFIG_KEY_CHECKPOINTER]: checkpointer,
@@ -386,7 +402,7 @@ export class Pregel extends Runnable {
                 .map((part) => part.split(CHECKPOINT_NAMESPACE_END)[0])
                 .join(CHECKPOINT_NAMESPACE_SEPARATOR);
             // find the subgraph with the matching name
-            for (const [name, pregel] of this.getSubgraphs(recastCheckpointNamespace, true)) {
+            for await (const [name, pregel] of this.getSubgraphsAsync(recastCheckpointNamespace, true)) {
                 if (name === recastCheckpointNamespace) {
                     yield* pregel.getStateHistory(patchConfigurable(config, {
                         [CONFIG_KEY_CHECKPOINTER]: checkpointer,
@@ -429,7 +445,7 @@ export class Pregel extends Runnable {
                 .join(CHECKPOINT_NAMESPACE_SEPARATOR);
             // find the subgraph with the matching name
             // eslint-disable-next-line no-unreachable-loop
-            for (const [, pregel] of this.getSubgraphs(recastCheckpointNamespace, true)) {
+            for await (const [, pregel] of this.getSubgraphsAsync(recastCheckpointNamespace, true)) {
                 return await pregel.updateState(patchConfigurable(inputConfig, {
                     [CONFIG_KEY_CHECKPOINTER]: checkpointer,
                 }), values, asNode);