@langchain/core 0.1.14 → 0.1.16

package/dist/runnables/base.js

@@ -3,7 +3,7 @@ import { CallbackManager, } from "../callbacks/manager.js";
 import { LogStreamCallbackHandler, RunLogPatch, } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, } from "../utils/stream.js";
-import { DEFAULT_RECURSION_LIMIT, getCallbackManagerForConfig, mergeConfigs, } from "./config.js";
+import { DEFAULT_RECURSION_LIMIT, ensureConfig, getCallbackManagerForConfig, mergeConfigs, patchConfig, } 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
@@ -105,14 +105,15 @@ export class Runnable extends Serializable {
             if (options.length !== length) {
                 throw new Error(`Passed "options" must be an array with the same length as the inputs, but got ${options.length} options for ${length} inputs`);
             }
-            return options;
+            return options.map(ensureConfig);
         }
-        return Array.from({ length }, () => options);
+        return Array.from({ length }, () => ensureConfig(options));
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
+        const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
         const caller = new AsyncCaller({
-            maxConcurrency: batchOptions?.maxConcurrency,
+            maxConcurrency,
             onFailedAttempt: (e) => {
                 throw e;
             },
@@ -150,27 +151,32 @@ export class Runnable extends Serializable {
         return IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
     }
     _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = {
+        const runnableConfig = ensureConfig({
             callbacks: options.callbacks,
             tags: options.tags,
             metadata: options.metadata,
             runName: options.runName,
             configurable: options.configurable,
-        };
+            recursionLimit: options.recursionLimit,
+            maxConcurrency: options.maxConcurrency,
+        });
         const callOptions = { ...options };
         delete callOptions.callbacks;
         delete callOptions.tags;
         delete callOptions.metadata;
         delete callOptions.runName;
         delete callOptions.configurable;
+        delete callOptions.recursionLimit;
+        delete callOptions.maxConcurrency;
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await getCallbackManagerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName());
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName());
         let output;
         try {
-            output = await func.bind(this)(input, options, runManager);
+            output = await func.call(this, input, config, runManager);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -194,7 +200,7 @@ export class Runnable extends Serializable {
         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);
+            outputs = await func.call(this, inputs, optionsList, runManagers, batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
@@ -213,7 +219,8 @@ export class Runnable extends Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await getCallbackManagerForConfig(options);
+        const config = ensureConfig(options);
+        const callbackManager_ = await getCallbackManagerForConfig(config);
         async function* wrapInputForTracing() {
             for await (const chunk of inputGenerator) {
                 if (finalInputSupported) {
@@ -236,9 +243,15 @@ export class Runnable extends Serializable {
         }
         let runManager;
         try {
-            const pipe = await pipeGeneratorWithSetup(transformer, wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()), options);
+            const pipe = await pipeGeneratorWithSetup(transformer.bind(this), wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, config?.runType, undefined, undefined, config?.runName ?? this.getName()), config);
             runManager = pipe.setup;
-            for await (const chunk of pipe.output) {
+            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);
+            }
+            for await (const chunk of iterator) {
                 yield chunk;
                 if (finalOutputSupported) {
                     if (finalOutput === undefined) {
@@ -265,21 +278,6 @@ export class Runnable extends Serializable {
         }
         await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
     }
-    _patchConfig(config = {}, callbackManager = undefined, recursionLimit = undefined) {
-        const newConfig = { ...config };
-        if (callbackManager !== undefined) {
-            /**
-             * If we're replacing callbacks we need to unset runName
-             * since that should apply only to the same run as the original callbacks
-             */
-            delete newConfig.runName;
-            return { ...newConfig, callbacks: callbackManager };
-        }
-        if (recursionLimit !== undefined) {
-            newConfig.recursionLimit = recursionLimit;
-        }
-        return newConfig;
-    }
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
      * piping the output of one runnable into another runnable or runnable-like.
@@ -348,7 +346,7 @@ export class Runnable extends Serializable {
             ...streamOptions,
             autoClose: false,
         });
-        const config = options ?? {};
+        const config = ensureConfig(options);
         const { callbacks } = config;
         if (callbacks === undefined) {
             config.callbacks = [stream];
@@ -479,10 +477,8 @@ export class RunnableBinding extends Runnable {
     getName(suffix) {
         return this.bound.getName(suffix);
     }
-    async _mergeConfig(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    options) {
-        const config = mergeConfigs(this.config, options);
+    async _mergeConfig(...options) {
+        const config = mergeConfigs(this.config, ...options);
         return mergeConfigs(config, ...(this.configFactories
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
@@ -512,27 +508,24 @@ export class RunnableBinding extends Runnable {
         });
     }
     async invoke(input, options) {
-        return this.bound.invoke(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        return this.bound.invoke(input, await this._mergeConfig(options, this.kwargs));
     }
     async batch(inputs, options, batchOptions) {
         const mergedOptions = Array.isArray(options)
-            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig({
-                ...individualOption,
-                ...this.kwargs,
-            })))
-            : await this._mergeConfig({ ...options, ...this.kwargs });
+            ? await Promise.all(options.map(async (individualOption) => this._mergeConfig(individualOption, this.kwargs)))
+            : await this._mergeConfig(options, this.kwargs);
         return this.bound.batch(inputs, mergedOptions, batchOptions);
     }
     async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        yield* this.bound._streamIterator(input, await this._mergeConfig(options, this.kwargs));
     }
     async stream(input, options) {
-        return this.bound.stream(input, await this._mergeConfig({ ...options, ...this.kwargs }));
+        return this.bound.stream(input, await this._mergeConfig(options, this.kwargs));
     }
     async *transform(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     generator, options) {
-        yield* this.bound.transform(generator, await this._mergeConfig({ ...options, ...this.kwargs }));
+        yield* this.bound.transform(generator, await this._mergeConfig(options, this.kwargs));
     }
     static isRunnableBinding(
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -604,7 +597,7 @@ export class RunnableEach extends Runnable {
     }
     /**
      * Binds the runnable with the specified arguments.
-     * @param args The arguments to bind the runnable with.
+     * @param kwargs The arguments to bind the runnable with.
      * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
      */
     bind(kwargs) {
@@ -628,7 +621,7 @@ export class RunnableEach extends Runnable {
      * @returns A promise that resolves to the output of the runnable.
      */
     async _invoke(inputs, config, runManager) {
-        return this.bound.batch(inputs, this._patchConfig(config, runManager?.getChild()));
+        return this.bound.batch(inputs, patchConfig(config, { callbacks: runManager?.getChild() }));
     }
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -681,7 +674,7 @@ export class RunnableRetry extends RunnableBinding {
     }
     _patchConfigForRetry(attempt, config, runManager) {
         const tag = attempt > 1 ? `retry:attempt:${attempt}` : undefined;
-        return this._patchConfig(config, runManager?.getChild(tag));
+        return patchConfig(config, { callbacks: runManager?.getChild(tag) });
     }
     async _invoke(input, config, runManager) {
         return pRetry((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
@@ -818,10 +811,14 @@ export class RunnableSequence extends Runnable {
             const initialSteps = [this.first, ...this.middle];
             for (let i = 0; i < initialSteps.length; i += 1) {
                 const step = initialSteps[i];
-                nextStepInput = await step.invoke(nextStepInput, this._patchConfig(options, runManager?.getChild(`seq:step:${i + 1}`)));
+                nextStepInput = await step.invoke(nextStepInput, patchConfig(options, {
+                    callbacks: runManager?.getChild(`seq:step:${i + 1}`),
+                }));
             }
             // TypeScript can't detect that the last output of the sequence returns RunOutput, so call it out of the loop here
-            finalOutput = await this.last.invoke(nextStepInput, this._patchConfig(options, runManager?.getChild(`seq:step:${this.steps.length}`)));
+            finalOutput = await this.last.invoke(nextStepInput, patchConfig(options, {
+                callbacks: runManager?.getChild(`seq:step:${this.steps.length}`),
+            }));
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -836,21 +833,21 @@ export class RunnableSequence extends Runnable {
         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;
-        let finalOutputs;
         try {
-            const initialSteps = [this.first, ...this.middle];
-            for (let i = 0; i < initialSteps.length; i += 1) {
-                const step = initialSteps[i];
-                nextStepInputs = await step.batch(nextStepInputs, runManagers.map((runManager, j) => this._patchConfig(configList[j], runManager?.getChild(`seq:step:${i + 1}`))), batchOptions);
+            for (let i = 0; i < this.steps.length; i += 1) {
+                const step = this.steps[i];
+                nextStepInputs = await step.batch(nextStepInputs, runManagers.map((runManager, j) => {
+                    const childRunManager = runManager?.getChild(`seq:step:${i + 1}`);
+                    return patchConfig(configList[j], { callbacks: childRunManager });
+                }), batchOptions);
             }
-            finalOutputs = await this.last.batch(nextStepInputs, runManagers.map((runManager) => this._patchConfig(configList[this.steps.length - 1], runManager?.getChild(`seq:step:${this.steps.length}`))), batchOptions);
         }
         catch (e) {
             await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
             throw e;
         }
-        await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(finalOutputs[i], "output"))));
-        return finalOutputs;
+        await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(nextStepInputs, "output"))));
+        return nextStepInputs;
     }
     async *_streamIterator(input, options) {
         const callbackManager_ = await getCallbackManagerForConfig(options);
@@ -862,10 +859,14 @@ export class RunnableSequence extends Runnable {
             yield input;
         }
         try {
-            let finalGenerator = steps[0].transform(inputGenerator(), this._patchConfig(options, runManager?.getChild(`seq:step:1`)));
+            let finalGenerator = steps[0].transform(inputGenerator(), patchConfig(options, {
+                callbacks: runManager?.getChild(`seq:step:1`),
+            }));
             for (let i = 1; i < steps.length; i += 1) {
                 const step = steps[i];
-                finalGenerator = await step.transform(finalGenerator, this._patchConfig(options, runManager?.getChild(`seq:step:${i + 1}`)));
+                finalGenerator = await step.transform(finalGenerator, patchConfig(options, {
+                    callbacks: runManager?.getChild(`seq:step:${i + 1}`),
+                }));
             }
             for await (const chunk of finalGenerator) {
                 yield chunk;
@@ -988,7 +989,9 @@ 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(`map:key:${key}`)));
+                output[key] = await runnable.invoke(input, patchConfig(options, {
+                    callbacks: runManager?.getChild(`map:key:${key}`),
+                }));
             }));
         }
         catch (e) {
@@ -1005,7 +1008,9 @@ export class RunnableMap extends Runnable {
         const inputCopies = atee(generator, Object.keys(steps).length);
         // 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}`)));
+            const gen = runnable.transform(inputCopies[i], patchConfig(options, {
+                callbacks: runManager?.getChild(`map:key:${key}`),
+            }));
             return [key, gen.next().then((result) => ({ key, gen, result }))];
         }));
         // yield chunks as they become available,
@@ -1064,7 +1069,10 @@ export class RunnableLambda extends Runnable {
             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));
+            output = await output.invoke(input, patchConfig(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+            }));
         }
         return output;
     }
