@langchain/core 0.2.12 → 0.2.13-rc.0

package/dist/runnables/graph.cjs

@@ -4,6 +4,7 @@ exports.Graph = exports.nodeDataStr = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const uuid_1 = require("uuid");
 const utils_js_1 = require("./utils.cjs");
+const graph_mermaid_js_1 = require("./graph_mermaid.cjs");
 const MAX_DATA_DISPLAY_NAME_LENGTH = 42;
 function nodeDataStr(node) {
     if (!(0, uuid_1.validate)(node.id)) {
@@ -11,16 +12,12 @@ function nodeDataStr(node) {
     }
     else if ((0, utils_js_1.isRunnableInterface)(node.data)) {
         try {
-            let data = node.data.toString();
-            if (data.startsWith("<") ||
-                data[0] !== data[0].toUpperCase() ||
-                data.split("\n").length > 1) {
-                data = node.data.getName();
-            }
-            else if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) {
+            let data = node.data.getName();
+            data = data.startsWith("Runnable") ? data.slice("Runnable".length) : data;
+            if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) {
                 data = `${data.substring(0, MAX_DATA_DISPLAY_NAME_LENGTH)}...`;
             }
-            return data.startsWith("Runnable") ? data.slice("Runnable".length) : data;
+            return data;
         }
         catch (error) {
             return node.data.getName();
@@ -160,5 +157,30 @@ class Graph {
             }
         }
     }
+    drawMermaid(params) {
+        const { withStyles, curveStyle, nodeColors = { start: "#ffdfba", end: "#baffc9", other: "#fad7de" }, wrapLabelNWords, } = params ?? {};
+        const nodes = {};
+        for (const node of Object.values(this.nodes)) {
+            nodes[node.id] = nodeDataStr(node);
+        }
+        const firstNode = this.firstNode();
+        const firstNodeLabel = firstNode ? nodeDataStr(firstNode) : undefined;
+        const lastNode = this.lastNode();
+        const lastNodeLabel = lastNode ? nodeDataStr(lastNode) : undefined;
+        return (0, graph_mermaid_js_1.drawMermaid)(nodes, this.edges, {
+            firstNodeLabel,
+            lastNodeLabel,
+            withStyles,
+            curveStyle,
+            nodeColors,
+            wrapLabelNWords,
+        });
+    }
+    async drawMermaidPng(params) {
+        const mermaidSyntax = this.drawMermaid(params);
+        return (0, graph_mermaid_js_1.drawMermaidPng)(mermaidSyntax, {
+            backgroundColor: params?.backgroundColor,
+        });
+    }
 }
 exports.Graph = Graph;

package/dist/runnables/graph.d.ts

