@langchain/core 0.1.14 → 0.1.15

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[];

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/runnables/base.cjs

@@ -117,8 +117,9 @@ class Runnable extends serializable_js_1.Serializable {
     }
     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;
             },
@@ -244,7 +245,13 @@ class Runnable extends serializable_js_1.Serializable {
         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);
             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 +278,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.
@@ -612,7 +604,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 +628,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 +682,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 +820,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 +842,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 +868,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 +999,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 +1018,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 +1080,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 +1112,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 +1186,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 +1213,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 +1302,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;
 };
@@ -89,7 +90,6 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * 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.
@@ -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>;

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, 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
@@ -111,8 +111,9 @@ export class Runnable extends Serializable {
     }
     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;
             },
@@ -238,7 +239,13 @@ export class Runnable extends Serializable {
         try {
             const pipe = await pipeGeneratorWithSetup(transformer, wrapInputForTracing(), async () => callbackManager_?.handleChainStart(this.toJSON(), { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName ?? this.getName()), options);
             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 +272,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.
@@ -604,7 +596,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 +620,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 +673,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 +810,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 +832,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 +858,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 +988,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 +1007,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 +1068,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 +1100,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 +1172,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 +1199,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 +1286,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,6 +1,6 @@
 "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) {
@@ -79,3 +79,44 @@ options) {
     return copy;
 }
 exports.mergeConfigs = mergeConfigs;
+/**
+ * Ensure that a passed config is an object with all required keys present.
+ */
+function ensureConfig(config) {
+    return {
+        tags: [],
+        metadata: {},
+        callbacks: undefined,
+        recursionLimit: 25,
+        ...config,
+    };
+}
+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>;
+/**
+ * Ensure that a passed config is an object with all required keys present.
+ */
+export declare function ensureConfig<CallOptions extends RunnableConfig>(config?: CallOptions): Partial<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>;

package/dist/runnables/config.js

@@ -74,3 +74,42 @@ options) {
     }
     return copy;
 }
+/**
+ * Ensure that a passed config is an object with all required keys present.
+ */
+export function ensureConfig(config) {
+    return {
+        tags: [],
+        metadata: {},
+        callbacks: undefined,
+        recursionLimit: 25,
+        ...config,
+    };
+}
+/**
+ * Helper function that patches runnable configs with updated properties.
+ */
+export 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;
+}

package/dist/runnables/index.cjs

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
+exports.RunnableWithMessageHistory = exports.RunnableBranch = exports.RouterRunnable = exports.RunnablePassthrough = exports.patchConfig = exports.getCallbackManagerForConfig = exports._coerceToRunnable = exports.RunnablePick = exports.RunnableAssign = exports.RunnableWithFallbacks = exports.RunnableLambda = exports.RunnableParallel = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableEach = exports.RunnableBinding = exports.Runnable = void 0;
 var base_js_1 = require("./base.cjs");
 Object.defineProperty(exports, "Runnable", { enumerable: true, get: function () { return base_js_1.Runnable; } });
 Object.defineProperty(exports, "RunnableBinding", { enumerable: true, get: function () { return base_js_1.RunnableBinding; } });
@@ -16,6 +16,7 @@ Object.defineProperty(exports, "RunnablePick", { enumerable: true, get: function
 Object.defineProperty(exports, "_coerceToRunnable", { enumerable: true, get: function () { return base_js_1._coerceToRunnable; } });
 var config_js_1 = require("./config.cjs");
 Object.defineProperty(exports, "getCallbackManagerForConfig", { enumerable: true, get: function () { return config_js_1.getCallbackManagerForConfig; } });
+Object.defineProperty(exports, "patchConfig", { enumerable: true, get: function () { return config_js_1.patchConfig; } });
 var passthrough_js_1 = require("./passthrough.cjs");
 Object.defineProperty(exports, "RunnablePassthrough", { enumerable: true, get: function () { return passthrough_js_1.RunnablePassthrough; } });
 var router_js_1 = require("./router.cjs");

package/dist/runnables/index.d.ts

@@ -1,5 +1,5 @@
 export { type RunnableFunc, type RunnableLike, type RunnableBatchOptions, type RunnableRetryFailedAttemptHandler, Runnable, type RunnableInterface, type RunnableBindingArgs, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
-export { type RunnableConfig, getCallbackManagerForConfig } from "./config.js";
+export { type RunnableConfig, getCallbackManagerForConfig, patchConfig, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { type RouterInput, RouterRunnable } from "./router.js";
 export { RunnableBranch, type Branch, type BranchLike } from "./branch.js";

package/dist/runnables/index.js

@@ -1,5 +1,5 @@
 export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableParallel, RunnableLambda, RunnableWithFallbacks, RunnableAssign, RunnablePick, _coerceToRunnable, } from "./base.js";
-export { getCallbackManagerForConfig } from "./config.js";
+export { getCallbackManagerForConfig, patchConfig, } from "./config.js";
 export { RunnablePassthrough } from "./passthrough.js";
 export { RouterRunnable } from "./router.js";
 export { RunnableBranch } from "./branch.js";

package/dist/runnables/router.cjs

@@ -49,9 +49,8 @@ class RouterRunnable extends base_js_1.Runnable {
         }
         const runnables = keys.map((key) => this.runnables[key]);
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
+        const maxConcurrency = optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
+        const batchSize = maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;
         const batchResults = [];
         for (let i = 0; i < actualInputs.length; i += batchSize) {
             const batchPromises = actualInputs

package/dist/runnables/router.js

@@ -46,9 +46,8 @@ export class RouterRunnable extends Runnable {
         }
         const runnables = keys.map((key) => this.runnables[key]);
         const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
+        const maxConcurrency = optionsList[0]?.maxConcurrency ?? batchOptions?.maxConcurrency;
+        const batchSize = maxConcurrency && maxConcurrency > 0 ? maxConcurrency : inputs.length;
         const batchResults = [];
         for (let i = 0; i < actualInputs.length; i += batchSize) {
             const batchPromises = actualInputs

package/dist/tracers/base.cjs

@@ -47,9 +47,16 @@ class BaseTracer extends base_js_1.BaseCallbackHandler {
                     ].join(".");
                 }
                 else {
-                    console.warn(`Parent run with UUID ${storedRun.parent_run_id} not found.`);
+                    // This can happen naturally for callbacks added within a run
+                    // console.debug(`Parent run with UUID ${storedRun.parent_run_id} has no dotted order.`);
                 }
             }
+            else {
+                // This can happen naturally for callbacks added within a run
+                // console.debug(
+                //   `Parent run with UUID ${storedRun.parent_run_id} not found.`
+                // );
+            }
         }
         else {
             storedRun.trace_id = storedRun.id;

package/dist/tracers/base.js

@@ -44,9 +44,16 @@ export class BaseTracer extends BaseCallbackHandler {
                     ].join(".");
                 }
                 else {
-                    console.warn(`Parent run with UUID ${storedRun.parent_run_id} not found.`);
+                    // This can happen naturally for callbacks added within a run
+                    // console.debug(`Parent run with UUID ${storedRun.parent_run_id} has no dotted order.`);
                 }
             }
+            else {
+                // This can happen naturally for callbacks added within a run
+                // console.debug(
+                //   `Parent run with UUID ${storedRun.parent_run_id} not found.`
+                // );
+            }
         }
         else {
             storedRun.trace_id = storedRun.id;

package/dist/tracers/log_stream.cjs

@@ -101,6 +101,12 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "rootId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "keyMapByRunId", {
             enumerable: true,
             configurable: true,
@@ -156,7 +162,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
         // and is therefore not useful here
     }
     _includeRun(run) {
-        if (run.parent_run_id === undefined) {
+        if (run.id === this.rootId) {
             return false;
         }
         const runTags = run.tags ?? [];
@@ -186,8 +192,32 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
         }
         return include;
     }
