@langchain/core 0.2.11 → 0.2.13-rc.0

package/README.md

@@ -85,7 +85,7 @@ Rather than having to write multiple implementations for all of those, LCEL allo
 
 For more check out the [LCEL docs](https://js.langchain.com/v0.2/docs/concepts#langchain-expression-language).
 
-![LangChain Stack](../docs/core_docs/static/img/langchain_stack_feb_2024.webp)
+![LangChain Stack](../docs/core_docs/static/svg/langchain_stack_062024.svg)
 
 ## 📕 Releases & Versioning
 

package/dist/language_models/tests/chat_models.test.js

@@ -3,6 +3,23 @@ import { test } from "@jest/globals";
 import { z } from "zod";
 import { zodToJsonSchema } from "zod-to-json-schema";
 import { FakeChatModel, FakeListChatModel } from "../../utils/testing/index.js";
+test("Test ChatModel accepts array shorthand for messages", async () => {
+    const model = new FakeChatModel({});
+    const response = await model.invoke([["human", "Hello there!"]]);
+    expect(response.content).toEqual("Hello there!");
+});
+test("Test ChatModel accepts object shorthand for messages", async () => {
+    const model = new FakeChatModel({});
+    const response = await model.invoke([
+        {
+            type: "human",
+            content: "Hello there!",
+            additional_kwargs: {},
+            example: true,
+        },
+    ]);
+    expect(response.content).toEqual("Hello there!");
+});
 test("Test ChatModel uses callbacks", async () => {
     const model = new FakeChatModel({});
     let acc = "";

package/dist/messages/base.d.ts

@@ -140,7 +140,9 @@ export declare function _mergeLists(left?: any[], right?: any[]): any[] | undefi
 export declare abstract class BaseMessageChunk extends BaseMessage {
     abstract concat(chunk: BaseMessageChunk): BaseMessageChunk;
 }
-export type BaseMessageLike = BaseMessage | [
+export type BaseMessageLike = BaseMessage | ({
+    type: MessageType | "user" | "assistant" | "placeholder";
+} & BaseMessageFields & Record<string, unknown>) | [
     StringWithAutocomplete<MessageType | "user" | "assistant" | "placeholder">,
     MessageContent
 ] | string;

package/dist/messages/utils.cjs

@@ -8,6 +8,21 @@ const function_js_1 = require("./function.cjs");
 const human_js_1 = require("./human.cjs");
 const system_js_1 = require("./system.cjs");
 const tool_js_1 = require("./tool.cjs");
+function _constructMessageFromParams(params) {
+    const { type, ...rest } = params;
+    if (type === "human" || type === "user") {
+        return new human_js_1.HumanMessage(rest);
+    }
+    else if (type === "ai" || type === "assistant") {
+        return new ai_js_1.AIMessage(rest);
+    }
+    else if (type === "system") {
+        return new system_js_1.SystemMessage(rest);
+    }
+    else {
+        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`);
+    }
+}
 function coerceMessageLikeToMessage(messageLike) {
     if (typeof messageLike === "string") {
         return new human_js_1.HumanMessage(messageLike);
@@ -15,18 +30,12 @@ function coerceMessageLikeToMessage(messageLike) {
     else if ((0, base_js_1.isBaseMessage)(messageLike)) {
         return messageLike;
     }
-    const [type, content] = messageLike;
-    if (type === "human" || type === "user") {
-        return new human_js_1.HumanMessage({ content });
-    }
-    else if (type === "ai" || type === "assistant") {
-        return new ai_js_1.AIMessage({ content });
-    }
-    else if (type === "system") {
-        return new system_js_1.SystemMessage({ content });
+    if (Array.isArray(messageLike)) {
+        const [type, content] = messageLike;
+        return _constructMessageFromParams({ type, content });
     }
     else {
-        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`);
+        return _constructMessageFromParams(messageLike);
     }
 }
 exports.coerceMessageLikeToMessage = coerceMessageLikeToMessage;

package/dist/messages/utils.js

@@ -5,6 +5,21 @@ import { FunctionMessage, FunctionMessageChunk, } from "./function.js";
 import { HumanMessage, HumanMessageChunk } from "./human.js";
 import { SystemMessage, SystemMessageChunk } from "./system.js";
 import { ToolMessage } from "./tool.js";
+function _constructMessageFromParams(params) {
+    const { type, ...rest } = params;
+    if (type === "human" || type === "user") {
+        return new HumanMessage(rest);
+    }
+    else if (type === "ai" || type === "assistant") {
+        return new AIMessage(rest);
+    }
+    else if (type === "system") {
+        return new SystemMessage(rest);
+    }
+    else {
+        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`);
+    }
+}
 export function coerceMessageLikeToMessage(messageLike) {
     if (typeof messageLike === "string") {
         return new HumanMessage(messageLike);
@@ -12,18 +27,12 @@ export function coerceMessageLikeToMessage(messageLike) {
     else if (isBaseMessage(messageLike)) {
         return messageLike;
     }
-    const [type, content] = messageLike;
-    if (type === "human" || type === "user") {
-        return new HumanMessage({ content });
-    }
-    else if (type === "ai" || type === "assistant") {
-        return new AIMessage({ content });
-    }
-    else if (type === "system") {
-        return new SystemMessage({ content });
+    if (Array.isArray(messageLike)) {
+        const [type, content] = messageLike;
+        return _constructMessageFromParams({ type, content });
     }
     else {
-        throw new Error(`Unable to coerce message from array: only human, AI, or system message coercion is currently supported.`);
+        return _constructMessageFromParams(messageLike);
     }
 }
 /**

package/dist/prompts/chat.cjs

@@ -75,33 +75,37 @@ class MessagesPlaceholder extends BaseMessagePromptTemplate {
     get inputVariables() {
         return [this.variableName];
     }
-    validateInputOrThrow(input, variableName) {
+    async formatMessages(values) {
+        const input = values[this.variableName];
         if (this.optional && !input) {
-            return false;
+            return [];
         }
         else if (!input) {
-            const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
+            const error = new Error(`Field "${this.variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
             error.name = "InputFormatError";
             throw error;
         }
-        let isInputBaseMessage = false;
-        if (Array.isArray(input)) {
-            isInputBaseMessage = input.every((message) => (0, index_js_1.isBaseMessage)(message));
-        }
-        else {
-            isInputBaseMessage = (0, index_js_1.isBaseMessage)(input);
+        let formattedMessages;
+        try {
+            if (Array.isArray(input)) {
+                formattedMessages = input.map(index_js_1.coerceMessageLikeToMessage);
+            }
+            else {
+                formattedMessages = [(0, index_js_1.coerceMessageLikeToMessage)(input)];
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
-        if (!isInputBaseMessage) {
+        catch (e) {
             const readableInput = typeof input === "string" ? input : JSON.stringify(input, null, 2);
-            const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: ${readableInput}`);
+            const error = new Error([
+                `Field "${this.variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages or coerceable values as input.`,
+                `Received value: ${readableInput}`,
+                `Additional message: ${e.message}`,
+            ].join("\n\n"));
             error.name = "InputFormatError";
             throw error;
         }
-        return true;
-    }
-    async formatMessages(values) {
-        this.validateInputOrThrow(values[this.variableName], this.variableName);
-        return values[this.variableName] ?? [];
+        return formattedMessages;
     }
 }
 exports.MessagesPlaceholder = MessagesPlaceholder;

package/dist/prompts/chat.d.ts

@@ -50,7 +50,6 @@ export declare class MessagesPlaceholder<RunInput extends InputValues = any> ext
     constructor(variableName: Extract<keyof RunInput, string>);
     constructor(fields: MessagesPlaceholderFields<Extract<keyof RunInput, string>>);
     get inputVariables(): Extract<keyof RunInput, string>[];
-    validateInputOrThrow(input: Array<unknown> | undefined, variableName: Extract<keyof RunInput, string>): input is BaseMessage[];
     formatMessages(values: TypedPromptInputValues<RunInput>): Promise<BaseMessage[]>;
 }
 /**

package/dist/prompts/chat.js

@@ -71,33 +71,37 @@ export class MessagesPlaceholder extends BaseMessagePromptTemplate {
     get inputVariables() {
         return [this.variableName];
     }
-    validateInputOrThrow(input, variableName) {
+    async formatMessages(values) {
+        const input = values[this.variableName];
         if (this.optional && !input) {
-            return false;
+            return [];
         }
         else if (!input) {
-            const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
+            const error = new Error(`Field "${this.variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined`);
             error.name = "InputFormatError";
             throw error;
         }
-        let isInputBaseMessage = false;
-        if (Array.isArray(input)) {
-            isInputBaseMessage = input.every((message) => isBaseMessage(message));
-        }
-        else {
-            isInputBaseMessage = isBaseMessage(input);
+        let formattedMessages;
+        try {
+            if (Array.isArray(input)) {
+                formattedMessages = input.map(coerceMessageLikeToMessage);
+            }
+            else {
+                formattedMessages = [coerceMessageLikeToMessage(input)];
+            }
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
         }
-        if (!isInputBaseMessage) {
+        catch (e) {
             const readableInput = typeof input === "string" ? input : JSON.stringify(input, null, 2);
-            const error = new Error(`Error: Field "${variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: ${readableInput}`);
+            const error = new Error([
+                `Field "${this.variableName}" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages or coerceable values as input.`,
+                `Received value: ${readableInput}`,
+                `Additional message: ${e.message}`,
+            ].join("\n\n"));
             error.name = "InputFormatError";
             throw error;
         }
-        return true;
-    }
-    async formatMessages(values) {
-        this.validateInputOrThrow(values[this.variableName], this.variableName);
-        return values[this.variableName] ?? [];
+        return formattedMessages;
     }
 }
 /**

package/dist/prompts/tests/chat.test.js

@@ -258,7 +258,7 @@ test("Test MessagesPlaceholder not optional", async () => {
         variableName: "foo",
     });
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    await expect(prompt.formatMessages({})).rejects.toThrow('Error: Field "foo" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined');
+    await expect(prompt.formatMessages({})).rejects.toThrow('Field "foo" in prompt uses a MessagesPlaceholder, which expects an array of BaseMessages as an input value. Received: undefined');
 });
 test("Test MessagesPlaceholder shorthand in a chat prompt template should throw for invalid syntax", async () => {
     expect(() => ChatPromptTemplate.fromMessages([["placeholder", "foo"]])).toThrow();
@@ -273,6 +273,56 @@ test("Test MessagesPlaceholder shorthand in a chat prompt template", async () =>
         new AIMessage("how r u"),
     ]);
 });
+test("Test MessagesPlaceholder shorthand in a chat prompt template with object format", async () => {
+    const prompt = ChatPromptTemplate.fromMessages([["placeholder", "{foo}"]]);
+    const messages = await prompt.formatMessages({
+        foo: [
+            {
+                type: "system",
+                content: "some initial content",
+            },
+            {
+                type: "human",
+                content: [
+                    {
+                        text: "page: 1\ndescription: One Purchase Flow\ntimestamp: '2024-06-04T14:46:46.062Z'\ntype: navigate\nscreenshot_present: true\n",
+                        type: "text",
+                    },
+                    {
+                        text: "page: 3\ndescription: intent_str=buy,mode_str=redirect,screenName_str=order-completed,\ntimestamp: '2024-06-04T14:46:58.846Z'\ntype: Screen View\nscreenshot_present: false\n",
+                        type: "text",
+                    },
+                ],
+            },
+            {
+                type: "assistant",
+                content: "some captivating response",
+            },
+        ],
+    });
+    expect(messages).toEqual([
+        new SystemMessage("some initial content"),
+        new HumanMessage({
+            content: [
+                {
+                    text: "page: 1\ndescription: One Purchase Flow\ntimestamp: '2024-06-04T14:46:46.062Z'\ntype: navigate\nscreenshot_present: true\n",
+                    type: "text",
+                },
+                {
+                    text: "page: 3\ndescription: intent_str=buy,mode_str=redirect,screenName_str=order-completed,\ntimestamp: '2024-06-04T14:46:58.846Z'\ntype: Screen View\nscreenshot_present: false\n",
+                    type: "text",
+                },
+            ],
+        }),
+        new AIMessage("some captivating response"),
+    ]);
+});
+test("Test MessagesPlaceholder with invalid shorthand should throw", async () => {
+    const prompt = ChatPromptTemplate.fromMessages([["placeholder", "{foo}"]]);
+    await expect(() => prompt.formatMessages({
+        foo: [{ badFormatting: true }],
+    })).rejects.toThrow();
+});
 test("Test using partial", async () => {
     const userPrompt = new PromptTemplate({
         template: "{foo}{bar}",

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.11",
+  "version": "0.2.13-rc.0",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {