@langchain/core 0.1.14 → 0.1.16

package/dist/callbacks/manager.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.traceAsGroup = exports.TraceGroup = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0;
+exports.traceAsGroup = exports.TraceGroup = exports.ensureHandler = exports.CallbackManager = exports.CallbackManagerForToolRun = exports.CallbackManagerForChainRun = exports.CallbackManagerForLLMRun = exports.CallbackManagerForRetrieverRun = exports.BaseCallbackManager = exports.parseCallbackConfigArg = void 0;
 const uuid_1 = require("uuid");
 const base_js_1 = require("./base.cjs");
 const console_js_1 = require("../tracers/console.cjs");
@@ -571,6 +571,7 @@ function ensureHandler(handler) {
     }
     return base_js_1.BaseCallbackHandler.fromMethods(handler);
 }
+exports.ensureHandler = ensureHandler;
 /**
  * @example
  * ```typescript

package/dist/callbacks/manager.d.ts

@@ -50,7 +50,7 @@ export declare abstract class BaseCallbackManager {
  */
 declare class BaseRunManager {
     readonly runId: string;
-    protected readonly handlers: BaseCallbackHandler[];
+    readonly handlers: BaseCallbackHandler[];
     protected readonly inheritableHandlers: BaseCallbackHandler[];
     protected readonly tags: string[];
     protected readonly inheritableTags: string[];
@@ -115,7 +115,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     metadata: Record<string, unknown>;
     inheritableMetadata: Record<string, unknown>;
     name: string;
-    private readonly _parentRunId?;
+    readonly _parentRunId?: string;
     constructor(parentRunId?: string, options?: {
         handlers?: BaseCallbackHandler[];
         inheritableHandlers?: BaseCallbackHandler[];
@@ -140,6 +140,7 @@ export declare class CallbackManager extends BaseCallbackManager implements Base
     static fromHandlers(handlers: CallbackHandlerMethods): CallbackManager;
     static configure(inheritableHandlers?: Callbacks, localHandlers?: Callbacks, inheritableTags?: string[], localTags?: string[], inheritableMetadata?: Record<string, unknown>, localMetadata?: Record<string, unknown>, options?: CallbackManagerOptions): Promise<CallbackManager | undefined>;
 }
+export declare function ensureHandler(handler: BaseCallbackHandler | CallbackHandlerMethods): BaseCallbackHandler;
 /**
  * @example
  * ```typescript

package/dist/callbacks/manager.js

@@ -555,7 +555,7 @@ export class CallbackManager extends BaseCallbackManager {
         return callbackManager;
     }
 }
-function ensureHandler(handler) {
+export function ensureHandler(handler) {
     if ("name" in handler) {
         return handler;
     }

package/dist/language_models/base.d.ts

@@ -3,7 +3,7 @@ import { type BaseCache } from "../caches.js";
 import { type BasePromptValueInterface } from "../prompt_values.js";
 import { type BaseMessage, type BaseMessageLike, type MessageContent } from "../messages/index.js";
 import { type LLMResult } from "../outputs.js";
-import { BaseCallbackConfig, CallbackManager, Callbacks } from "../callbacks/manager.js";
+import { CallbackManager, Callbacks } from "../callbacks/manager.js";
 import { AsyncCaller, AsyncCallerParams } from "../utils/async_caller.js";
 import { Runnable, type RunnableInterface } from "../runnables/base.js";
 import { RunnableConfig } from "../runnables/config.js";
@@ -53,7 +53,7 @@ export interface BaseLanguageModelParams extends AsyncCallerParams, BaseLangChai
     callbackManager?: CallbackManager;
     cache?: BaseCache | boolean;
 }
-export interface BaseLanguageModelCallOptions extends BaseCallbackConfig {
+export interface BaseLanguageModelCallOptions extends RunnableConfig {
     /**
      * Stop tokens to use for this call.
      * If not provided, the default stop tokens for the model will be used.

package/dist/retrievers.cjs

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseRetriever = void 0;
 const manager_js_1 = require("./callbacks/manager.cjs");
 const base_js_1 = require("./runnables/base.cjs");
+const config_js_1 = require("./runnables/config.cjs");
 /**
  * Abstract base class for a Document retrieval system. A retrieval system
  * is defined as something that can take string queries and return the
@@ -62,7 +63,7 @@ class BaseRetriever extends base_js_1.Runnable {
      * @returns A promise that resolves to an array of `Document` objects.
      */
     async getRelevantDocuments(query, config) {
-        const parsedConfig = (0, manager_js_1.parseCallbackConfigArg)(config);
+        const parsedConfig = (0, config_js_1.ensureConfig)((0, manager_js_1.parseCallbackConfigArg)(config));
         const callbackManager_ = await manager_js_1.CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
         const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
         try {

package/dist/retrievers.js

@@ -1,5 +1,6 @@
 import { CallbackManager, parseCallbackConfigArg, } from "./callbacks/manager.js";
 import { Runnable } from "./runnables/base.js";
+import { ensureConfig } from "./runnables/config.js";
 /**
  * Abstract base class for a Document retrieval system. A retrieval system
  * is defined as something that can take string queries and return the
@@ -59,7 +60,7 @@ export class BaseRetriever extends Runnable {
      * @returns A promise that resolves to an array of `Document` objects.
      */
     async getRelevantDocuments(query, config) {
-        const parsedConfig = parseCallbackConfigArg(config);
+        const parsedConfig = ensureConfig(parseCallbackConfigArg(config));
         const callbackManager_ = await CallbackManager.configure(parsedConfig.callbacks, this.callbacks, parsedConfig.tags, this.tags, parsedConfig.metadata, this.metadata, { verbose: this.verbose });
         const runManager = await callbackManager_?.handleRetrieverStart(this.toJSON(), query, undefined, undefined, undefined, undefined, parsedConfig.runName);
         try {

package/dist/runnables/base.cjs

@@ -111,14 +111,15 @@ class Runnable extends serializable_js_1.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(config_js_1.ensureConfig);
         }
-        return Array.from({ length }, () => options);
+        return Array.from({ length }, () => (0, config_js_1.ensureConfig)(options));
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
+        const maxConcurrency = configList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
         const caller = new async_caller_js_1.AsyncCaller({
-            maxConcurrency: batchOptions?.maxConcurrency,
+            maxConcurrency,
             onFailedAttempt: (e) => {
                 throw e;
             },
@@ -156,27 +157,32 @@ class Runnable extends serializable_js_1.Serializable {
         return stream_js_1.IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
     }
     _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = {
+        const runnableConfig = (0, config_js_1.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 (0, config_js_1.getCallbackManagerForConfig)(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName());
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.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);
@@ -200,7 +206,7 @@ class Runnable extends serializable_js_1.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)));
@@ -219,7 +225,8 @@ class Runnable extends serializable_js_1.Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(options);
+        const config = (0, config_js_1.ensureConfig)(options);
+        const callbackManager_ = await (0, config_js_1.getCallbackManagerForConfig)(config);
         async function* wrapInputForTracing() {
             for await (const chunk of inputGenerator) {
                 if (finalInputSupported) {
@@ -242,9 +249,15 @@ class Runnable extends serializable_js_1.Serializable {
         }
         let runManager;
         try {
-            const pipe = await (0, stream_js_1.pipeGeneratorWithSetup)(transformer, wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()), options);
+            const pipe = await (0, stream_js_1.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) {
@@ -271,21 +284,6 @@ class Runnable extends serializable_js_1.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.
@@ -354,7 +352,7 @@ class Runnable extends serializable_js_1.Serializable {
             ...streamOptions,
             autoClose: false,
         });
-        const config = options ?? {};
+        const config = (0, config_js_1.ensureConfig)(options);
         const { callbacks } = config;
         if (callbacks === undefined) {
             config.callbacks = [stream];
@@ -486,10 +484,8 @@ 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 = (0, config_js_1.mergeConfigs)(this.config, options);
+    async _mergeConfig(...options) {
+        const config = (0, config_js_1.mergeConfigs)(this.config, ...options);
         return (0, config_js_1.mergeConfigs)(config, ...(this.configFactories
             ? await Promise.all(this.configFactories.map(async (configFactory) => await configFactory(config)))
             : []));
@@ -519,27 +515,24 @@ 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
@@ -612,7 +605,7 @@ 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) {
@@ -636,7 +629,7 @@ 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, (0, config_js_1.patchConfig)(config, { callbacks: runManager?.getChild() }));
     }
     /**
      * Bind lifecycle listeners to a Runnable, returning a new Runnable.
@@ -690,7 +683,7 @@ class RunnableRetry extends RunnableBinding {
     }
     _patchConfigForRetry(attempt, config, runManager) {
         const tag = attempt > 1 ? `retry:attempt:${attempt}` : undefined;
-        return this._patchConfig(config, runManager?.getChild(tag));
+        return (0, config_js_1.patchConfig)(config, { callbacks: runManager?.getChild(tag) });
     }
     async _invoke(input, config, runManager) {
         return (0, p_retry_1.default)((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
@@ -828,10 +821,14 @@ 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, (0, config_js_1.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, (0, config_js_1.patchConfig)(options, {
+                callbacks: runManager?.getChild(`seq:step:${this.steps.length}`),
+            }));
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -846,21 +843,21 @@ 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 (0, config_js_1.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 (0, config_js_1.getCallbackManagerForConfig)(options);
@@ -872,10 +869,14 @@ 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(), (0, config_js_1.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, (0, config_js_1.patchConfig)(options, {
+                    callbacks: runManager?.getChild(`seq:step:${i + 1}`),
+                }));
             }
             for await (const chunk of finalGenerator) {
                 yield chunk;
@@ -999,7 +1000,9 @@ 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, (0, config_js_1.patchConfig)(options, {
+                    callbacks: runManager?.getChild(`map:key:${key}`),
+                }));
             }));
         }
         catch (e) {
@@ -1016,7 +1019,9 @@ class RunnableMap extends Runnable {
         const inputCopies = (0, stream_js_1.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], (0, config_js_1.patchConfig)(options, {
+                callbacks: runManager?.getChild(`map:key:${key}`),
+            }));
             return [key, gen.next().then((result) => ({ key, gen, result }))];
         }));
         // yield chunks as they become available,
@@ -1076,7 +1081,10 @@ 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 ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1));
+            output = await output.invoke(input, (0, config_js_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+            }));
         }
         return output;
     }
@@ -1105,7 +1113,10 @@ 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 ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1));
+            const stream = await output.stream(finalChunk, (0, config_js_1.patchConfig)(config, {
+                callbacks: runManager?.getChild(),
+                recursionLimit: (config?.recursionLimit ?? config_js_1.DEFAULT_RECURSION_LIMIT) - 1,
+            }));
             for await (const chunk of stream) {
                 yield chunk;
             }
@@ -1176,7 +1187,7 @@ 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, (0, config_js_1.patchConfig)(options, { callbacks: runManager?.getChild() }));
                 await runManager?.handleChainEnd(_coerceToDict(output, "output"));
                 return output;
             }
@@ -1203,7 +1214,9 @@ 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) => (0, config_js_1.patchConfig)(configList[j], {
+                    callbacks: runManager?.getChild(),
+                })), batchOptions);
                 await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(outputs[i], "output"))));
                 return outputs;
             }
@@ -1290,7 +1303,7 @@ class RunnableAssign extends Runnable {
         // create two input gens, one for the mapper, one for the input
         const [forPassthrough, forMapper] = (0, stream_js_1.atee)(generator);
         // create mapper output gen
-        const mapperOutput = this.mapper.transform(forMapper, this._patchConfig(options, runManager?.getChild()));
+        const mapperOutput = this.mapper.transform(forMapper, (0, config_js_1.patchConfig)(options, { callbacks: runManager?.getChild() }));
         // start the mapper
         const firstMapperChunkPromise = mapperOutput.next();
         // yield the passthrough

package/dist/runnables/base.d.ts

@@ -1,4 +1,4 @@
-import { CallbackManager, CallbackManagerForChainRun } from "../callbacks/manager.js";
+import { CallbackManagerForChainRun } from "../callbacks/manager.js";
 import { LogStreamCallbackHandlerInput, RunLogPatch } from "../tracers/log_stream.js";
 import { Serializable } from "../load/serializable.js";
 import { IterableReadableStream, type IterableReadableStreamInterface } from "../utils/stream.js";
@@ -33,6 +33,7 @@ export type RunnableMapLike<RunInput, RunOutput> = {
 };
 export type RunnableLike<RunInput = any, RunOutput = any> = RunnableInterface<RunInput, RunOutput> | RunnableFunc<RunInput, RunOutput> | RunnableMapLike<RunInput, RunOutput>;
 export type RunnableBatchOptions = {
+    /** @deprecated Pass in via the standard runnable config object instead */
     maxConcurrency?: number;
     returnExceptions?: boolean;
 };
@@ -81,15 +82,14 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
     withFallbacks(fields: {
         fallbacks: Runnable<RunInput, RunOutput>[];
     }): RunnableWithFallbacks<RunInput, RunOutput>;
-    protected _getOptionsList(options: Partial<CallOptions> | Partial<CallOptions>[], length?: number): Partial<CallOptions & {
+    protected _getOptionsList<O extends CallOptions & {
         runType?: string;
-    }>[];
+    }>(options: Partial<O> | Partial<O>[], length?: number): Partial<O>[];
     /**
      * Default implementation of batch, which calls invoke N times.
      * Subclasses should override this method if they can batch more efficiently.
      * @param inputs Array of inputs to each batch call.
      * @param options Either a single call options object to apply to each batch call or an array for each call.
-     * @param batchOptions.maxConcurrency Maximum number of calls to run at once.
      * @param batchOptions.returnExceptions Whether to return errors rather than throwing on the first one
      * @returns An array of RunOutputs, or mixed RunOutputs and errors if batchOptions.returnExceptions is set
      */
@@ -140,7 +140,6 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
     protected _transformStreamWithConfig<I extends RunInput, O extends RunOutput>(inputGenerator: AsyncGenerator<I>, transformer: (generator: AsyncGenerator<I>, runManager?: CallbackManagerForChainRun, options?: Partial<CallOptions>) => AsyncGenerator<O>, options?: CallOptions & {
         runType?: string;
     }): AsyncGenerator<O>;
-    _patchConfig(config?: Partial<CallOptions>, callbackManager?: CallbackManager | undefined, recursionLimit?: number | undefined): Partial<CallOptions>;
     /**
      * Create a new runnable sequence that runs each individual runnable in series,
      * piping the output of one runnable into another runnable or runnable-like.
@@ -213,7 +212,7 @@ export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends Ru
     configFactories?: Array<(config: RunnableConfig) => RunnableConfig | Promise<RunnableConfig>>;
     constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions>);
     getName(suffix?: string | undefined): string;
-    _mergeConfig(options?: Record<string, any>): Promise<Partial<CallOptions>>;
+    _mergeConfig(...options: (Partial<CallOptions> | RunnableConfig | undefined)[]): Promise<Partial<CallOptions>>;
     bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
     withConfig(config: RunnableConfig): RunnableBinding<RunInput, RunOutput, CallOptions>;
     withRetry(fields?: {
@@ -263,7 +262,7 @@ export declare class RunnableEach<RunInputItem, RunOutputItem, CallOptions exten
     });
     /**
      * 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: Partial<CallOptions>): RunnableEach<RunInputItem, RunOutputItem, CallOptions>;