@langchain/core 0.1.15 → 0.1.17-rc.0

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

@@ -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/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,9 +111,9 @@ 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);
@@ -154,30 +154,39 @@ class Runnable extends serializable_js_1.Serializable {
      * @returns A readable stream that is also an iterable.
      */
     async stream(input, options) {
-        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
+        // Buffer the first streamed chunk to allow for initial errors
+        // to surface immediately.
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this._streamIterator(input, options));
+        await wrappedGenerator.setup;
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
     _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);
@@ -201,7 +210,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)));
@@ -220,7 +229,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) {
@@ -243,7 +253,7 @@ 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;
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
@@ -346,7 +356,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];
@@ -478,10 +488,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)))
             : []));
@@ -511,27 +519,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
@@ -1042,7 +1047,9 @@ class RunnableMap extends Runnable {
         async function* generator() {
             yield input;
         }
-        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 exports.RunnableMap = RunnableMap;
@@ -1131,7 +1138,9 @@ class RunnableLambda extends Runnable {
         async function* generator() {
             yield input;
         }
-        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 exports.RunnableLambda = RunnableLambda;
@@ -1328,7 +1337,9 @@ class RunnableAssign extends Runnable {
         async function* generator() {
             yield input;
         }
-        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 exports.RunnableAssign = RunnableAssign;
@@ -1394,7 +1405,9 @@ class RunnablePick extends Runnable {
         async function* generator() {
             yield input;
         }
-        return stream_js_1.IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new stream_js_1.AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return stream_js_1.IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 exports.RunnablePick = RunnablePick;

package/dist/runnables/base.d.ts

@@ -82,9 +82,9 @@ 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.
@@ -212,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?: {

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, concat, atee, pipeGeneratorWithSetup, } from "../utils/stream.js";
-import { DEFAULT_RECURSION_LIMIT, getCallbackManagerForConfig, mergeConfigs, patchConfig, } from "./config.js";
+import { IterableReadableStream, concat, atee, pipeGeneratorWithSetup, AsyncGeneratorWithSetup, } from "../utils/stream.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,9 +105,9 @@ 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);
@@ -148,30 +148,39 @@ export class Runnable extends Serializable {
      * @returns A readable stream that is also an iterable.
      */
     async stream(input, options) {
-        return IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
+        // Buffer the first streamed chunk to allow for initial errors
+        // to surface immediately.
+        const wrappedGenerator = new AsyncGeneratorWithSetup(this._streamIterator(input, options));
+        await wrappedGenerator.setup;
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
     _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);
@@ -195,7 +204,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)));
@@ -214,7 +223,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) {
@@ -237,7 +247,7 @@ 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;
             const isLogStreamHandler = (handler) => handler.name === "log_stream_tracer";
             const streamLogHandler = runManager?.handlers.find(isLogStreamHandler);
@@ -340,7 +350,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];
@@ -471,10 +481,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)))
             : []));
@@ -504,27 +512,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
@@ -1031,7 +1036,9 @@ export class RunnableMap extends Runnable {
         async function* generator() {
             yield input;
         }
-        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 /**
@@ -1119,7 +1126,9 @@ export class RunnableLambda extends Runnable {
         async function* generator() {
             yield input;
         }
-        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 export class RunnableParallel extends RunnableMap {
@@ -1312,7 +1321,9 @@ export class RunnableAssign extends Runnable {
         async function* generator() {
             yield input;
         }
-        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }
 /**
@@ -1377,6 +1388,8 @@ export class RunnablePick extends Runnable {
         async function* generator() {
             yield input;
         }
-        return IterableReadableStream.fromAsyncGenerator(this.transform(generator(), options));
+        const wrappedGenerator = new AsyncGeneratorWithSetup(this.transform(generator(), options));
+        await wrappedGenerator.setup;
+        return IterableReadableStream.fromAsyncGenerator(wrappedGenerator);
     }
 }

package/dist/runnables/config.cjs

@@ -7,25 +7,23 @@ 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,24 +70,40 @@ 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) {
-    return {
+    let empty = {
         tags: [],
         metadata: {},
         callbacks: undefined,
         recursionLimit: 25,
-        ...config,
     };
+    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;
 /**

package/dist/runnables/config.d.ts

@@ -14,11 +14,11 @@ export interface RunnableConfig extends BaseCallbackConfig {
     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): Partial<CallOptions>;
+export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): CallOptions;
 /**
  * Helper function that patches runnable configs with updated properties.
  */