+    async *tapOutputIterable(runId, output) {
+        // Tap an output async iterator to stream its values to the log.
+        for await (const chunk of output) {
+            // root run is handled in .streamLog()
+            if (runId !== this.rootId) {
+                // if we can't find the run silently ignore
+                // eg. because this run wasn't included in the log
+                const key = this.keyMapByRunId[runId];
+                if (key) {
+                    await this.writer.write(new RunLogPatch({
+                        ops: [
+                            {
+                                op: "add",
+                                path: `/logs/${key}/streamed_output/-`,
+                                value: chunk,
+                            },
+                        ],
+                    }));
+                }
+            }
+            yield chunk;
+        }
+    }
     async onRunCreate(run) {
-        if (run.parent_run_id === undefined) {
+        if (this.rootId === undefined) {
+            this.rootId = run.id;
             await this.writer.write(new RunLogPatch({
                 ops: [
                     {
@@ -220,6 +250,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             tags: run.tags ?? [],
             metadata: run.extra?.metadata ?? {},
             start_time: new Date(run.start_time).toISOString(),
+            streamed_output: [],
             streamed_output_str: [],
             final_output: undefined,
             end_time: undefined,
@@ -258,7 +289,7 @@ class LogStreamCallbackHandler extends base_js_1.BaseTracer {
             await this.writer.write(patch);
         }
         finally {
-            if (run.parent_run_id === undefined) {
+            if (run.id === this.rootId) {
                 const patch = new RunLogPatch({
                     ops: [
                         {

package/dist/tracers/log_stream.d.ts

@@ -19,6 +19,8 @@ export type LogEntry = {
     metadata: Record<string, any>;
     /** ISO-8601 timestamp of when the run started. */
     start_time: string;
+    /** List of general output chunks streamed by this run. */
+    streamed_output: any[];
     /** List of LLM tokens streamed by this run, if applicable. */
     streamed_output_str: string[];
     /** Final output of this run. Only available after the run has finished successfully. */
@@ -84,6 +86,7 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     protected excludeNames?: string[];
     protected excludeTypes?: string[];
     protected excludeTags?: string[];
+    protected rootId?: string;
     private keyMapByRunId;
     private counterMapByRunName;
     protected transformStream: TransformStream;
@@ -94,6 +97,7 @@ export declare class LogStreamCallbackHandler extends BaseTracer {
     [Symbol.asyncIterator](): IterableReadableStream<RunLogPatch>;
     protected persistRun(_run: Run): Promise<void>;
     _includeRun(run: Run): boolean;
+    tapOutputIterable<T>(runId: string, output: AsyncGenerator<T>): AsyncGenerator<T>;
     onRunCreate(run: Run): Promise<void>;
     onRunUpdate(run: Run): Promise<void>;
     onLLMNewToken(run: Run, token: string): Promise<void>;

package/dist/tracers/log_stream.js

@@ -96,6 +96,12 @@ export class LogStreamCallbackHandler extends BaseTracer {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "rootId", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "keyMapByRunId", {
             enumerable: true,
             configurable: true,
@@ -151,7 +157,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
         // and is therefore not useful here
     }
     _includeRun(run) {
-        if (run.parent_run_id === undefined) {
+        if (run.id === this.rootId) {
             return false;
         }
         const runTags = run.tags ?? [];
@@ -181,8 +187,32 @@ export class LogStreamCallbackHandler extends BaseTracer {
         }
         return include;
     }
+    async *tapOutputIterable(runId, output) {
+        // Tap an output async iterator to stream its values to the log.
+        for await (const chunk of output) {
+            // root run is handled in .streamLog()
+            if (runId !== this.rootId) {
+                // if we can't find the run silently ignore
+                // eg. because this run wasn't included in the log
+                const key = this.keyMapByRunId[runId];
+                if (key) {
+                    await this.writer.write(new RunLogPatch({
+                        ops: [
+                            {
+                                op: "add",
+                                path: `/logs/${key}/streamed_output/-`,
+                                value: chunk,
+                            },
+                        ],
+                    }));
+                }
+            }
+            yield chunk;
+        }
+    }
     async onRunCreate(run) {
-        if (run.parent_run_id === undefined) {
+        if (this.rootId === undefined) {
+            this.rootId = run.id;
             await this.writer.write(new RunLogPatch({
                 ops: [
                     {
@@ -215,6 +245,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
             tags: run.tags ?? [],
             metadata: run.extra?.metadata ?? {},
             start_time: new Date(run.start_time).toISOString(),
+            streamed_output: [],
             streamed_output_str: [],
             final_output: undefined,
             end_time: undefined,
@@ -253,7 +284,7 @@ export class LogStreamCallbackHandler extends BaseTracer {
             await this.writer.write(patch);
         }
         finally {
-            if (run.parent_run_id === undefined) {
+            if (run.id === this.rootId) {
                 const patch = new RunLogPatch({
                     ops: [
                         {

package/dist/utils/testing/index.cjs

@@ -99,16 +99,27 @@ class FakeStreamingLLM extends llms_js_1.LLM {
             writable: true,
             value: 50
         });
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.sleep = fields.sleep ?? this.sleep;
+        this.responses = fields.responses;
     }
     _llmType() {
         return "fake";
     }
     async _call(prompt) {
-        return prompt;
+        const response = this.responses?.[0];
+        this.responses = this.responses?.slice(1);
+        return response ?? prompt;
     }
     async *_streamResponseChunks(input) {
-        for (const c of input) {
+        const response = this.responses?.[0];
+        this.responses = this.responses?.slice(1);
+        for (const c of response ?? input) {
             await new Promise((resolve) => setTimeout(resolve, this.sleep));
             yield { text: c, generationInfo: {} };
         }

package/dist/utils/testing/index.d.ts

@@ -40,8 +40,10 @@ export declare class FakeLLM extends LLM {
 }
 export declare class FakeStreamingLLM extends LLM {
     sleep?: number;
+    responses?: string[];
     constructor(fields: {
         sleep?: number;
+        responses?: string[];
     } & BaseLLMParams);
     _llmType(): string;
     _call(prompt: string): Promise<string>;

package/dist/utils/testing/index.js

@@ -93,16 +93,27 @@ export class FakeStreamingLLM extends LLM {
             writable: true,
             value: 50
         });
+        Object.defineProperty(this, "responses", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         this.sleep = fields.sleep ?? this.sleep;
+        this.responses = fields.responses;
     }
     _llmType() {
         return "fake";
     }
     async _call(prompt) {
-        return prompt;
+        const response = this.responses?.[0];
+        this.responses = this.responses?.slice(1);
+        return response ?? prompt;
     }
     async *_streamResponseChunks(input) {
-        for (const c of input) {
+        const response = this.responses?.[0];
+        this.responses = this.responses?.slice(1);
+        for (const c of response ?? input) {
             await new Promise((resolve) => setTimeout(resolve, this.sleep));
             yield { text: c, generationInfo: {} };
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@langchain/core",
-  "version": "0.1.14",
+  "version": "0.1.15",
   "description": "Core LangChain.js abstractions and schemas",
   "type": "module",
   "engines": {
@@ -18,7 +18,7 @@
     "build:cjs": "NODE_OPTIONS=--max-old-space-size=4096 tsc --outDir dist-cjs/ -p tsconfig.cjs.json && node scripts/move-cjs-to-dist.js && rimraf dist-cjs",
     "build:watch": "node scripts/create-entrypoints.js && tsc --outDir dist/ --watch",
     "build:scripts": "node scripts/create-entrypoints.js && node scripts/check-tree-shaking.js",
-    "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint src",
+    "lint:eslint": "NODE_OPTIONS=--max-old-space-size=4096 eslint --cache --ext .ts,.js src/",
     "lint:dpdm": "dpdm --exit-code circular:1 --no-warning --no-tree src/*.ts src/**/*.ts",
     "lint": "yarn lint:eslint && yarn lint:dpdm",
     "lint:fix": "yarn lint:eslint --fix && yarn lint:dpdm",