langchain 0.0.195 → 0.0.197-rc.0

package/dist/schema/runnable/base.js

@@ -1,1060 +1 @@
-import pRetry from "p-retry";
-import { CallbackManager, } from "../../callbacks/manager.js";
-import { LogStreamCallbackHandler, RunLogPatch, } from "../../callbacks/handlers/log_stream.js";
-import { Serializable } from "../../load/serializable.js";
-import { IterableReadableStream } from "../../util/stream.js";
-import { getCallbackMangerForConfig } from "./config.js";
-import { AsyncCaller } from "../../util/async_caller.js";
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-function _coerceToDict(value, defaultKey) {
-    return value && !Array.isArray(value) && typeof value === "object"
-        ? value
-        : { [defaultKey]: value };
-}
-/**
- * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
- * transformed.
- */
-export class Runnable extends Serializable {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_runnable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-    }
-    /**
-     * Bind arguments to a Runnable, returning a new Runnable.
-     * @param kwargs
-     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
-     */
-    bind(kwargs) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableBinding({ bound: this, kwargs, config: {} });
-    }
-    /**
-     * Return a new Runnable that maps a list of inputs to a list of outputs,
-     * by calling invoke() with each input.
-     */
-    map() {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableEach({ bound: this });
-    }
-    /**
-     * Add retry logic to an existing runnable.
-     * @param kwargs
-     * @returns A new RunnableRetry that, when invoked, will retry according to the parameters.
-     */
-    withRetry(fields) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableRetry({
-            bound: this,
-            kwargs: {},
-            config: {},
-            maxAttemptNumber: fields?.stopAfterAttempt,
-            ...fields,
-        });
-    }
-    /**
-     * Bind config to a Runnable, returning a new Runnable.
-     * @param config New configuration parameters to attach to the new runnable.
-     * @returns A new RunnableBinding with a config matching what's passed.
-     */
-    withConfig(config) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableBinding({
-            bound: this,
-            config,
-            kwargs: {},
-        });
-    }
-    /**
-     * Create a new runnable from the current one that will try invoking
-     * other passed fallback runnables if the initial invocation fails.
-     * @param fields.fallbacks Other runnables to call if the runnable errors.
-     * @returns A new RunnableWithFallbacks.
-     */
-    withFallbacks(fields) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableWithFallbacks({
-            runnable: this,
-            fallbacks: fields.fallbacks,
-        });
-    }
-    _getOptionsList(options, length = 0) {
-        if (Array.isArray(options)) {
-            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 Array.from({ length }, () => options);
-    }
-    async batch(inputs, options, batchOptions) {
-        const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const caller = new AsyncCaller({
-            maxConcurrency: batchOptions?.maxConcurrency,
-            onFailedAttempt: (e) => {
-                throw e;
-            },
-        });
-        const batchCalls = inputs.map((input, i) => caller.call(async () => {
-            try {
-                const result = await this.invoke(input, configList[i]);
-                return result;
-            }
-            catch (e) {
-                if (batchOptions?.returnExceptions) {
-                    return e;
-                }
-                throw e;
-            }
-        }));
-        return Promise.all(batchCalls);
-    }
-    /**
-     * Default streaming implementation.
-     * Subclasses should override this method if they support streaming output.
-     * @param input
-     * @param options
-     */
-    async *_streamIterator(input, options) {
-        yield this.invoke(input, options);
-    }
-    /**
-     * Stream output in chunks.
-     * @param input
-     * @param options
-     * @returns A readable stream that is also an iterable.
-     */
-    async stream(input, options) {
-        return IterableReadableStream.fromAsyncGenerator(this._streamIterator(input, options));
-    }
-    _separateRunnableConfigFromCallOptions(options = {}) {
-        const runnableConfig = {
-            callbacks: options.callbacks,
-            tags: options.tags,
-            metadata: options.metadata,
-            runName: options.runName,
-        };
-        const callOptions = { ...options };
-        delete callOptions.callbacks;
-        delete callOptions.tags;
-        delete callOptions.metadata;
-        delete callOptions.runName;
-        return [runnableConfig, callOptions];
-    }
-    async _callWithConfig(func, input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType, undefined, undefined, options?.runName);
-        let output;
-        try {
-            output = await func.bind(this)(input, options, runManager);
-        }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
-        }
-        await runManager?.handleChainEnd(_coerceToDict(output, "output"));
-        return output;
-    }
-    /**
-     * Internal method that handles batching and configuration for a runnable
-     * It takes a function, input values, and optional configuration, and
-     * returns a promise that resolves to the output values.
-     * @param func The function to be executed for each input value.
-     * @param input The input values to be processed.
-     * @param config Optional configuration for the function execution.
-     * @returns A promise that resolves to the output values.
-     */
-    async _batchWithConfig(func, inputs, options, batchOptions) {
-        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(optionsList.map(getCallbackMangerForConfig));
-        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"), undefined, optionsList[i].runType, undefined, undefined, optionsList[i].runName)));
-        let outputs;
-        try {
-            outputs = await func(inputs, optionsList, runManagers, batchOptions);
-        }
-        catch (e) {
-            await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(e)));
-            throw e;
-        }
-        await Promise.all(runManagers.map((runManager) => runManager?.handleChainEnd(_coerceToDict(outputs, "output"))));
-        return outputs;
-    }
-    /**
-     * Helper method to transform an Iterator of Input values into an Iterator of
-     * Output values, with callbacks.
-     * Use this to implement `stream()` or `transform()` in Runnable subclasses.
-     */
-    async *_transformStreamWithConfig(inputGenerator, transformer, options) {
-        let finalInput;
-        let finalInputSupported = true;
-        let finalOutput;
-        let finalOutputSupported = true;
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        let runManager;
-        const serializedRepresentation = this.toJSON();
-        async function* wrapInputForTracing() {
-            for await (const chunk of inputGenerator) {
-                if (!runManager) {
-                    // Start the run manager AFTER the iterator starts to preserve
-                    // tracing order
-                    runManager = await callbackManager_?.handleChainStart(serializedRepresentation, { input: "" }, undefined, options?.runType, undefined, undefined, options?.runName);
-                }
-                if (finalInputSupported) {
-                    if (finalInput === undefined) {
-                        finalInput = chunk;
-                    }
-                    else {
-                        try {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalInput = finalInput.concat(chunk);
-                        }
-                        catch {
-                            finalInput = undefined;
-                            finalInputSupported = false;
-                        }
-                    }
-                }
-                yield chunk;
-            }
-        }
-        const wrappedInputGenerator = wrapInputForTracing();
-        try {
-            const outputIterator = transformer(wrappedInputGenerator, runManager, options);
-            for await (const chunk of outputIterator) {
-                yield chunk;
-                if (finalOutputSupported) {
-                    if (finalOutput === undefined) {
-                        finalOutput = chunk;
-                    }
-                    else {
-                        try {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = finalOutput.concat(chunk);
-                        }
-                        catch {
-                            finalOutput = undefined;
-                            finalOutputSupported = false;
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            await runManager?.handleChainError(e, undefined, undefined, undefined, {
-                inputs: _coerceToDict(finalInput, "input"),
-            });
-            throw e;
-        }
-        await runManager?.handleChainEnd(finalOutput ?? {}, undefined, undefined, undefined, { inputs: _coerceToDict(finalInput, "input") });
-    }
-    _patchConfig(config = {}, callbackManager = 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 };
-        }
-        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.
-     * @param coerceable A runnable, function, or object whose values are functions or runnables.
-     * @returns A new runnable sequence.
-     */
-    pipe(coerceable) {
-        // eslint-disable-next-line @typescript-eslint/no-use-before-define
-        return new RunnableSequence({
-            first: this,
-            last: _coerceToRunnable(coerceable),
-        });
-    }
-    /**
-     * Default implementation of transform, which buffers input and then calls stream.
-     * Subclasses should override this method if they can start producing output while
-     * input is still being generated.
-     * @param generator
-     * @param options
-     */
-    async *transform(generator, options) {
-        let finalChunk;
-        for await (const chunk of generator) {
-            if (finalChunk === undefined) {
-                finalChunk = chunk;
-            }
-            else {
-                // Make a best effort to gather, for any type that supports concat.
-                // This method should throw an error if gathering fails.
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                finalChunk = finalChunk.concat(chunk);
-            }
-        }
-        yield* this._streamIterator(finalChunk, options);
-    }
-    /**
-     * Stream all output from a runnable, as reported to the callback system.
-     * This includes all inner runs of LLMs, Retrievers, Tools, etc.
-     * Output is streamed as Log objects, which include a list of
-     * jsonpatch ops that describe how the state of the run has changed in each
-     * step, and the final state of the run.
-     * The jsonpatch ops can be applied in order to construct state.
-     * @param input
-     * @param options
-     * @param streamOptions
-     */
-    async *streamLog(input, options, streamOptions) {
-        const stream = new LogStreamCallbackHandler({
-            ...streamOptions,
-            autoClose: false,
-        });
-        const config = options ?? {};
-        const { callbacks } = config;
-        if (callbacks === undefined) {
-            config.callbacks = [stream];
-        }
-        else if (Array.isArray(callbacks)) {
-            config.callbacks = callbacks.concat([stream]);
-        }
-        else {
-            const copiedCallbacks = callbacks.copy();
-            copiedCallbacks.inheritableHandlers.push(stream);
-            config.callbacks = copiedCallbacks;
-        }
-        const runnableStream = await this.stream(input, config);
-        async function consumeRunnableStream() {
-            try {
-                for await (const chunk of runnableStream) {
-                    const patch = new RunLogPatch({
-                        ops: [
-                            {
-                                op: "add",
-                                path: "/streamed_output/-",
-                                value: chunk,
-                            },
-                        ],
-                    });
-                    await stream.writer.write(patch);
-                }
-            }
-            finally {
-                await stream.writer.close();
-            }
-        }
-        const runnableStreamPromise = consumeRunnableStream();
-        try {
-            for await (const log of stream) {
-                yield log;
-            }
-        }
-        finally {
-            await runnableStreamPromise;
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static isRunnable(thing) {
-        return thing ? thing.lc_runnable : false;
-    }
-}
-/**
- * A runnable that delegates calls to another runnable with a set of kwargs.
- */
-export class RunnableBinding extends Runnable {
-    static lc_name() {
-        return "RunnableBinding";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "bound", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "config", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "kwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.bound = fields.bound;
-        this.kwargs = fields.kwargs;
-        this.config = fields.config;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _mergeConfig(options) {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const copy = { ...this.config };
-        if (options) {
-            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] ?? []);
-                }
-                else {
-                    copy[key] = options[key] ?? copy[key];
-                }
-            }
-        }
-        return copy;
-    }
-    bind(kwargs) {
-        return this.constructor({
-            bound: this.bound,
-            kwargs: { ...this.kwargs, ...kwargs },
-            config: this.config,
-        });
-    }
-    withConfig(config) {
-        return this.constructor({
-            bound: this.bound,
-            kwargs: this.kwargs,
-            config: { ...this.config, ...config },
-        });
-    }
-    withRetry(fields) {
-        return this.constructor({
-            bound: this.bound.withRetry(fields),
-            kwargs: this.kwargs,
-            config: this.config,
-        });
-    }
-    async invoke(input, options) {
-        return this.bound.invoke(input, this._mergeConfig({ ...options, ...this.kwargs }));
-    }
-    async batch(inputs, options, batchOptions) {
-        const mergedOptions = Array.isArray(options)
-            ? options.map((individualOption) => this._mergeConfig({
-                ...individualOption,
-                ...this.kwargs,
-            }))
-            : this._mergeConfig({ ...options, ...this.kwargs });
-        return this.bound.batch(inputs, mergedOptions, batchOptions);
-    }
-    async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, this._mergeConfig({ ...options, ...this.kwargs }));
-    }
-    async stream(input, options) {
-        return this.bound.stream(input, this._mergeConfig({ ...options, ...this.kwargs }));
-    }
-    async *transform(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    generator, options) {
-        yield* this.bound.transform(generator, this._mergeConfig({ ...options, ...this.kwargs }));
-    }
-    static isRunnableBinding(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    thing
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
-        return thing.bound && Runnable.isRunnable(thing.bound);
-    }
-}
-/**
- * A runnable that delegates calls to another runnable
- * with each element of the input sequence.
- */
-export class RunnableEach extends Runnable {
-    static lc_name() {
-        return "RunnableEach";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "bound", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.bound = fields.bound;
-    }
-    /**
-     * Binds the runnable with the specified arguments.
-     * @param args The arguments to bind the runnable with.
-     * @returns A new instance of the `RunnableEach` class that is bound with the specified arguments.
-     */
-    bind(kwargs) {
-        return new RunnableEach({
-            bound: this.bound.bind(kwargs),
-        });
-    }
-    /**
-     * Invokes the runnable with the specified input and configuration.
-     * @param input The input to invoke the runnable with.
-     * @param config The configuration to invoke the runnable with.
-     * @returns A promise that resolves to the output of the runnable.
-     */
-    async invoke(inputs, config) {
-        return this._callWithConfig(this._invoke, inputs, config);
-    }
-    /**
-     * A helper method that is used to invoke the runnable with the specified input and configuration.
-     * @param input The input to invoke the runnable with.
-     * @param config The configuration to invoke the runnable with.
-     * @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()));
-    }
-}
-/**
- * Base class for runnables that can be retried a
- * specified number of times.
- */
-export class RunnableRetry extends RunnableBinding {
-    static lc_name() {
-        return "RunnableRetry";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "maxAttemptNumber", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: 3
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "onFailedAttempt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: () => { }
-        });
-        this.maxAttemptNumber = fields.maxAttemptNumber ?? this.maxAttemptNumber;
-        this.onFailedAttempt = fields.onFailedAttempt ?? this.onFailedAttempt;
-    }
-    _patchConfigForRetry(attempt, config, runManager) {
-        const tag = attempt > 1 ? `retry:attempt:${attempt}` : undefined;
-        return this._patchConfig(config, runManager?.getChild(tag));
-    }
-    async _invoke(input, config, runManager) {
-        return pRetry((attemptNumber) => super.invoke(input, this._patchConfigForRetry(attemptNumber, config, runManager)), {
-            onFailedAttempt: this.onFailedAttempt,
-            retries: Math.max(this.maxAttemptNumber - 1, 0),
-            randomize: true,
-        });
-    }
-    /**
-     * Method that invokes the runnable with the specified input, run manager,
-     * and config. It handles the retry logic by catching any errors and
-     * recursively invoking itself with the updated config for the next retry
-     * attempt.
-     * @param input The input for the runnable.
-     * @param runManager The run manager for the runnable.
-     * @param config The config for the runnable.
-     * @returns A promise that resolves to the output of the runnable.
-     */
-    async invoke(input, config) {
-        return this._callWithConfig(this._invoke, input, config);
-    }
-    async _batch(inputs, configs, runManagers, batchOptions) {
-        const resultsMap = {};
-        try {
-            await pRetry(async (attemptNumber) => {
-                const remainingIndexes = inputs
-                    .map((_, i) => i)
-                    .filter((i) => resultsMap[i.toString()] === undefined ||
-                    // eslint-disable-next-line no-instanceof/no-instanceof
-                    resultsMap[i.toString()] instanceof Error);
-                const remainingInputs = remainingIndexes.map((i) => inputs[i]);
-                const patchedConfigs = remainingIndexes.map((i) => this._patchConfigForRetry(attemptNumber, configs?.[i], runManagers?.[i]));
-                const results = await super.batch(remainingInputs, patchedConfigs, {
-                    ...batchOptions,
-                    returnExceptions: true,
-                });
-                let firstException;
-                for (let i = 0; i < results.length; i += 1) {
-                    const result = results[i];
-                    const resultMapIndex = remainingIndexes[i];
-                    // eslint-disable-next-line no-instanceof/no-instanceof
-                    if (result instanceof Error) {
-                        if (firstException === undefined) {
-                            firstException = result;
-                        }
-                    }
-                    resultsMap[resultMapIndex.toString()] = result;
-                }
-                if (firstException) {
-                    throw firstException;
-                }
-                return results;
-            }, {
-                onFailedAttempt: this.onFailedAttempt,
-                retries: Math.max(this.maxAttemptNumber - 1, 0),
-                randomize: true,
-            });
-        }
-        catch (e) {
-            if (batchOptions?.returnExceptions !== true) {
-                throw e;
-            }
-        }
-        return Object.keys(resultsMap)
-            .sort((a, b) => parseInt(a, 10) - parseInt(b, 10))
-            .map((key) => resultsMap[parseInt(key, 10)]);
-    }
-    async batch(inputs, options, batchOptions) {
-        return this._batchWithConfig(this._batch.bind(this), inputs, options, batchOptions);
-    }
-}
-/**
- * A sequence of runnables, where the output of each is the input of the next.
- * @example
- * ```typescript
- * const promptTemplate = PromptTemplate.fromTemplate(
- *   "Tell me a joke about {topic}",
- * );
- * const chain = RunnableSequence.from([promptTemplate, new ChatOpenAI({})]);
- * const result = await chain.invoke({ topic: "bears" });
- * ```
- */
-export class RunnableSequence extends Runnable {
-    static lc_name() {
-        return "RunnableSequence";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "first", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "middle", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: []
-        });
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        Object.defineProperty(this, "last", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        this.first = fields.first;
-        this.middle = fields.middle ?? this.middle;
-        this.last = fields.last;
-    }
-    get steps() {
-        return [this.first, ...this.middle, this.last];
-    }
-    async invoke(input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
-        let nextStepInput = input;
-        let finalOutput;
-        try {
-            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}`)));
-            }
-            // 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}`)));
-        }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
-        }
-        await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
-        return finalOutput;
-    }
-    async batch(inputs, options, batchOptions) {
-        const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map(getCallbackMangerForConfig));
-        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);
-            }
-            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;
-    }
-    async *_streamIterator(input, options) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
-        let nextStepInput = input;
-        const steps = [this.first, ...this.middle, this.last];
-        // Find the index of the last runnable in the sequence that doesn't have an overridden .transform() method
-        // and start streaming from there
-        const streamingStartStepIndex = Math.min(steps.length - 1, steps.length -
-            [...steps].reverse().findIndex((step) => {
-                const isDefaultImplementation = step.transform === Runnable.prototype.transform;
-                const boundRunnableIsDefaultImplementation = RunnableBinding.isRunnableBinding(step) &&
-                    step.bound?.transform === Runnable.prototype.transform;
-                return (isDefaultImplementation || boundRunnableIsDefaultImplementation);
-            }) -
-            1);
-        try {
-            const invokeSteps = steps.slice(0, streamingStartStepIndex);
-            for (let i = 0; i < invokeSteps.length; i += 1) {
-                const step = invokeSteps[i];
-                nextStepInput = await step.invoke(nextStepInput, this._patchConfig(options, runManager?.getChild(`seq:step:${i + 1}`)));
-            }
-        }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
-        }
-        let concatSupported = true;
-        let finalOutput;
-        try {
-            let finalGenerator = await steps[streamingStartStepIndex]._streamIterator(nextStepInput, this._patchConfig(options, runManager?.getChild(`seq:step:${streamingStartStepIndex + 1}`)));
-            const finalSteps = steps.slice(streamingStartStepIndex + 1);
-            for (let i = 0; i < finalSteps.length; i += 1) {
-                const step = finalSteps[i];
-                finalGenerator = await step.transform(finalGenerator, this._patchConfig(options, runManager?.getChild(`seq:step:${streamingStartStepIndex + i + 2}`)));
-            }
-            for await (const chunk of finalGenerator) {
-                yield chunk;
-                if (concatSupported) {
-                    if (finalOutput === undefined) {
-                        finalOutput = chunk;
-                    }
-                    else {
-                        try {
-                            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                            finalOutput = finalOutput.concat(chunk);
-                        }
-                        catch (e) {
-                            finalOutput = undefined;
-                            concatSupported = false;
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
-        }
-        await runManager?.handleChainEnd(_coerceToDict(finalOutput, "output"));
-    }
-    pipe(coerceable) {
-        if (RunnableSequence.isRunnableSequence(coerceable)) {
-            return new RunnableSequence({
-                first: this.first,
-                middle: this.middle.concat([
-                    this.last,
-                    coerceable.first,
-                    ...coerceable.middle,
-                ]),
-                last: coerceable.last,
-            });
-        }
-        else {
-            return new RunnableSequence({
-                first: this.first,
-                middle: [...this.middle, this.last],
-                last: _coerceToRunnable(coerceable),
-            });
-        }
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static isRunnableSequence(thing) {
-        return Array.isArray(thing.middle) && Runnable.isRunnable(thing);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static from([first, ...runnables]) {
-        return new RunnableSequence({
-            first: _coerceToRunnable(first),
-            middle: runnables.slice(0, -1).map(_coerceToRunnable),
-            last: _coerceToRunnable(runnables[runnables.length - 1]),
-        });
-    }
-}
-/**
- * A runnable that runs a mapping of runnables in parallel,
- * and returns a mapping of their outputs.
- * @example
- * ```typescript
- * const mapChain = RunnableMap.from({
- *   joke: PromptTemplate.fromTemplate("Tell me a joke about {topic}").pipe(
- *     new ChatAnthropic({}),
- *   ),
- *   poem: PromptTemplate.fromTemplate("write a 2-line poem about {topic}").pipe(
- *     new ChatAnthropic({}),
- *   ),
- * });
- * const result = await mapChain.invoke({ topic: "bear" });
- * ```
- */
-export class RunnableMap extends Runnable {
-    static lc_name() {
-        return "RunnableMap";
-    }
-    getStepsKeys() {
-        return Object.keys(this.steps);
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "steps", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.steps = {};
-        for (const [key, value] of Object.entries(fields.steps)) {
-            this.steps[key] = _coerceToRunnable(value);
-        }
-    }
-    static from(steps) {
-        return new RunnableMap({ steps });
-    }
-    async invoke(input, options
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    ) {
-        const callbackManager_ = await getCallbackMangerForConfig(options);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
-            input,
-        }, undefined, undefined, undefined, undefined, options?.runName);
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const output = {};
-        try {
-            await Promise.all(Object.entries(this.steps).map(async ([key, runnable]) => {
-                output[key] = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild(key)));
-            }));
-        }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
-        }
-        await runManager?.handleChainEnd(output);
-        return output;
-    }
-}
-/**
- * A runnable that runs a callable.
- */
-export class RunnableLambda extends Runnable {
-    static lc_name() {
-        return "RunnableLambda";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "func", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.func = fields.func;
-    }
-    static from(func) {
-        return new RunnableLambda({
-            func,
-        });
-    }
-    async _invoke(input, config, runManager) {
-        let output = await this.func(input);
-        if (output && Runnable.isRunnable(output)) {
-            output = await output.invoke(input, this._patchConfig(config, runManager?.getChild()));
-        }
-        return output;
-    }
-    async invoke(input, options) {
-        return this._callWithConfig(this._invoke, input, options);
-    }
-}
-/**
- * A Runnable that can fallback to other Runnables if it fails.
- */
-export class RunnableWithFallbacks extends Runnable {
-    static lc_name() {
-        return "RunnableWithFallbacks";
-    }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "runnable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "fallbacks", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.runnable = fields.runnable;
-        this.fallbacks = fields.fallbacks;
-    }
-    *runnables() {
-        yield this.runnable;
-        for (const fallback of this.fallbacks) {
-            yield fallback;
-        }
-    }
-    async invoke(input, options) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, undefined, undefined, undefined, options?.runName);
-        let firstError;
-        for (const runnable of this.runnables()) {
-            try {
-                const output = await runnable.invoke(input, this._patchConfig(options, runManager?.getChild()));
-                await runManager?.handleChainEnd(_coerceToDict(output, "output"));
-                return output;
-            }
-            catch (e) {
-                if (firstError === undefined) {
-                    firstError = e;
-                }
-            }
-        }
-        if (firstError === undefined) {
-            throw new Error("No error stored at end of fallback.");
-        }
-        await runManager?.handleChainError(firstError);
-        throw firstError;
-    }
-    async batch(inputs, options, batchOptions) {
-        if (batchOptions?.returnExceptions) {
-            throw new Error("Not implemented.");
-        }
-        const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map((config) => CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
-        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 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);
-                await Promise.all(runManagers.map((runManager, i) => runManager?.handleChainEnd(_coerceToDict(outputs[i], "output"))));
-                return outputs;
-            }
-            catch (e) {
-                if (firstError === undefined) {
-                    firstError = e;
-                }
-            }
-        }
-        if (!firstError) {
-            throw new Error("No error stored at end of fallbacks.");
-        }
-        await Promise.all(runManagers.map((runManager) => runManager?.handleChainError(firstError)));
-        throw firstError;
-    }
-}
-// TODO: Figure out why the compiler needs help eliminating Error as a RunOutput type
-export function _coerceToRunnable(coerceable) {
-    if (typeof coerceable === "function") {
-        return new RunnableLambda({ func: coerceable });
-    }
-    else if (Runnable.isRunnable(coerceable)) {
-        return coerceable;
-    }
-    else if (!Array.isArray(coerceable) && typeof coerceable === "object") {
-        const runnables = {};
-        for (const [key, value] of Object.entries(coerceable)) {
-            runnables[key] = _coerceToRunnable(value);
-        }
-        return new RunnableMap({
-            steps: runnables,
-        });
-    }
-    else {
-        throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`);
-    }
-}
+export { Runnable, RunnableBinding, RunnableEach, RunnableRetry, RunnableSequence, RunnableMap, RunnableLambda, RunnableWithFallbacks, _coerceToRunnable, } from "langchain-core/runnables";