@langchain/core 0.2.0 → 0.2.1

package/dist/runnables/base.cjs

@@ -6,8 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnablePick = exports.RunnableAssign = exports._coerceToRunnable = exports.RunnableWithFallbacks = exports.RunnableParallel = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = exports._coerceToDict = void 0;
 const zod_1 = require("zod");
 const p_retry_1 = __importDefault(require("p-retry"));
+const uuid_1 = require("uuid");
 const manager_js_1 = require("../callbacks/manager.cjs");
 const log_stream_js_1 = require("../tracers/log_stream.cjs");
+const event_stream_js_1 = require("../tracers/event_stream.cjs");
 const serializable_js_1 = require("../load/serializable.cjs");
 const stream_js_1 = require("../utils/stream.cjs");
 const config_js_1 = require("./config.cjs");
@@ -285,11 +287,16 @@ class Runnable extends serializable_js_1.Serializable {
             const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
             delete config.runId;
             runManager = pipe.setup;
+            const isStreamEventsHandler = (handler) => handler.name === "event_stream_tracer";
+            const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
+            let iterator = pipe.output;
+            if (streamEventsHandler !== undefined && runManager !== undefined) {
+                iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
+            }
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
-            let iterator = pipe.output;
             if (streamLogHandler !== undefined && runManager !== undefined) {
-                iterator = await streamLogHandler.tapOutputIterable(runManager.runId, pipe.output);
+                iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
             }
             for await (const chunk of iterator) {
                 yield chunk;
@@ -455,7 +462,16 @@ class Runnable extends serializable_js_1.Serializable {
         }
     }
     streamEvents(input, options, streamOptions) {
-        const stream = this._streamEvents(input, options, streamOptions);
+        let stream;
+        if (options.version === "v1") {
+            stream = this._streamEventsV1(input, options, streamOptions);
+        }
+        else if (options.version === "v2") {
+            stream = this._streamEventsV2(input, options, streamOptions);
+        }
+        else {
+            throw new Error(`Only versions "v1" and "v2" of the schema are currently supported.`);
+        }
         if (options.encoding === "text/event-stream") {
             return (0, wrappers_js_1.convertToHttpEventStream)(stream);
         }
@@ -463,10 +479,75 @@ class Runnable extends serializable_js_1.Serializable {
             return stream_js_1.IterableReadableStream.fromAsyncGenerator(stream);
         }
     }
-    async *_streamEvents(input, options, streamOptions) {
-        if (options.version !== "v1") {
-            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+    async *_streamEventsV2(input, options, streamOptions) {
+        const eventStreamer = new event_stream_js_1.EventStreamCallbackHandler({
+            ...streamOptions,
+            autoClose: false,
+        });
+        const config = (0, config_js_1.ensureConfig)(options);
+        const runId = config.runId ?? (0, uuid_1.v4)();
+        config.runId = runId;
+        const callbacks = config.callbacks;
+        if (callbacks === undefined) {
+            config.callbacks = [eventStreamer];
+        }
+        else if (Array.isArray(callbacks)) {
+            config.callbacks = callbacks.concat(eventStreamer);
+        }
+        else {
+            const copiedCallbacks = callbacks.copy();
+            copiedCallbacks.inheritableHandlers.push(eventStreamer);
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = copiedCallbacks;
+        }
+        // Call the runnable in streaming mode,
+        // add each chunk to the output stream
+        const outerThis = this;
+        async function consumeRunnableStream() {
+            try {
+                const runnableStream = await outerThis.stream(input, config);
+                const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                for await (const _ of tappedStream) {
+                    // Just iterate so that the callback handler picks up events
+                }
+            }
+            finally {
+                await eventStreamer.writer.close();
+            }
+        }
+        const runnableStreamConsumePromise = consumeRunnableStream();
+        let firstEventSent = false;
+        let firstEventRunId;
+        try {
+            for await (const event of eventStreamer) {
+                // This is a work-around an issue where the inputs into the
+                // chain are not available until the entire input is consumed.
+                // As a temporary solution, we'll modify the input to be the input
+                // that was passed into the chain.
+                if (!firstEventSent) {
+                    event.data.input = input;
+                    firstEventSent = true;
+                    firstEventRunId = event.run_id;
+                    yield event;
+                    continue;
+                }
+                if (event.run_id === firstEventRunId && event.event.endsWith("_end")) {
+                    // If it's the end event corresponding to the root runnable
+                    // we dont include the input in the event since it's guaranteed
+                    // to be included in the first event.
+                    if (event.data?.input) {
+                        delete event.data.input;
+                    }
+                }
+                yield event;
+            }
         }
+        finally {
+            await runnableStreamConsumePromise;
+        }
+    }
+    async *_streamEventsV1(input, options, streamOptions) {
         let runLog;
         let hasEncounteredStartEvent = false;
         const config = (0, config_js_1.ensureConfig)(options);

package/dist/runnables/base.d.ts

@@ -1,6 +1,7 @@
 import type { RunnableInterface, RunnableBatchOptions } from "./types.js";
 import { CallbackManagerForChainRun } from "../callbacks/manager.js";
-import { LogStreamCallbackHandler, LogStreamCallbackHandlerInput, RunLogPatch, StreamEvent } from "../tracers/log_stream.js";
+import { LogStreamCallbackHandler, LogStreamCallbackHandlerInput, RunLogPatch } from "../tracers/log_stream.js";
+import { EventStreamCallbackHandlerInput, StreamEvent } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream } from "../utils/stream.js";
 import { RunnableConfig } from "./config.js";
@@ -179,33 +180,51 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * chains. Metadata fields have been omitted from the table for brevity.
      * Chain definitions have been included after the table.
      *
-     * | event                | name             | chunk                              | input                                         | output                                          |
-     * |----------------------|------------------|------------------------------------|-----------------------------------------------|-------------------------------------------------|
-     * | on_llm_start         | [model name]     |                                    | {'input': 'hello'}                            |                                                 |
-     * | on_llm_stream        | [model name]     | 'Hello' OR AIMessageChunk("hello") |                                               |                                                 |
-     * | on_llm_end           | [model name]     |                                    | 'Hello human!'                                |
-     * | on_chain_start       | format_docs      |                                    |                                               |                                                 |
-     * | on_chain_stream      | format_docs      | "hello world!, goodbye world!"     |                                               |                                                 |
-     * | on_chain_end         | format_docs      |                                    | [Document(...)]                               | "hello world!, goodbye world!"                  |
-     * | on_tool_start        | some_tool        |                                    | {"x": 1, "y": "2"}                            |                                                 |
-     * | on_tool_stream       | some_tool        |   {"x": 1, "y": "2"}               |                                               |                                                 |
-     * | on_tool_end          | some_tool        |                                    |                                               | {"x": 1, "y": "2"}                              |
-     * | on_retriever_start   | [retriever name] |                                    | {"query": "hello"}                            |                                                 |
-     * | on_retriever_chunk   | [retriever name] |  {documents: [...]}                |                                               |                                                 |
-     * | on_retriever_end     | [retriever name] |                                    | {"query": "hello"}                            | {documents: [...]}                              |
-     * | on_prompt_start      | [template_name]  |                                    | {"question": "hello"}                         |                                                 |
-     * | on_prompt_end        | [template_name]  |                                    | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
+     * **ATTENTION** This reference table is for the V2 version of the schema.
+     *
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | event                | name             | chunk                           | input                                         | output                                          |
+     * +======================+==================+=================================+===============================================+=================================================+
+     * | on_chat_model_start  | [model name]     |                                 | {"messages": [[SystemMessage, HumanMessage]]} |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_chat_model_stream | [model name]     | AIMessageChunk(content="hello") |                                               |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_chat_model_end    | [model name]     |                                 | {"messages": [[SystemMessage, HumanMessage]]} | AIMessageChunk(content="hello world")           |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_llm_start         | [model name]     |                                 | {'input': 'hello'}                            |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_llm_stream        | [model name]     | 'Hello'                         |                                               |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_llm_end           | [model name]     |                                 | 'Hello human!'                                |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_chain_start       | format_docs      |                                 |                                               |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_chain_stream      | format_docs      | "hello world!, goodbye world!"  |                                               |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_chain_end         | format_docs      |                                 | [Document(...)]                               | "hello world!, goodbye world!"                  |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_tool_start        | some_tool        |                                 | {"x": 1, "y": "2"}                            |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_tool_end          | some_tool        |                                 |                                               | {"x": 1, "y": "2"}                              |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_retriever_start   | [retriever name] |                                 | {"query": "hello"}                            |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_retriever_end     | [retriever name] |                                 | {"query": "hello"}                            | [Document(...), ..]                             |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_prompt_start      | [template_name]  |                                 | {"question": "hello"}                         |                                                 |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
+     * | on_prompt_end        | [template_name]  |                                 | {"question": "hello"}                         | ChatPromptValue(messages: [SystemMessage, ...]) |
+     * +----------------------+------------------+---------------------------------+-----------------------------------------------+-------------------------------------------------+
      */
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
+        version: "v1" | "v2";
+    }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
         encoding: "text/event-stream";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
-    _streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
-    }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): AsyncGenerator<StreamEvent>;
+    }, streamOptions?: Omit<EventStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
+    private _streamEventsV2;
+    private _streamEventsV1;
     static isRunnable(thing: any): thing is Runnable;
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -262,10 +281,10 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     stream(input: RunInput, options?: Partial<CallOptions> | undefined): Promise<IterableReadableStream<RunOutput>>;
     transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<StreamEvent>;
     streamEvents(input: RunInput, options: Partial<CallOptions> & {
-        version: "v1";
+        version: "v1" | "v2";
         encoding: "text/event-stream";
     }, streamOptions?: Omit<LogStreamCallbackHandlerInput, "autoClose">): IterableReadableStream<Uint8Array>;
     static isRunnableBinding(thing: any): thing is RunnableBinding<any, any, any>;

