@langchain/langgraph 0.2.18 → 0.2.20-rc.0

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();