@nocobase/plugin-ai 1.6.0-beta.17

package/dist/node_modules/@langchain/core/dist/runnables/graph_mermaid.cjs

@@ -0,0 +1,152 @@
+"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, "_");
+}
+const MARKDOWN_SPECIAL_CHARS = ["*", "_", "`"];
+function _generateMermaidGraphStyles(nodeColors) {
+    let styles = "";
+    for (const [className, color] of Object.entries(nodeColors)) {
+        styles += `\tclassDef ${className} ${color};\n`;
+    }
+    return styles;
+}
+/**
+ * Draws a Mermaid graph using the provided graph data
+ */
+function drawMermaid(nodes, edges, config) {
+    const { firstNode, lastNode, 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})",
+        };
+        if (firstNode !== undefined) {
+            formatDict[firstNode] = "{0}([{1}]):::first";
+        }
+        if (lastNode !== undefined) {
+            formatDict[lastNode] = "{0}([{1}]):::last";
+        }
+        // Add nodes to the graph
+        for (const [key, node] of Object.entries(nodes)) {
+            const nodeName = node.name.split(":").pop() ?? "";
+            const label = MARKDOWN_SPECIAL_CHARS.some((char) => nodeName.startsWith(char) && nodeName.endsWith(char))
+                ? `<p>${nodeName}</p>`
+                : nodeName;
+            let finalLabel = label;
+            if (Object.keys(node.metadata ?? {}).length) {
+                finalLabel += `<hr/><small><em>${Object.entries(node.metadata ?? {})
+                    .map(([k, v]) => `${k} = ${v}`)
+                    .join("\n")}</em></small>`;
+            }
+            const nodeLabel = (formatDict[key] ?? formatDict[defaultClassLabel])
+                .replace("{0}", _escapeNodeLabel(key))
+                .replace("{1}", finalLabel);
+            mermaidGraph += `\t${nodeLabel}\n`;
+        }
+    }
+    // Group edges by their common prefixes
+    const edgeGroups = {};
+    for (const edge of edges) {
+        const srcParts = edge.source.split(":");
+        const tgtParts = edge.target.split(":");
+        const commonPrefix = srcParts
+            .filter((src, i) => src === tgtParts[i])
+            .join(":");
+        if (!edgeGroups[commonPrefix]) {
+            edgeGroups[commonPrefix] = [];
+        }
+        edgeGroups[commonPrefix].push(edge);
+    }
+    const seenSubgraphs = new Set();
+    function addSubgraph(edges, prefix) {
+        const selfLoop = edges.length === 1 && edges[0].source === edges[0].target;
+        if (prefix && !selfLoop) {
+            const subgraph = prefix.split(":").pop();
+            if (seenSubgraphs.has(subgraph)) {
+                throw new Error(`Found duplicate subgraph '${subgraph}' -- this likely means that ` +
+                    "you're reusing a subgraph node with the same name. " +
+                    "Please adjust your graph to have subgraph nodes with unique names.");
+            }
+            seenSubgraphs.add(subgraph);
+            mermaidGraph += `\tsubgraph ${subgraph}\n`;
+        }
+        for (const edge of edges) {
+            const { source, target, data, conditional } = edge;
+            let edgeLabel = "";
+            if (data !== undefined) {
+                let edgeData = data;
+                const words = edgeData.split(" ");
+                if (words.length > wrapLabelNWords) {
+                    edgeData = Array.from({ length: Math.ceil(words.length / wrapLabelNWords) }, (_, i) => words
+                        .slice(i * wrapLabelNWords, (i + 1) * wrapLabelNWords)
+                        .join(" ")).join("&nbsp;<br>&nbsp;");
+                }
+                edgeLabel = conditional
+                    ? ` -. &nbsp;${edgeData}&nbsp; .-> `
+                    : ` -- &nbsp;${edgeData}&nbsp; --> `;
+            }
+            else {
+                edgeLabel = conditional ? " -.-> " : " --> ";
+            }
+            mermaidGraph += `\t${_escapeNodeLabel(source)}${edgeLabel}${_escapeNodeLabel(target)};\n`;
+        }
+        // Recursively add nested subgraphs
+        for (const nestedPrefix in edgeGroups) {
+            if (nestedPrefix.startsWith(`${prefix}:`) && nestedPrefix !== prefix) {
+                addSubgraph(edgeGroups[nestedPrefix], nestedPrefix);
+            }
+        }
+        if (prefix && !selfLoop) {
+            mermaidGraph += "\tend\n";
+        }
+    }
+    // Start with the top-level edges (no common prefix)
+    addSubgraph(edgeGroups[""] ?? [], "");
+    // Add remaining subgraphs
+    for (const prefix in edgeGroups) {
+        if (!prefix.includes(":") && prefix !== "") {
+            addSubgraph(edgeGroups[prefix], prefix);
+        }
+    }
+    // Add custom styles for nodes
+    if (withStyles) {
+        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/node_modules/@langchain/core/dist/runnables/graph_mermaid.d.ts

@@ -0,0 +1,18 @@
+import { Edge, Node } from "./types.js";
+/**
+ * Draws a Mermaid graph using the provided graph data
+ */
+export declare function drawMermaid(nodes: Record<string, Node>, edges: Edge[], config?: {
+    firstNode?: string;
+    lastNode?: 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/node_modules/@langchain/core/dist/runnables/graph_mermaid.js

@@ -0,0 +1,147 @@
+function _escapeNodeLabel(nodeLabel) {
+    // Escapes the node label for Mermaid syntax.
+    return nodeLabel.replace(/[^a-zA-Z-_0-9]/g, "_");
+}
+const MARKDOWN_SPECIAL_CHARS = ["*", "_", "`"];
+function _generateMermaidGraphStyles(nodeColors) {
+    let styles = "";
+    for (const [className, color] of Object.entries(nodeColors)) {
+        styles += `\tclassDef ${className} ${color};\n`;
+    }
+    return styles;
+}
+/**
+ * Draws a Mermaid graph using the provided graph data
+ */
+export function drawMermaid(nodes, edges, config) {
+    const { firstNode, lastNode, 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})",
+        };
+        if (firstNode !== undefined) {
+            formatDict[firstNode] = "{0}([{1}]):::first";
+        }
+        if (lastNode !== undefined) {
+            formatDict[lastNode] = "{0}([{1}]):::last";
+        }
+        // Add nodes to the graph
+        for (const [key, node] of Object.entries(nodes)) {
+            const nodeName = node.name.split(":").pop() ?? "";
+            const label = MARKDOWN_SPECIAL_CHARS.some((char) => nodeName.startsWith(char) && nodeName.endsWith(char))
+                ? `<p>${nodeName}</p>`
+                : nodeName;
+            let finalLabel = label;
+            if (Object.keys(node.metadata ?? {}).length) {
+                finalLabel += `<hr/><small><em>${Object.entries(node.metadata ?? {})
+                    .map(([k, v]) => `${k} = ${v}`)
+                    .join("\n")}</em></small>`;
+            }
+            const nodeLabel = (formatDict[key] ?? formatDict[defaultClassLabel])
+                .replace("{0}", _escapeNodeLabel(key))
+                .replace("{1}", finalLabel);
+            mermaidGraph += `\t${nodeLabel}\n`;
+        }
+    }
+    // Group edges by their common prefixes
+    const edgeGroups = {};
+    for (const edge of edges) {
+        const srcParts = edge.source.split(":");
+        const tgtParts = edge.target.split(":");
+        const commonPrefix = srcParts
+            .filter((src, i) => src === tgtParts[i])
+            .join(":");
+        if (!edgeGroups[commonPrefix]) {
+            edgeGroups[commonPrefix] = [];
+        }
+        edgeGroups[commonPrefix].push(edge);
+    }
+    const seenSubgraphs = new Set();
+    function addSubgraph(edges, prefix) {
+        const selfLoop = edges.length === 1 && edges[0].source === edges[0].target;
+        if (prefix && !selfLoop) {
+            const subgraph = prefix.split(":").pop();
+            if (seenSubgraphs.has(subgraph)) {
+                throw new Error(`Found duplicate subgraph '${subgraph}' -- this likely means that ` +
+                    "you're reusing a subgraph node with the same name. " +
+                    "Please adjust your graph to have subgraph nodes with unique names.");
+            }
+            seenSubgraphs.add(subgraph);
+            mermaidGraph += `\tsubgraph ${subgraph}\n`;
+        }
+        for (const edge of edges) {
+            const { source, target, data, conditional } = edge;
+            let edgeLabel = "";
+            if (data !== undefined) {
+                let edgeData = data;
+                const words = edgeData.split(" ");
+                if (words.length > wrapLabelNWords) {
+                    edgeData = Array.from({ length: Math.ceil(words.length / wrapLabelNWords) }, (_, i) => words
+                        .slice(i * wrapLabelNWords, (i + 1) * wrapLabelNWords)
+                        .join(" ")).join("&nbsp;<br>&nbsp;");
+                }
+                edgeLabel = conditional
+                    ? ` -. &nbsp;${edgeData}&nbsp; .-> `
+                    : ` -- &nbsp;${edgeData}&nbsp; --> `;
+            }
+            else {
+                edgeLabel = conditional ? " -.-> " : " --> ";
+            }
+            mermaidGraph += `\t${_escapeNodeLabel(source)}${edgeLabel}${_escapeNodeLabel(target)};\n`;
+        }
+        // Recursively add nested subgraphs
+        for (const nestedPrefix in edgeGroups) {
+            if (nestedPrefix.startsWith(`${prefix}:`) && nestedPrefix !== prefix) {
+                addSubgraph(edgeGroups[nestedPrefix], nestedPrefix);
+            }
+        }
+        if (prefix && !selfLoop) {
+            mermaidGraph += "\tend\n";
+        }
+    }
+    // Start with the top-level edges (no common prefix)
+    addSubgraph(edgeGroups[""] ?? [], "");
+    // Add remaining subgraphs
+    for (const prefix in edgeGroups) {
+        if (!prefix.includes(":") && prefix !== "") {
+            addSubgraph(edgeGroups[prefix], prefix);
+        }
+    }
+    // Add custom styles for nodes
+    if (withStyles) {
+        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/node_modules/@langchain/core/dist/runnables/history.cjs

@@ -0,0 +1,262 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnableWithMessageHistory = void 0;
+const index_js_1 = require("../messages/index.cjs");
+const base_js_1 = require("./base.cjs");
+const passthrough_js_1 = require("./passthrough.cjs");
+/**
+ * Wraps a LCEL chain and manages history. It appends input messages
+ * and chain outputs as history, and adds the current history messages to
+ * the chain input.
+ * @example
+ * ```typescript
+ * // yarn add @langchain/anthropic @langchain/community @upstash/redis
+ *
+ * import {
+ *   ChatPromptTemplate,
+ *   MessagesPlaceholder,
+ * } from "@langchain/core/prompts";
+ * import { ChatAnthropic } from "@langchain/anthropic";
+ * import { UpstashRedisChatMessageHistory } from "@langchain/community/stores/message/upstash_redis";
+ * // For demos, you can also use an in-memory store:
+ * // import { ChatMessageHistory } from "langchain/stores/message/in_memory";
+ *
+ * const prompt = ChatPromptTemplate.fromMessages([
+ *   ["system", "You're an assistant who's good at {ability}"],
+ *   new MessagesPlaceholder("history"),
+ *   ["human", "{question}"],
+ * ]);
+ *
+ * const chain = prompt.pipe(new ChatAnthropic({}));
+ *
+ * const chainWithHistory = new RunnableWithMessageHistory({
+ *   runnable: chain,
+ *   getMessageHistory: (sessionId) =>
+ *     new UpstashRedisChatMessageHistory({
+ *       sessionId,
+ *       config: {
+ *         url: process.env.UPSTASH_REDIS_REST_URL!,
+ *         token: process.env.UPSTASH_REDIS_REST_TOKEN!,
+ *       },
+ *     }),
+ *   inputMessagesKey: "question",
+ *   historyMessagesKey: "history",
+ * });
+ *
+ * const result = await chainWithHistory.invoke(
+ *   {
+ *     ability: "math",
+ *     question: "What does cosine mean?",
+ *   },
+ *   {
+ *     configurable: {
+ *       sessionId: "some_string_identifying_a_user",
+ *     },
+ *   }
+ * );
+ *
+ * const result2 = await chainWithHistory.invoke(
+ *   {
+ *     ability: "math",
+ *     question: "What's its inverse?",
+ *   },
+ *   {
+ *     configurable: {
+ *       sessionId: "some_string_identifying_a_user",
+ *     },
+ *   }
+ * );
+ * ```
+ */
+class RunnableWithMessageHistory extends base_js_1.RunnableBinding {
+    constructor(fields) {
+        let historyChain = base_js_1.RunnableLambda.from((input, options) => this._enterHistory(input, options ?? {})).withConfig({ runName: "loadHistory" });
+        const messagesKey = fields.historyMessagesKey ?? fields.inputMessagesKey;
+        if (messagesKey) {
+            historyChain = passthrough_js_1.RunnablePassthrough.assign({
+                [messagesKey]: historyChain,
+            }).withConfig({ runName: "insertHistory" });
+        }
+        const bound = historyChain
+            .pipe(fields.runnable.withListeners({
+            onEnd: (run, config) => this._exitHistory(run, config ?? {}),
+        }))
+            .withConfig({ runName: "RunnableWithMessageHistory" });
+        const config = fields.config ?? {};
+        super({
+            ...fields,
+            config,
+            bound,
+        });
+        Object.defineProperty(this, "runnable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "inputMessagesKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "outputMessagesKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "historyMessagesKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "getMessageHistory", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.runnable = fields.runnable;
+        this.getMessageHistory = fields.getMessageHistory;
+        this.inputMessagesKey = fields.inputMessagesKey;
+        this.outputMessagesKey = fields.outputMessagesKey;
+        this.historyMessagesKey = fields.historyMessagesKey;
+    }
+    _getInputMessages(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    inputValue) {
+        let parsedInputValue;
+        if (typeof inputValue === "object" &&
+            !Array.isArray(inputValue) &&
+            !(0, index_js_1.isBaseMessage)(inputValue)) {
+            let key;
+            if (this.inputMessagesKey) {
+                key = this.inputMessagesKey;
+            }
+            else if (Object.keys(inputValue).length === 1) {
+                key = Object.keys(inputValue)[0];
+            }
+            else {
+                key = "input";
+            }
+            if (Array.isArray(inputValue[key]) && Array.isArray(inputValue[key][0])) {
+                parsedInputValue = inputValue[key][0];
+            }
+            else {
+                parsedInputValue = inputValue[key];
+            }
+        }
+        else {
+            parsedInputValue = inputValue;
+        }
+        if (typeof parsedInputValue === "string") {
+            return [new index_js_1.HumanMessage(parsedInputValue)];
+        }
+        else if (Array.isArray(parsedInputValue)) {
+            return parsedInputValue;
+        }
+        else if ((0, index_js_1.isBaseMessage)(parsedInputValue)) {
+            return [parsedInputValue];
+        }
+        else {
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages.\nGot ${JSON.stringify(parsedInputValue, null, 2)}`);
+        }
+    }
+    _getOutputMessages(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    outputValue) {
+        let parsedOutputValue;
+        if (!Array.isArray(outputValue) &&
+            !(0, index_js_1.isBaseMessage)(outputValue) &&
+            typeof outputValue !== "string") {
+            let key;
+            if (this.outputMessagesKey !== undefined) {
+                key = this.outputMessagesKey;
+            }
+            else if (Object.keys(outputValue).length === 1) {
+                key = Object.keys(outputValue)[0];
+            }
+            else {
+                key = "output";
+            }
+            // If you are wrapping a chat model directly
+            // The output is actually this weird generations object
+            if (outputValue.generations !== undefined) {
+                parsedOutputValue = outputValue.generations[0][0].message;
+            }
+            else {
+                parsedOutputValue = outputValue[key];
+            }
+        }
+        else {
+            parsedOutputValue = outputValue;
+        }
+        if (typeof parsedOutputValue === "string") {
+            return [new index_js_1.AIMessage(parsedOutputValue)];
+        }
+        else if (Array.isArray(parsedOutputValue)) {
+            return parsedOutputValue;
+        }
+        else if ((0, index_js_1.isBaseMessage)(parsedOutputValue)) {
+            return [parsedOutputValue];
+        }
+        else {
+            throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(parsedOutputValue, null, 2)}`);
+        }
+    }
+    async _enterHistory(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    input, kwargs) {
+        const history = kwargs?.configurable?.messageHistory;
+        const messages = await history.getMessages();
+        if (this.historyMessagesKey === undefined) {
+            return messages.concat(this._getInputMessages(input));
+        }
+        return messages;
+    }
+    async _exitHistory(run, config) {
+        const history = config.configurable?.messageHistory;
+        // Get input messages
+        let inputs;
+        // Chat model inputs are nested arrays
+        if (Array.isArray(run.inputs) && Array.isArray(run.inputs[0])) {
+            inputs = run.inputs[0];
+        }
+        else {
+            inputs = run.inputs;
+        }
+        let inputMessages = this._getInputMessages(inputs);
+        // If historic messages were prepended to the input messages, remove them to
+        // avoid adding duplicate messages to history.
+        if (this.historyMessagesKey === undefined) {
+            const existingMessages = await history.getMessages();
+            inputMessages = inputMessages.slice(existingMessages.length);
+        }
+        // Get output messages
+        const outputValue = run.outputs;
+        if (!outputValue) {
+            throw new Error(`Output values from 'Run' undefined. Run: ${JSON.stringify(run, null, 2)}`);
+        }
+        const outputMessages = this._getOutputMessages(outputValue);
+        await history.addMessages([...inputMessages, ...outputMessages]);
+    }
+    async _mergeConfig(...configs) {
+        const config = await super._mergeConfig(...configs);
+        // Extract sessionId
+        if (!config.configurable || !config.configurable.sessionId) {
+            const exampleInput = {
+                [this.inputMessagesKey ?? "input"]: "foo",
+            };
+            const exampleConfig = { configurable: { sessionId: "123" } };
+            throw new Error(`sessionId is required. Pass it in as part of the config argument to .invoke() or .stream()\n` +
+                `eg. chain.invoke(${JSON.stringify(exampleInput)}, ${JSON.stringify(exampleConfig)})`);
+        }
+        // attach messageHistory
+        const { sessionId } = config.configurable;
+        config.configurable.messageHistory = await this.getMessageHistory(sessionId);
+        return config;
+    }
+}
+exports.RunnableWithMessageHistory = RunnableWithMessageHistory;

package/dist/node_modules/@langchain/core/dist/runnables/history.d.ts

@@ -0,0 +1,92 @@
+import { BaseChatMessageHistory, BaseListChatMessageHistory } from "../chat_history.js";
+import { BaseMessage } from "../messages/index.js";
+import { Run } from "../tracers/base.js";
+import { Runnable, RunnableBinding, type RunnableBindingArgs } from "./base.js";
+import { RunnableConfig } from "./config.js";
+type GetSessionHistoryCallable = (...args: Array<any>) => Promise<BaseChatMessageHistory | BaseListChatMessageHistory> | BaseChatMessageHistory | BaseListChatMessageHistory;
+export interface RunnableWithMessageHistoryInputs<RunInput, RunOutput> extends Omit<RunnableBindingArgs<RunInput, RunOutput>, "bound" | "config"> {
+    runnable: Runnable<RunInput, RunOutput>;
+    getMessageHistory: GetSessionHistoryCallable;
+    inputMessagesKey?: string;
+    outputMessagesKey?: string;
+    historyMessagesKey?: string;
+    config?: RunnableConfig;
+}
+/**
+ * Wraps a LCEL chain and manages history. It appends input messages
+ * and chain outputs as history, and adds the current history messages to
+ * the chain input.
+ * @example
+ * ```typescript
+ * // yarn add @langchain/anthropic @langchain/community @upstash/redis
+ *
+ * import {
+ *   ChatPromptTemplate,
+ *   MessagesPlaceholder,
+ * } from "@langchain/core/prompts";
+ * import { ChatAnthropic } from "@langchain/anthropic";
+ * import { UpstashRedisChatMessageHistory } from "@langchain/community/stores/message/upstash_redis";
+ * // For demos, you can also use an in-memory store:
+ * // import { ChatMessageHistory } from "langchain/stores/message/in_memory";
+ *
+ * const prompt = ChatPromptTemplate.fromMessages([
+ *   ["system", "You're an assistant who's good at {ability}"],
+ *   new MessagesPlaceholder("history"),
+ *   ["human", "{question}"],
+ * ]);
+ *
+ * const chain = prompt.pipe(new ChatAnthropic({}));
+ *
+ * const chainWithHistory = new RunnableWithMessageHistory({
+ *   runnable: chain,
+ *   getMessageHistory: (sessionId) =>
+ *     new UpstashRedisChatMessageHistory({
+ *       sessionId,
+ *       config: {
+ *         url: process.env.UPSTASH_REDIS_REST_URL!,
+ *         token: process.env.UPSTASH_REDIS_REST_TOKEN!,
+ *       },
+ *     }),
+ *   inputMessagesKey: "question",
+ *   historyMessagesKey: "history",
+ * });
+ *
+ * const result = await chainWithHistory.invoke(
+ *   {
+ *     ability: "math",
+ *     question: "What does cosine mean?",
+ *   },
+ *   {
+ *     configurable: {
+ *       sessionId: "some_string_identifying_a_user",
+ *     },
+ *   }
+ * );
+ *
+ * const result2 = await chainWithHistory.invoke(
+ *   {
+ *     ability: "math",
+ *     question: "What's its inverse?",
+ *   },
+ *   {
+ *     configurable: {
+ *       sessionId: "some_string_identifying_a_user",
+ *     },
+ *   }
+ * );
+ * ```
+ */
+export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends RunnableBinding<RunInput, RunOutput> {
+    runnable: Runnable<RunInput, RunOutput>;
+    inputMessagesKey?: string;
+    outputMessagesKey?: string;
+    historyMessagesKey?: string;
+    getMessageHistory: GetSessionHistoryCallable;
+    constructor(fields: RunnableWithMessageHistoryInputs<RunInput, RunOutput>);
+    _getInputMessages(inputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
+    _getOutputMessages(outputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
+    _enterHistory(input: any, kwargs?: RunnableConfig): Promise<BaseMessage[]>;
+    _exitHistory(run: Run, config: RunnableConfig): Promise<void>;
+    _mergeConfig(...configs: Array<RunnableConfig | undefined>): Promise<Partial<RunnableConfig<Record<string, any>>>>;
+}
+export {};