package/dist/runnables/base.js

@@ -1,7 +1,9 @@
 import { z } from "zod";
 import pRetry from "p-retry";
+import { v4 as uuidv4 } from "uuid";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLog, RunLogPatch, } from "../tracers/log_stream.js";
+import { EventStreamCallbackHandler, } from "../tracers/event_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGeneratorWithSetup, } from "../utils/stream.js";
 import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
@@ -278,11 +280,16 @@ export class Runnable extends Serializable {
             const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, config.runId, config.runType, undefined, undefined, config.runName ?? this.getName()), config);
             delete config.runId;
             runManager = pipe.setup;
+            const isStreamEventsHandler = (handler) => handler.name === "event_stream_tracer";
+            const streamEventsHandler = runManager?.handlers.find(isStreamEventsHandler);
+            let iterator = pipe.output;
+            if (streamEventsHandler !== undefined && runManager !== undefined) {
+                iterator = streamEventsHandler.tapOutputIterable(runManager.runId, iterator);
+            }
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
-            let iterator = pipe.output;
             if (streamLogHandler !== undefined && runManager !== undefined) {
-                iterator = await streamLogHandler.tapOutputIterable(runManager.runId, pipe.output);
+                iterator = streamLogHandler.tapOutputIterable(runManager.runId, iterator);
             }
             for await (const chunk of iterator) {
                 yield chunk;
@@ -448,7 +455,16 @@ export class Runnable extends Serializable {
         }
     }
     streamEvents(input, options, streamOptions) {
-        const stream = this._streamEvents(input, options, streamOptions);
+        let stream;
+        if (options.version === "v1") {
+            stream = this._streamEventsV1(input, options, streamOptions);
+        }
+        else if (options.version === "v2") {
+            stream = this._streamEventsV2(input, options, streamOptions);
+        }
+        else {
+            throw new Error(`Only versions "v1" and "v2" of the schema are currently supported.`);
+        }
         if (options.encoding === "text/event-stream") {
             return convertToHttpEventStream(stream);
         }
@@ -456,10 +472,75 @@ export class Runnable extends Serializable {
             return IterableReadableStream.fromAsyncGenerator(stream);
         }
     }
-    async *_streamEvents(input, options, streamOptions) {
-        if (options.version !== "v1") {
-            throw new Error(`Only version "v1" of the events schema is currently supported.`);
+    async *_streamEventsV2(input, options, streamOptions) {
+        const eventStreamer = new EventStreamCallbackHandler({
+            ...streamOptions,
+            autoClose: false,
+        });
+        const config = ensureConfig(options);
+        const runId = config.runId ?? uuidv4();
+        config.runId = runId;
+        const callbacks = config.callbacks;
+        if (callbacks === undefined) {
+            config.callbacks = [eventStreamer];
+        }
+        else if (Array.isArray(callbacks)) {
+            config.callbacks = callbacks.concat(eventStreamer);
+        }
+        else {
+            const copiedCallbacks = callbacks.copy();
+            copiedCallbacks.inheritableHandlers.push(eventStreamer);
+            // eslint-disable-next-line no-param-reassign
+            config.callbacks = copiedCallbacks;
+        }
+        // Call the runnable in streaming mode,
+        // add each chunk to the output stream
+        const outerThis = this;
+        async function consumeRunnableStream() {
+            try {
+                const runnableStream = await outerThis.stream(input, config);
+                const tappedStream = eventStreamer.tapOutputIterable(runId, runnableStream);
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                for await (const _ of tappedStream) {
+                    // Just iterate so that the callback handler picks up events
+                }
+            }
+            finally {
+                await eventStreamer.writer.close();
+            }
+        }
+        const runnableStreamConsumePromise = consumeRunnableStream();
+        let firstEventSent = false;
+        let firstEventRunId;
+        try {
+            for await (const event of eventStreamer) {
+                // This is a work-around an issue where the inputs into the
+                // chain are not available until the entire input is consumed.
+                // As a temporary solution, we'll modify the input to be the input
+                // that was passed into the chain.
+                if (!firstEventSent) {
+                    event.data.input = input;
+                    firstEventSent = true;
+                    firstEventRunId = event.run_id;
+                    yield event;
+                    continue;
+                }
+                if (event.run_id === firstEventRunId && event.event.endsWith("_end")) {
+                    // If it's the end event corresponding to the root runnable
+                    // we dont include the input in the event since it's guaranteed
+                    // to be included in the first event.
+                    if (event.data?.input) {
+                        delete event.data.input;
+                    }
+                }
+                yield event;
+            }
         }
+        finally {
+            await runnableStreamConsumePromise;
+        }
+    }
+    async *_streamEventsV1(input, options, streamOptions) {
         let runLog;
         let hasEncounteredStartEvent = false;
         const config = ensureConfig(options);

package/dist/runnables/history.cjs

@@ -126,68 +126,123 @@ class RunnableWithMessageHistory extends base_js_1.RunnableBinding {
         this.outputMessagesKey = fields.outputMessagesKey;
         this.historyMessagesKey = fields.historyMessagesKey;
     }
-    _getInputMessages(inputValue) {
-        if (typeof inputValue === "string") {
-            return [new index_js_1.HumanMessage(inputValue)];
+    _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(inputValue)) {
-            return inputValue;
+        else if (Array.isArray(parsedInputValue)) {
+            return parsedInputValue;
+        }
+        else if ((0, index_js_1.isBaseMessage)(parsedInputValue)) {
+            return [parsedInputValue];
         }
         else {
-            return [inputValue];
+            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 newOutputValue = outputValue;
+        let parsedOutputValue;
         if (!Array.isArray(outputValue) &&
             !(0, index_js_1.isBaseMessage)(outputValue) &&
             typeof outputValue !== "string") {
-            newOutputValue = outputValue[this.outputMessagesKey ?? "output"];
+            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 newOutputValue === "string") {
-            return [new index_js_1.AIMessage(newOutputValue)];
+        if (typeof parsedOutputValue === "string") {
+            return [new index_js_1.AIMessage(parsedOutputValue)];
         }
-        else if (Array.isArray(newOutputValue)) {
-            return newOutputValue;
+        else if (Array.isArray(parsedOutputValue)) {
+            return parsedOutputValue;
         }
-        else if ((0, index_js_1.isBaseMessage)(newOutputValue)) {
-            return [newOutputValue];
+        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)}`);
         }
-        throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(newOutputValue, null, 2)}`);
     }
     async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
         const history = kwargs?.config?.configurable?.messageHistory;
-        if (this.historyMessagesKey) {
-            return history.getMessages();
-        }
-        const inputVal = input ||
-            (this.inputMessagesKey ? input[this.inputMessagesKey] : undefined);
-        const historyMessages = history ? await history.getMessages() : [];
-        const returnType = [
-            ...historyMessages,
-            ...this._getInputMessages(inputVal),
-        ];
-        return returnType;
+        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
-        const { inputs } = run;
-        const inputValue = inputs[this.inputMessagesKey ?? "input"];
-        const inputMessages = this._getInputMessages(inputValue);
+        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);
-        for await (const message of [...inputMessages, ...outputMessages]) {
-            await history.addMessage(message);
-        }
+        await history.addMessages([...inputMessages, ...outputMessages]);
     }
     async _mergeConfig(...configs) {
         const config = await super._mergeConfig(...configs);

package/dist/runnables/history.d.ts

@@ -83,7 +83,7 @@ export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends Run
     historyMessagesKey?: string;
     getMessageHistory: GetSessionHistoryCallable;
     constructor(fields: RunnableWithMessageHistoryInputs<RunInput, RunOutput>);
-    _getInputMessages(inputValue: string | BaseMessage | Array<BaseMessage>): Array<BaseMessage>;
+    _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?: {
         config?: RunnableConfig;