@@ -1,13 +1,4 @@
-import type { RunnableInterface, RunnableIOSchema } from "./types.js";
-interface Edge {
-    source: string;
-    target: string;
-    data?: string;
-}
-interface Node {
-    id: string;
-    data: RunnableIOSchema | RunnableInterface;
-}
+import type { RunnableInterface, RunnableIOSchema, Node, Edge } from "./types.js";
 export declare function nodeDataStr(node: Node): string;
 export declare class Graph {
     nodes: Record<string, Node>;
@@ -21,5 +12,17 @@ export declare class Graph {
     extend(graph: Graph): void;
     trimFirstNode(): void;
     trimLastNode(): void;
+    drawMermaid(params?: {
+        withStyles?: boolean;
+        curveStyle?: string;
+        nodeColors?: Record<string, string>;
+        wrapLabelNWords?: number;
+    }): string;
+    drawMermaidPng(params?: {
+        withStyles?: boolean;
+        curveStyle?: string;
+        nodeColors?: Record<string, string>;
+        wrapLabelNWords?: number;
+        backgroundColor?: string;
+    }): Promise<Blob>;
 }
-export {};

package/dist/runnables/graph.js

@@ -1,6 +1,7 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { v4 as uuidv4, validate as isUuid } from "uuid";
 import { isRunnableInterface } from "./utils.js";
+import { drawMermaid, drawMermaidPng } from "./graph_mermaid.js";
 const MAX_DATA_DISPLAY_NAME_LENGTH = 42;
 export function nodeDataStr(node) {
     if (!isUuid(node.id)) {
@@ -8,16 +9,12 @@ export function nodeDataStr(node) {
     }
     else if (isRunnableInterface(node.data)) {
         try {
-            let data = node.data.toString();
-            if (data.startsWith("<") ||
-                data[0] !== data[0].toUpperCase() ||
-                data.split("\n").length > 1) {
-                data = node.data.getName();
-            }
-            else if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) {
+            let data = node.data.getName();
+            data = data.startsWith("Runnable") ? data.slice("Runnable".length) : data;
+            if (data.length > MAX_DATA_DISPLAY_NAME_LENGTH) {
                 data = `${data.substring(0, MAX_DATA_DISPLAY_NAME_LENGTH)}...`;
             }
-            return data.startsWith("Runnable") ? data.slice("Runnable".length) : data;
+            return data;
         }
         catch (error) {
             return node.data.getName();
@@ -156,4 +153,29 @@ export class Graph {
             }
         }
     }
+    drawMermaid(params) {
+        const { withStyles, curveStyle, nodeColors = { start: "#ffdfba", end: "#baffc9", other: "#fad7de" }, wrapLabelNWords, } = params ?? {};
+        const nodes = {};
+        for (const node of Object.values(this.nodes)) {
+            nodes[node.id] = nodeDataStr(node);
+        }
+        const firstNode = this.firstNode();
+        const firstNodeLabel = firstNode ? nodeDataStr(firstNode) : undefined;
+        const lastNode = this.lastNode();
+        const lastNodeLabel = lastNode ? nodeDataStr(lastNode) : undefined;
+        return drawMermaid(nodes, this.edges, {
+            firstNodeLabel,
+            lastNodeLabel,
+            withStyles,
+            curveStyle,
+            nodeColors,
+            wrapLabelNWords,
+        });
+    }
+    async drawMermaidPng(params) {
+        const mermaidSyntax = this.drawMermaid(params);
+        return drawMermaidPng(mermaidSyntax, {
+            backgroundColor: params?.backgroundColor,
+        });
+    }
 }

package/dist/runnables/graph_mermaid.cjs

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.drawMermaidPng = exports.drawMermaid = void 0;
+function _escapeNodeLabel(nodeLabel) {
+    // Escapes the node label for Mermaid syntax.
+    return nodeLabel.replace(/[^a-zA-Z-_0-9]/g, "_");
+}
+// Adjusts Mermaid edge to map conditional nodes to pure nodes.
+function _adjustMermaidEdge(edge, nodes) {
+    const sourceNodeLabel = nodes[edge.source] ?? edge.source;
+    const targetNodeLabel = nodes[edge.target] ?? edge.target;
+    return [sourceNodeLabel, targetNodeLabel];
+}
+function _generateMermaidGraphStyles(nodeColors) {
+    let styles = "";
+    for (const [className, color] of Object.entries(nodeColors)) {
+        styles += `\tclassDef ${className}class fill:${color};\n`;
+    }
+    return styles;
+}
+/**
+ * Draws a Mermaid graph using the provided graph data
+ */
+function drawMermaid(nodes, edges, config) {
+    const { firstNodeLabel, lastNodeLabel, nodeColors, withStyles = true, curveStyle = "linear", wrapLabelNWords = 9, } = config ?? {};
+    // Initialize Mermaid graph configuration
+    let mermaidGraph = withStyles
+        ? `%%{init: {'flowchart': {'curve': '${curveStyle}'}}}%%\ngraph TD;\n`
+        : "graph TD;\n";
+    if (withStyles) {
+        // Node formatting templates
+        const defaultClassLabel = "default";
+        const formatDict = {
+            [defaultClassLabel]: "{0}([{1}]):::otherclass",
+        };
+        if (firstNodeLabel !== undefined) {
+            formatDict[firstNodeLabel] = "{0}[{0}]:::startclass";
+        }
+        if (lastNodeLabel !== undefined) {
+            formatDict[lastNodeLabel] = "{0}[{0}]:::endclass";
+        }
+        // Add nodes to the graph
+        for (const node of Object.values(nodes)) {
+            const nodeLabel = formatDict[node] ?? formatDict[defaultClassLabel];
+            const escapedNodeLabel = _escapeNodeLabel(node);
+            const nodeParts = node.split(":");
+            const nodeSplit = nodeParts[nodeParts.length - 1];
+            mermaidGraph += `\t${nodeLabel
+                .replace(/\{0\}/g, escapedNodeLabel)
+                .replace(/\{1\}/g, nodeSplit)};\n`;
+        }
+    }
+    let subgraph = "";
+    // Add edges to the graph
+    for (const edge of edges) {
+        const sourcePrefix = edge.source.includes(":")
+            ? edge.source.split(":")[0]
+            : undefined;
+        const targetPrefix = edge.target.includes(":")
+            ? edge.target.split(":")[0]
+            : undefined;
+        // Exit subgraph if source or target is not in the same subgraph
+        if (subgraph !== "" &&
+            (subgraph !== sourcePrefix || subgraph !== targetPrefix)) {
+            mermaidGraph += "\tend\n";
+            subgraph = "";
+        }
+        // Enter subgraph if source and target are in the same subgraph
+        if (subgraph === "" &&
+            sourcePrefix !== undefined &&
+            sourcePrefix === targetPrefix) {
+            mermaidGraph = `\tsubgraph ${sourcePrefix}\n`;
+            subgraph = sourcePrefix;
+        }
+        const [source, target] = _adjustMermaidEdge(edge, nodes);
+        let edgeLabel = "";
+        // Add BR every wrapLabelNWords words
+        if (edge.data !== undefined) {
+            let edgeData = edge.data;
+            const words = edgeData.split(" ");
+            // Group words into chunks of wrapLabelNWords size
+            if (words.length > wrapLabelNWords) {
+                edgeData = words
+                    .reduce((acc, word, i) => {
+                    if (i % wrapLabelNWords === 0)
+                        acc.push("");
+                    acc[acc.length - 1] += ` ${word}`;
+                    return acc;
+                }, [])
+                    .join("<br>");
+                if (edge.conditional) {
+                    edgeLabel = ` -. ${edgeData} .-> `;
+                }
+                else {
+                    edgeLabel = ` -- ${edgeData} --> `;
+                }
+            }
+        }
+        else {
+            if (edge.conditional) {
+                edgeLabel = ` -.-> `;
+            }
+            else {
+                edgeLabel = ` --> `;
+            }
+        }
+        mermaidGraph += `\t${_escapeNodeLabel(source)}${edgeLabel}${_escapeNodeLabel(target)};\n`;
+    }
+    if (subgraph !== "") {
+        mermaidGraph += "end\n";
+    }
+    // Add custom styles for nodes
+    if (withStyles && nodeColors !== undefined) {
+        mermaidGraph += _generateMermaidGraphStyles(nodeColors);
+    }
+    return mermaidGraph;
+}
+exports.drawMermaid = drawMermaid;
+/**
+ * Renders Mermaid graph using the Mermaid.INK API.
+ */
+async function drawMermaidPng(mermaidSyntax, config) {
+    let { backgroundColor = "white" } = config ?? {};
+    // Use btoa for compatibility, assume ASCII
+    const mermaidSyntaxEncoded = btoa(mermaidSyntax);
+    // Check if the background color is a hexadecimal color code using regex
+    if (backgroundColor !== undefined) {
+        const hexColorPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+        if (!hexColorPattern.test(backgroundColor)) {
+            backgroundColor = `!${backgroundColor}`;
+        }
+    }
+    const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}`;
+    const res = await fetch(imageUrl);
+    if (!res.ok) {
+        throw new Error([
+            `Failed to render the graph using the Mermaid.INK API.`,
+            `Status code: ${res.status}`,
+            `Status text: ${res.statusText}`,
+        ].join("\n"));
+    }
+    const content = await res.blob();
+    return content;
+}
+exports.drawMermaidPng = drawMermaidPng;

package/dist/runnables/graph_mermaid.d.ts

@@ -0,0 +1,18 @@
+import { Edge } from "./types.js";
+/**
+ * Draws a Mermaid graph using the provided graph data
+ */
+export declare function drawMermaid(nodes: Record<string, string>, edges: Edge[], config?: {
+    firstNodeLabel?: string;
+    lastNodeLabel?: string;
+    curveStyle?: string;
+    withStyles?: boolean;
+    nodeColors?: Record<string, string>;
+    wrapLabelNWords?: number;
+}): string;
+/**
+ * Renders Mermaid graph using the Mermaid.INK API.
+ */
+export declare function drawMermaidPng(mermaidSyntax: string, config?: {
+    backgroundColor?: string;
+}): Promise<Blob>;

package/dist/runnables/graph_mermaid.js

@@ -0,0 +1,140 @@
+function _escapeNodeLabel(nodeLabel) {
+    // Escapes the node label for Mermaid syntax.
+    return nodeLabel.replace(/[^a-zA-Z-_0-9]/g, "_");
+}
+// Adjusts Mermaid edge to map conditional nodes to pure nodes.
+function _adjustMermaidEdge(edge, nodes) {
+    const sourceNodeLabel = nodes[edge.source] ?? edge.source;
+    const targetNodeLabel = nodes[edge.target] ?? edge.target;
+    return [sourceNodeLabel, targetNodeLabel];
+}
+function _generateMermaidGraphStyles(nodeColors) {
+    let styles = "";
+    for (const [className, color] of Object.entries(nodeColors)) {
+        styles += `\tclassDef ${className}class fill:${color};\n`;
+    }
+    return styles;
+}
+/**
+ * Draws a Mermaid graph using the provided graph data
+ */
+export function drawMermaid(nodes, edges, config) {
+    const { firstNodeLabel, lastNodeLabel, nodeColors, withStyles = true, curveStyle = "linear", wrapLabelNWords = 9, } = config ?? {};
+    // Initialize Mermaid graph configuration
+    let mermaidGraph = withStyles
+        ? `%%{init: {'flowchart': {'curve': '${curveStyle}'}}}%%\ngraph TD;\n`
+        : "graph TD;\n";
+    if (withStyles) {
+        // Node formatting templates
+        const defaultClassLabel = "default";
+        const formatDict = {
+            [defaultClassLabel]: "{0}([{1}]):::otherclass",
+        };
+        if (firstNodeLabel !== undefined) {
+            formatDict[firstNodeLabel] = "{0}[{0}]:::startclass";
+        }
+        if (lastNodeLabel !== undefined) {
+            formatDict[lastNodeLabel] = "{0}[{0}]:::endclass";
+        }
+        // Add nodes to the graph
+        for (const node of Object.values(nodes)) {
+            const nodeLabel = formatDict[node] ?? formatDict[defaultClassLabel];
+            const escapedNodeLabel = _escapeNodeLabel(node);
+            const nodeParts = node.split(":");
+            const nodeSplit = nodeParts[nodeParts.length - 1];
+            mermaidGraph += `\t${nodeLabel
+                .replace(/\{0\}/g, escapedNodeLabel)
+                .replace(/\{1\}/g, nodeSplit)};\n`;
+        }
+    }
+    let subgraph = "";
+    // Add edges to the graph
+    for (const edge of edges) {
+        const sourcePrefix = edge.source.includes(":")
+            ? edge.source.split(":")[0]
+            : undefined;
+        const targetPrefix = edge.target.includes(":")
+            ? edge.target.split(":")[0]
+            : undefined;
+        // Exit subgraph if source or target is not in the same subgraph
+        if (subgraph !== "" &&
+            (subgraph !== sourcePrefix || subgraph !== targetPrefix)) {
+            mermaidGraph += "\tend\n";
+            subgraph = "";
+        }
+        // Enter subgraph if source and target are in the same subgraph
+        if (subgraph === "" &&
+            sourcePrefix !== undefined &&
+            sourcePrefix === targetPrefix) {
+            mermaidGraph = `\tsubgraph ${sourcePrefix}\n`;
+            subgraph = sourcePrefix;
+        }
+        const [source, target] = _adjustMermaidEdge(edge, nodes);
+        let edgeLabel = "";
+        // Add BR every wrapLabelNWords words
+        if (edge.data !== undefined) {
+            let edgeData = edge.data;
+            const words = edgeData.split(" ");
+            // Group words into chunks of wrapLabelNWords size
+            if (words.length > wrapLabelNWords) {
+                edgeData = words
+                    .reduce((acc, word, i) => {
+                    if (i % wrapLabelNWords === 0)
+                        acc.push("");
+                    acc[acc.length - 1] += ` ${word}`;
+                    return acc;
+                }, [])
+                    .join("<br>");
+                if (edge.conditional) {
+                    edgeLabel = ` -. ${edgeData} .-> `;
+                }
+                else {
+                    edgeLabel = ` -- ${edgeData} --> `;
+                }
+            }
+        }
+        else {
+            if (edge.conditional) {
+                edgeLabel = ` -.-> `;
+            }
+            else {
+                edgeLabel = ` --> `;
+            }
+        }
+        mermaidGraph += `\t${_escapeNodeLabel(source)}${edgeLabel}${_escapeNodeLabel(target)};\n`;
+    }
+    if (subgraph !== "") {
+        mermaidGraph += "end\n";
+    }
+    // Add custom styles for nodes
+    if (withStyles && nodeColors !== undefined) {
+        mermaidGraph += _generateMermaidGraphStyles(nodeColors);
+    }
+    return mermaidGraph;
+}
+/**
+ * Renders Mermaid graph using the Mermaid.INK API.
+ */
+export async function drawMermaidPng(mermaidSyntax, config) {
+    let { backgroundColor = "white" } = config ?? {};
+    // Use btoa for compatibility, assume ASCII
+    const mermaidSyntaxEncoded = btoa(mermaidSyntax);
+    // Check if the background color is a hexadecimal color code using regex
+    if (backgroundColor !== undefined) {
+        const hexColorPattern = /^#(?:[0-9a-fA-F]{3}){1,2}$/;
+        if (!hexColorPattern.test(backgroundColor)) {
+            backgroundColor = `!${backgroundColor}`;
+        }
+    }
+    const imageUrl = `https://mermaid.ink/img/${mermaidSyntaxEncoded}?bgColor=${backgroundColor}`;
+    const res = await fetch(imageUrl);
+    if (!res.ok) {
+        throw new Error([
+            `Failed to render the graph using the Mermaid.INK API.`,
+            `Status code: ${res.status}`,
+            `Status text: ${res.statusText}`,
+        ].join("\n"));
+    }
+    const content = await res.blob();
+    return content;
+}

package/dist/runnables/tests/runnable_graph.test.js

@@ -81,4 +81,20 @@ test("Test graph sequence", async () => {
             { source: 2, target: 3 },
         ],
     });
