@langchain/core 0.1.4 → 0.1.6

package/dist/runnables/base.js

@@ -2,8 +2,8 @@ import pRetry from "p-retry";
 import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
-import { IterableReadableStream, } from "../utils/stream.js";
-import { getCallbackMangerForConfig, mergeConfigs, } from "./config.js";
+import { IterableReadableStream, concat, atee, AsyncGeneratorWithSetup, } from "../utils/stream.js";
+import { DEFAULT_RECURSION_LIMIT, getCallbackManagerForConfig, mergeConfigs, } from "./config.js";
 import { AsyncCaller } from "../utils/async_caller.js";
 import { RootListenersTracer } from "../tracers/root_listener.js";
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -25,6 +25,18 @@ export class Runnable extends Serializable {
             writable: true,
             value: true
         });
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+    }
+    getName(suffix) {
+        const name = 
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        this.name ?? this.constructor.lc_name() ?? this.constructor.name;
+        return suffix ? `${name}${suffix}` : name;
     }
     /**
      * Bind arguments to a Runnable, returning a new Runnable.
@@ -139,17 +151,19 @@ export class Runnable extends Serializable {
             tags: options.tags,
             metadata: options.metadata,
             runName: options.runName,
+            configurable: options.configurable,
         };
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
         delete callOptions.runName;
+        delete callOptions.configurable;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName());
         let output;
         try {
             output = await func.bind(this)(input, options, runManager);
@@ -172,8 +186,8 @@ export class Runnable extends Serializable {
      */
     async _batchWithConfig(func, inputs, options, batchOptions) {
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(optionsList.map(getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName)));
+        const callbackManagers = await Promise.all(optionsList.map(getCallbackManagerForConfig));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName ?? this.getName())));
         let outputs;
         try {
             outputs = await func(inputs, optionsList, runManagers, batchOptions);
@@ -195,16 +209,10 @@ export class Runnable extends Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        let runManager;
-        const serializedRepresentation = this.toJSON();
+        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const inputGeneratorWithSetup = new AsyncGeneratorWithSetup(inputGenerator, async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()));
         async function* wrapInputForTracing() {
-            for await (const chunk of inputGenerator) {
-                if (!runManager) {
-                    // Start the run manager AFTER the iterator starts to preserve
-                    // tracing order
-                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName);
-                }
+            for await (const chunk of inputGeneratorWithSetup) {
                 if (finalInputSupported) {
                     if (finalInput === undefined) {
                         finalInput = chunk;
@@ -212,7 +220,7 @@ export class Runnable extends Serializable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalInput = finalInput.concat(chunk);
+                            finalInput = concat(finalInput, chunk);
                         }
                         catch {
                             finalInput = undefined;
@@ -223,9 +231,8 @@ export class Runnable extends Serializable {
                 yield chunk;
             }
         }
-        const wrappedInputGenerator = wrapInputForTracing();
         try {
-            const outputIterator = transformer(wrappedInputGenerator, runManager, options);
+            const outputIterator = transformer(wrapInputForTracing(), inputGeneratorWithSetup.setup, options);
             for await (const chunk of outputIterator) {
                 yield chunk;
                 if (finalOutputSupported) {
@@ -235,7 +242,7 @@ export class Runnable extends Serializable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = finalOutput.concat(chunk);
+                            finalOutput = concat(finalOutput, chunk);
                         }
                         catch {
                             finalOutput = undefined;
@@ -246,14 +253,16 @@ export class Runnable extends Serializable {
             }
         }
         catch (e) {
+            const runManager = await inputGeneratorWithSetup.setup;
             await runManager?.handleChainError(e, undefined, undefined, undefined, {
                 inputs: _coerceToDict(finalInput, "input"),
             });
             throw e;
         }
+        const runManager = await inputGeneratorWithSetup.setup;
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
-    _patchConfig(config = {}, callbackManager = undefined) {
+    _patchConfig(config = {}, callbackManager = undefined, recursionLimit = undefined) {
         const newConfig = { ...config };
         if (callbackManager !== undefined) {
             /**
@@ -263,6 +272,9 @@ export class Runnable extends Serializable {
             delete newConfig.runName;
             return { ...newConfig, callbacks: callbackManager };
         }
+        if (recursionLimit !== undefined) {
+            newConfig.recursionLimit = recursionLimit;
+        }
         return newConfig;
     }
     /**
@@ -278,6 +290,23 @@ export class Runnable extends Serializable {
             last: _coerceToRunnable(coerceable),
         });
     }
+    /**
+     * Pick keys from the dict output of this runnable. Returns a new runnable.
+     */
+    pick(keys) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return this.pipe(new RunnablePick(keys));
+    }
+    /**
+     * Assigns new fields to the dict output of this runnable. Returns a new runnable.
+     */
+    assign(mapping) {
+        return this.pipe(
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        new RunnableAssign(
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        new RunnableMap({ steps: mapping })));
+    }
     /**
      * Default implementation of transform, which buffers input and then calls stream.
      * Subclasses should override this method if they can start producing output while
@@ -295,7 +324,7 @@ export class Runnable extends Serializable {
                 // Make a best effort to gather, for any type that supports concat.
                 // This method should throw an error if gathering fails.
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                finalChunk = finalChunk.concat(chunk);
+                finalChunk = concat(finalChunk, chunk);
             }
         }
         yield* this._streamIterator(finalChunk, options);
@@ -444,6 +473,9 @@ export class RunnableBinding extends Runnable {
         this.config = fields.config;
         this.configFactories = fields.configFactories;
     }
+    getName(suffix) {
+        return this.bound.getName(suffix);
+    }
     async _mergeConfig(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     options) {
@@ -453,21 +485,24 @@ export class RunnableBinding extends Runnable {
             : []));
     }
     bind(kwargs) {
-        return this.constructor({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new this.constructor({
             bound: this.bound,
             kwargs: { ...this.kwargs, ...kwargs },
             config: this.config,
         });
     }
     withConfig(config) {
-        return this.constructor({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new this.constructor({
             bound: this.bound,
             kwargs: this.kwargs,
             config: { ...this.config, ...config },
         });
     }
     withRetry(fields) {
-        return this.constructor({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        return new this.constructor({
             bound: this.bound.withRetry(fields),
             kwargs: this.kwargs,
             config: this.config,
@@ -766,12 +801,13 @@ export class RunnableSequence extends Runnable {
         this.first = fields.first;
         this.middle = fields.middle ?? this.middle;
         this.last = fields.last;
+        this.name = fields.name;
     }
     get steps() {
         return [this.first, ...this.middle, this.last];
     }
     async invoke(input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         let nextStepInput = input;
         let finalOutput;
@@ -793,7 +829,7 @@ export class RunnableSequence extends Runnable {
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map(getCallbackMangerForConfig));
+        const callbackManagers = await Promise.all(configList.map(getCallbackManagerForConfig));
         const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, undefined, undefined, undefined, configList[i].runName)));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
@@ -814,7 +850,7 @@ export class RunnableSequence extends Runnable {
         return finalOutputs;
     }
     async *_streamIterator(input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
         const steps = [this.first, ...this.middle, this.last];
         let concatSupported = true;
@@ -837,7 +873,7 @@ export class RunnableSequence extends Runnable {
                     else {
                         try {
                             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = finalOutput.concat(chunk);
+                            finalOutput = concat(finalOutput, chunk);
                         }
                         catch (e) {
                             finalOutput = undefined;
@@ -863,6 +899,7 @@ export class RunnableSequence extends Runnable {
                     ...coerceable.middle,
                 ]),
                 last: coerceable.last,
+                name: this.name ?? coerceable.name,
             });
         }
         else {
@@ -870,6 +907,7 @@ export class RunnableSequence extends Runnable {
                 first: this.first,
                 middle: [...this.middle, this.last],
                 last: _coerceToRunnable(coerceable),
+                name: this.name,
             });
         }
     }
@@ -878,11 +916,12 @@ export class RunnableSequence extends Runnable {
         return Array.isArray(thing.middle) && Runnable.isRunnable(thing);
     }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static from([first, ...runnables]) {
+    static from([first, ...runnables], name) {
         return new RunnableSequence({
             first: _coerceToRunnable(first),
             middle: runnables.slice(0, -1).map(_coerceToRunnable),
             last: _coerceToRunnable(runnables[runnables.length - 1]),
+            name,
         });
     }
 }
@@ -938,7 +977,7 @@ export class RunnableMap extends Runnable {
         return new RunnableMap({ steps });
     }
     async invoke(input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
         }, undefined, undefined, undefined, undefined, options?.runName);
@@ -946,7 +985,7 @@ export class RunnableMap extends Runnable {
         const output = {};
         try {
             await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => {
-                output[key] = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild(key)));
+                output[key] = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild(`map:key:${key}`)));
             }));
         }
         catch (e) {
@@ -956,6 +995,38 @@ export class RunnableMap extends Runnable {
         await runManager?.handleChainEnd(output);
         return output;
     }
+    async *_transform(generator, runManagerPromise, options) {
+        // shallow copy steps to ignore changes while iterating
+        const steps = { ...this.steps };
+        // each step gets a copy of the input iterator
+        const inputCopies = atee(generator, Object.keys(steps).length);
+        const runManager = await runManagerPromise;
+        // start the first iteration of each output iterator
+        const tasks = new Map(Object.entries(steps).map(([key, runnable], i) => {
+            const gen = runnable.transform(inputCopies[i], this._patchConfig(options, runManager?.getChild(`map:key:${key}`)));
+            return [key, gen.next().then((result) => ({ key, gen, result }))];
+        }));
+        // yield chunks as they become available,
+        // starting new iterations as needed,
+        // until all iterators are done
+        while (tasks.size) {
+            const { key, result, gen } = await Promise.race(tasks.values());
+            tasks.delete(key);
+            if (!result.done) {
+                yield { [key]: result.value };
+                tasks.set(key, gen.next().then((result) => ({ key, gen, result })));
+            }
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
 }
 /**
  * A runnable that runs a callable.
@@ -988,13 +1059,57 @@ export class RunnableLambda extends Runnable {
     async _invoke(input, config, runManager) {
         let output = await this.func(input, { config });
         if (output && Runnable.isRunnable(output)) {
-            output = await output.invoke(input, this._patchConfig(config, runManager?.getChild()));
+            if (config?.recursionLimit === 0) {
+                throw new Error("Recursion limit reached.");
+            }
+            output = await output.invoke(input, this._patchConfig(config, runManager?.getChild(), (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1));
         }
         return output;
     }
     async invoke(input, options) {
         return this._callWithConfig(this._invoke, input, options);
     }
+    async *_transform(generator, runManagerPromise, config) {
+        let finalChunk;
+        for await (const chunk of generator) {
+            if (finalChunk === undefined) {
+                finalChunk = chunk;
+            }
+            else {
+                // Make a best effort to gather, for any type that supports concat.
+                try {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    finalChunk = concat(finalChunk, chunk);
+                }
+                catch (e) {
+                    finalChunk = chunk;
+                }
+            }
+        }
+        const output = await this.func(finalChunk, { config });
+        if (output && Runnable.isRunnable(output)) {
+            if (config?.recursionLimit === 0) {
+                throw new Error("Recursion limit reached.");
+            }
+            const runManager = await runManagerPromise;
+            const stream = await output.stream(finalChunk, this._patchConfig(config, runManager?.getChild(), (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1));
+            for await (const chunk of stream) {
+                yield chunk;
+            }
+        }
+        else {
+            yield output;
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
 }
 export class RunnableParallel extends RunnableMap {
 }
@@ -1111,3 +1226,145 @@ export function _coerceToRunnable(coerceable) {
         throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`);
     }
 }
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+export class RunnableAssign extends Runnable {
+    static lc_name() {
+        return "RunnableAssign";
+    }
+    constructor(fields) {
+        // eslint-disable-next-line no-instanceof/no-instanceof
+        if (fields instanceof RunnableMap) {
+            // eslint-disable-next-line no-param-reassign
+            fields = { mapper: fields };
+        }
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "mapper", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.mapper = fields.mapper;
+    }
+    async invoke(input, options) {
+        const mapperResult = await this.mapper.invoke(input, options);
+        return {
+            ...input,
+            ...mapperResult,
+        };
+    }
+    async *_transform(generator, runManagerPromise, options) {
+        // collect mapper keys
+        const mapperKeys = this.mapper.getStepsKeys();
+        // create two input gens, one for the mapper, one for the input
+        const [forPassthrough, forMapper] = atee(generator);
+        const runManager = await runManagerPromise;
+        // create mapper output gen
+        const mapperOutput = this.mapper.transform(forMapper, this._patchConfig(options, runManager?.getChild()));
+        // start the mapper
+        const firstMapperChunkPromise = mapperOutput.next();
+        // yield the passthrough
+        for await (const chunk of forPassthrough) {
+            if (typeof chunk !== "object" || Array.isArray(chunk)) {
+                throw new Error(`RunnableAssign can only be used with objects as input, got ${typeof chunk}`);
+            }
+            const filtered = Object.fromEntries(Object.entries(chunk).filter(([key]) => !mapperKeys.includes(key)));
+            if (Object.keys(filtered).length > 0) {
+                yield filtered;
+            }
+        }
+        // yield the mapper output
+        yield (await firstMapperChunkPromise).value;
+        for await (const chunk of mapperOutput) {
+            yield chunk;
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
+}
+/**
+ * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
+ */
+export class RunnablePick extends Runnable {
+    static lc_name() {
+        return "RunnablePick";
+    }
+    constructor(fields) {
+        if (typeof fields === "string" || Array.isArray(fields)) {
+            // eslint-disable-next-line no-param-reassign
+            fields = { keys: fields };
+        }
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain_core", "runnables"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "keys", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.keys = fields.keys;
+    }
+    async _pick(input) {
+        if (typeof this.keys === "string") {
+            return input[this.keys];
+        }
+        else {
+            const picked = this.keys
+                .map((key) => [key, input[key]])
+                .filter((v) => v[1] !== undefined);
+            return picked.length === 0 ? undefined : Object.fromEntries(picked);
+        }
+    }
+    async invoke(input, options) {
+        return this._callWithConfig(this._pick.bind(this), input, options);
+    }
+    async *_transform(generator) {
+        for await (const chunk of generator) {
+            const picked = await this._pick(chunk);
+            if (picked !== undefined) {
+                yield picked;
+            }
+        }
+    }
+    transform(generator, options) {
+        return this._transformStreamWithConfig(generator, this._transform.bind(this), options);
+    }
+    async stream(input, options) {
+        async function* generator() {
+            yield input;
+        }
+        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+    }
+}

package/dist/runnables/config.cjs

@@ -1,11 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeConfigs = exports.getCallbackMangerForConfig = void 0;
+exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
 const manager_js_1 = require("../callbacks/manager.cjs");
-async function getCallbackMangerForConfig(config) {
+exports.DEFAULT_RECURSION_LIMIT = 25;
+async function getCallbackManagerForConfig(config) {
     return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
-exports.getCallbackMangerForConfig = getCallbackMangerForConfig;
+exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
 function mergeConfigs(config, 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 options) {
@@ -19,6 +20,9 @@ options) {
             else if (key === "tags") {
                 copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
             }
+            else if (key === "configurable") {
+                copy[key] = { ...copy[key], ...options[key] };
+            }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
                 const providedCallbacks = options.callbacks ?? config.callbacks;

package/dist/runnables/config.d.ts

@@ -1,4 +1,15 @@
 import { type BaseCallbackConfig, CallbackManager } from "../callbacks/manager.js";
-export type RunnableConfig = BaseCallbackConfig;
-export declare function getCallbackMangerForConfig(config?: RunnableConfig): Promise<CallbackManager | undefined>;
+export declare const DEFAULT_RECURSION_LIMIT = 25;
+export interface RunnableConfig extends BaseCallbackConfig {
+    /**
+     * Runtime values for attributes previously made configurable on this Runnable,
+     * or sub-Runnables.
+     */
+    configurable?: Record<string, any>;
+    /**
+     * Maximum number of times a call can recurse. If not provided, defaults to 25.
+     */
+    recursionLimit?: number;
+}
+export declare function getCallbackManagerForConfig(config?: RunnableConfig): Promise<CallbackManager | undefined>;
 export declare function mergeConfigs<CallOptions extends RunnableConfig>(config: RunnableConfig, options?: Record<string, any>): Partial<CallOptions>;

package/dist/runnables/config.js

@@ -1,5 +1,6 @@
 import { CallbackManager, } from "../callbacks/manager.js";
-export async function getCallbackMangerForConfig(config) {
+export const DEFAULT_RECURSION_LIMIT = 25;
+export async function getCallbackManagerForConfig(config) {
     return CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
 export function mergeConfigs(config, 
@@ -15,6 +16,9 @@ options) {
             else if (key === "tags") {
                 copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
             }
+            else if (key === "configurable") {
+                copy[key] = { ...copy[key], ...options[key] };
+            }
             else if (key === "callbacks") {
                 const baseCallbacks = copy.callbacks;
                 const providedCallbacks = options.callbacks ?? config.callbacks;

package/dist/runnables/history.cjs

@@ -93,16 +93,16 @@ class RunnableWithMessageHistory extends base_js_1.RunnableBinding {
         }
         throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(newOutputValue, null, 2)}`);
     }
-    _enterHistory(
+    async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
         const history = kwargs?.config?.configurable?.messageHistory;
         if (this.historyMessagesKey) {
-            return history.messages;
+            return history.getMessages();
         }
         const inputVal = input ||
             (this.inputMessagesKey ? input[this.inputMessagesKey] : undefined);
-        const historyMessages = history ? history.messages : [];
+        const historyMessages = history ? await history.getMessages() : [];
         const returnType = [
             ...historyMessages,
             ...this._getInputMessages(inputVal),

package/dist/runnables/history.d.ts

@@ -1,11 +1,10 @@
-import { BaseCallbackConfig } from "../callbacks/manager.js";
 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, BaseCallbackConfig>, "bound" | "config"> {
+export interface RunnableWithMessageHistoryInputs<RunInput, RunOutput> extends Omit<RunnableBindingArgs<RunInput, RunOutput>, "bound" | "config"> {
     runnable: Runnable<RunInput, RunOutput>;
     getMessageHistory: GetSessionHistoryCallable;
     inputMessagesKey?: string;
@@ -13,7 +12,7 @@ export interface RunnableWithMessageHistoryInputs<RunInput, RunOutput> extends O
     historyMessagesKey?: string;
     config?: RunnableConfig;
 }
-export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends RunnableBinding<RunInput, RunOutput, BaseCallbackConfig> {
+export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends RunnableBinding<RunInput, RunOutput> {
     runnable: Runnable<RunInput, RunOutput>;
     inputMessagesKey?: string;
     outputMessagesKey?: string;
@@ -24,8 +23,8 @@ export declare class RunnableWithMessageHistory<RunInput, RunOutput> extends Run
     _getOutputMessages(outputValue: string | BaseMessage | Array<BaseMessage> | Record<string, any>): Array<BaseMessage>;
     _enterHistory(input: any, kwargs?: {
         config?: RunnableConfig;
-    }): Array<BaseMessage>;
-    _exitHistory(run: Run, config: BaseCallbackConfig): Promise<void>;
-    _mergeConfig(...configs: Array<BaseCallbackConfig | undefined>): Promise<Partial<BaseCallbackConfig>>;
+    }): Promise<BaseMessage[]>;
+    _exitHistory(run: Run, config: RunnableConfig): Promise<void>;
+    _mergeConfig(...configs: Array<RunnableConfig | undefined>): Promise<Partial<RunnableConfig>>;
 }
 export {};

package/dist/runnables/history.js

@@ -90,16 +90,16 @@ export class RunnableWithMessageHistory extends RunnableBinding {
         }
         throw new Error(`Expected a string, BaseMessage, or array of BaseMessages. Received: ${JSON.stringify(newOutputValue, null, 2)}`);
     }
-    _enterHistory(
+    async _enterHistory(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     input, kwargs) {
         const history = kwargs?.config?.configurable?.messageHistory;
         if (this.historyMessagesKey) {
-            return history.messages;
+            return history.getMessages();
         }
         const inputVal = input ||
             (this.inputMessagesKey ? input[this.inputMessagesKey] : undefined);
-        const historyMessages = history ? history.messages : [];
+        const historyMessages = history ? await history.getMessages() : [];
         const returnType = [
             ...historyMessages,
             ...this._getInputMessages(inputVal),