@@ -1093,7 +1101,10 @@ export class RunnableLambda extends Runnable {
             if (config?.recursionLimit === 0) {
                 throw new Error("Recursion limit reached.");
             }
-            const stream = await output.stream(finalChunk, this._patchConfig(config, runManager?.getChild(), (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1));
+            const stream = await output.stream(finalChunk, patchConfig(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? DEFAULT_RECURSION_LIMIT) - 1,
+            }));
             for await (const chunk of stream) {
                 yield chunk;
             }
@@ -1162,7 +1173,7 @@ export class RunnableWithFallbacks extends Runnable {
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const output = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild()));
+                const output = await runnable.invoke(input, patchConfig(options, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1189,7 +1200,9 @@ export class RunnableWithFallbacks extends Runnable {
         let firstError;
         for (const runnable of this.runnables()) {
             try {
-                const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => this._patchConfig(configList[j], runManager?.getChild())), batchOptions);
+                const outputs = await runnable.batch(inputs, runManagers.map((runManager, j) => patchConfig(configList[j], {
+                    callbacks: runManager?.getChild(),
+                })), batchOptions);
                 await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(outputs[i], "output"))));
                 return outputs;
             }
@@ -1274,7 +1287,7 @@ export class RunnableAssign extends Runnable {
         // create two input gens, one for the mapper, one for the input
         const [forPassthrough, forMapper] = atee(generator);
         // create mapper output gen
-        const mapperOutput = this.mapper.transform(forMapper, this._patchConfig(options, runManager?.getChild()));
+        const mapperOutput = this.mapper.transform(forMapper, patchConfig(options, { callbacks: runManager?.getChild() }));
         // start the mapper
         const firstMapperChunkPromise = mapperOutput.next();
         // yield the passthrough

package/dist/runnables/branch.cjs

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RunnableBranch = void 0;
 const base_js_1 = require("./base.cjs");
+const config_js_1 = require("./config.cjs");
 /**
  * Class that represents a runnable branch. The RunnableBranch is
  * initialized with an array of branches and a default branch. When invoked,
@@ -116,14 +117,20 @@ class RunnableBranch extends base_js_1.Runnable {
         let result;
         for (let i = 0; i < this.branches.length; i += 1) {
             const [condition, branchRunnable] = this.branches[i];
-            const conditionValue = await condition.invoke(input, this._patchConfig(config, runManager?.getChild(`condition:${i + 1}`)));
+            const conditionValue = await condition.invoke(input, (0, config_js_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(`condition:${i + 1}`),
+            }));
             if (conditionValue) {
-                result = await branchRunnable.invoke(input, this._patchConfig(config, runManager?.getChild(`branch:${i + 1}`)));
+                result = await branchRunnable.invoke(input, (0, config_js_1.patchConfig)(config, {
+                    callbacks: runManager?.getChild(`branch:${i + 1}`),
+                }));
                 break;
             }
         }
         if (!result) {
-            result = await this.default.invoke(input, this._patchConfig(config, runManager?.getChild("default")));
+            result = await this.default.invoke(input, (0, config_js_1.patchConfig)(config, {
+                callbacks: runManager?.getChild("default"),
+            }));
         }
         return result;
     }

package/dist/runnables/branch.js

@@ -1,4 +1,5 @@
 import { Runnable, _coerceToRunnable } from "./base.js";
+import { patchConfig } from "./config.js";
 /**
  * Class that represents a runnable branch. The RunnableBranch is
  * initialized with an array of branches and a default branch. When invoked,
@@ -113,14 +114,20 @@ export class RunnableBranch extends Runnable {
         let result;
         for (let i = 0; i < this.branches.length; i += 1) {
             const [condition, branchRunnable] = this.branches[i];
-            const conditionValue = await condition.invoke(input, this._patchConfig(config, runManager?.getChild(`condition:${i + 1}`)));
+            const conditionValue = await condition.invoke(input, patchConfig(config, {
+                callbacks: runManager?.getChild(`condition:${i + 1}`),
+            }));
             if (conditionValue) {
-                result = await branchRunnable.invoke(input, this._patchConfig(config, runManager?.getChild(`branch:${i + 1}`)));
+                result = await branchRunnable.invoke(input, patchConfig(config, {
+                    callbacks: runManager?.getChild(`branch:${i + 1}`),
+                }));
                 break;
             }
         }
         if (!result) {
-            result = await this.default.invoke(input, this._patchConfig(config, runManager?.getChild("default")));
+            result = await this.default.invoke(input, patchConfig(config, {
+                callbacks: runManager?.getChild("default"),
+            }));
         }
         return result;
     }

package/dist/runnables/config.cjs

@@ -1,31 +1,29 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
+exports.patchConfig = exports.ensureConfig = exports.mergeConfigs = exports.getCallbackManagerForConfig = exports.DEFAULT_RECURSION_LIMIT = void 0;
 const manager_js_1 = require("../callbacks/manager.cjs");
 exports.DEFAULT_RECURSION_LIMIT = 25;
 async function getCallbackManagerForConfig(config) {
     return manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata);
 }
 exports.getCallbackManagerForConfig = getCallbackManagerForConfig;
-function mergeConfigs(config, 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-options) {
+function mergeConfigs(...configs) {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const copy = { ...config };
-    if (options) {
+    const copy = ensureConfig();
+    for (const options of configs.filter((c) => !!c)) {
         for (const key of Object.keys(options)) {
             if (key === "metadata") {
                 copy[key] = { ...copy[key], ...options[key] };
             }
             else if (key === "tags") {
-                copy[key] = (copy[key] ?? []).concat(options[key] ?? []);
+                copy[key] = [...new Set(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;
+                const providedCallbacks = options.callbacks;
                 // callbacks can be either undefined, Array<handler> or manager
                 // so merging two callbacks values has 6 cases
                 if (Array.isArray(providedCallbacks)) {
@@ -39,7 +37,7 @@ options) {
                         // baseCallbacks is a manager
                         const manager = baseCallbacks.copy();
                         for (const callback of providedCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler((0, manager_js_1.ensureHandler)(callback), true);
                         }
                         copy.callbacks = manager;
                     }
@@ -52,13 +50,13 @@ options) {
                     else if (Array.isArray(baseCallbacks)) {
                         const manager = providedCallbacks.copy();
                         for (const callback of baseCallbacks) {
-                            manager.addHandler(callback, true);
+                            manager.addHandler((0, manager_js_1.ensureHandler)(callback), true);
                         }
                         copy.callbacks = manager;
                     }
                     else {
                         // baseCallbacks is also a manager
-                        copy.callbacks = new manager_js_1.CallbackManager(providedCallbacks.parentRunId, {
+                        copy.callbacks = new manager_js_1.CallbackManager(providedCallbacks._parentRunId, {
                             handlers: baseCallbacks.handlers.concat(providedCallbacks.handlers),
                             inheritableHandlers: baseCallbacks.inheritableHandlers.concat(providedCallbacks.inheritableHandlers),
                             tags: Array.from(new Set(baseCallbacks.tags.concat(providedCallbacks.tags))),
@@ -72,10 +70,67 @@ options) {
                 }
             }
             else {
-                copy[key] = options[key] ?? copy[key];
+                const typedKey = key;
+                copy[typedKey] = options[typedKey] ?? copy[typedKey];
             }
         }
     }
     return copy;
 }
 exports.mergeConfigs = mergeConfigs;
+const PRIMITIVES = new Set(["string", "number", "boolean"]);
+/**
+ * Ensure that a passed config is an object with all required keys present.
+ */
+function ensureConfig(config) {
+    let empty = {
+        tags: [],
+        metadata: {},
+        callbacks: undefined,
+        recursionLimit: 25,
+    };
+    if (config) {
+        empty = { ...empty, ...config };
+    }
+    if (config?.configurable) {
+        for (const key of Object.keys(config.configurable)) {
+            if (PRIMITIVES.has(typeof config.configurable[key]) &&
+                !empty.metadata?.[key]) {
+                if (!empty.metadata) {
+                    empty.metadata = {};
+                }
+                empty.metadata[key] = config.configurable[key];
+            }
+        }
+    }
+    return empty;
+}
+exports.ensureConfig = ensureConfig;
+/**
+ * Helper function that patches runnable configs with updated properties.
+ */
+function patchConfig(config = {}, { callbacks, maxConcurrency, recursionLimit, runName, configurable, } = {}) {
+    const newConfig = ensureConfig(config);
+    if (callbacks !== undefined) {
+        /**
+         * If we're replacing callbacks we need to unset runName
+         * since that should apply only to the same run as the original callbacks
+         */
+        delete newConfig.runName;
+        newConfig.callbacks = callbacks;
+    }
+    if (recursionLimit !== undefined) {
+        newConfig.recursionLimit = recursionLimit;
+    }
+    if (maxConcurrency !== undefined) {
+        newConfig.maxConcurrency = maxConcurrency;
+    }
+    if (runName !== undefined) {
+        newConfig.runName = runName;
+    }
+    if (configurable !== undefined) {
+        newConfig.configurable = { ...newConfig.configurable, ...configurable };
+    }
+    return newConfig;
+}
+exports.patchConfig = patchConfig;

package/dist/runnables/config.d.ts

@@ -10,6 +10,16 @@ export interface RunnableConfig extends BaseCallbackConfig {
      * Maximum number of times a call can recurse. If not provided, defaults to 25.
      */
     recursionLimit?: number;
+    /** Maximum number of parallel calls to make. */
+    maxConcurrency?: 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>;
+export declare function mergeConfigs<CallOptions extends RunnableConfig>(...configs: (CallOptions | RunnableConfig | undefined | null)[]): Partial<CallOptions>;
+/**
+ * Ensure that a passed config is an object with all required keys present.
+ */
+export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): CallOptions;
+/**
+ * Helper function that patches runnable configs with updated properties.
+ */
+export declare function patchConfig<CallOptions extends RunnableConfig>(config?: Partial<CallOptions>, { callbacks, maxConcurrency, recursionLimit, runName, configurable, }?: RunnableConfig): Partial<CallOptions>;