+    expect(graph.drawMermaid())
+        .toEqual(`%%{init: {'flowchart': {'curve': 'linear'}}}%%
+graph TD;
+\tPromptTemplateInput[PromptTemplateInput]:::startclass;
+\tPromptTemplate([PromptTemplate]):::otherclass;
+\tFakeLLM([FakeLLM]):::otherclass;
+\tCommaSeparatedListOutputParser([CommaSeparatedListOutputParser]):::otherclass;
+\tCommaSeparatedListOutputParserOutput[CommaSeparatedListOutputParserOutput]:::endclass;
+\tPromptTemplateInput --> PromptTemplate;
+\tPromptTemplate --> FakeLLM;
+\tCommaSeparatedListOutputParser --> CommaSeparatedListOutputParserOutput;
+\tFakeLLM --> CommaSeparatedListOutputParser;
+\tclassDef startclass fill:#ffdfba;
+\tclassDef endclass fill:#baffc9;
+\tclassDef otherclass fill:#fad7de;
+`);
 });

package/dist/runnables/types.d.ts

@@ -31,3 +31,13 @@ export interface RunnableInterface<RunInput = any, RunOutput = any, CallOptions
     transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     getName(suffix?: string): string;
 }
+export interface Edge {
+    source: string;
+    target: string;
+    data?: string;
+    conditional?: boolean;
+}
+export interface Node {
+    id: string;
+    data: RunnableIOSchema | RunnableInterface;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.2.12",
+  "version": "0.2.13-rc.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {