langchain 0.0.146 → 0.0.147

package/dist/schema/{runnable.cjs → runnable/index.cjs}

@@ -1,9 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RunnableWithFallbacks = exports.RouterRunnable = exports.RunnableBinding = exports.RunnablePassthrough = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.Runnable = void 0;
-const manager_js_1 = require("../callbacks/manager.cjs");
-const serializable_js_1 = require("../load/serializable.cjs");
-const stream_js_1 = require("../util/stream.cjs");
+exports.RunnableWithFallbacks = exports.RouterRunnable = exports.RunnablePassthrough = exports.RunnableLambda = exports.RunnableMap = exports.RunnableSequence = exports.RunnableRetry = exports.RunnableBinding = exports.Runnable = void 0;
+const p_retry_1 = __importDefault(require("p-retry"));
+const manager_js_1 = require("../../callbacks/manager.cjs");
+const serializable_js_1 = require("../../load/serializable.cjs");
+const stream_js_1 = require("../../util/stream.cjs");
+const config_js_1 = require("./config.cjs");
+const async_caller_js_1 = require("../../util/async_caller.cjs");
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 function _coerceToDict(value, defaultKey) {
     return value && !Array.isArray(value) && typeof value === "object"
@@ -33,6 +39,20 @@ class Runnable extends serializable_js_1.Serializable {
         // eslint-disable-next-line @typescript-eslint/no-use-before-define
         return new RunnableBinding({ bound: this, kwargs });
     }
+    /**
+     * Bind arguments to a Runnable, returning a new Runnable.
+     * @param kwargs
+     * @returns A new RunnableBinding that, when invoked, will apply the bound args.
+     */
+    withRetry(fields) {
+        // eslint-disable-next-line @typescript-eslint/no-use-before-define
+        return new RunnableRetry({
+            bound: this,
+            kwargs: {},
+            maxAttemptNumber: fields?.stopAfterAttempt,
+            ...fields,
+        });
+    }
     /**
      * Create a new runnable from the current one that will try invoking
      * other passed fallback runnables if the initial invocation fails.
@@ -55,28 +75,27 @@ class Runnable extends serializable_js_1.Serializable {
         }
         return Array.from({ length }, () => options);
     }
-    /**
-     * Default implementation of batch, which calls invoke N times.
-     * Subclasses should override this method if they can batch more efficiently.
-     * @param inputs Array of inputs to each batch call.
-     * @param options Either a single call options object to apply to each batch call or an array for each call.
-     * @param batchOptions.maxConcurrency Maximum number of calls to run at once.
-     * @returns An array of RunOutputs
-     */
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
-        const batchResults = [];
-        for (let i = 0; i < inputs.length; i += batchSize) {
-            const batchPromises = inputs
-                .slice(i, i + batchSize)
-                .map((input, j) => this.invoke(input, configList[j]));
-            const batchResult = await Promise.all(batchPromises);
-            batchResults.push(batchResult);
-        }
-        return batchResults.flat();
+        const caller = new async_caller_js_1.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.
@@ -109,11 +128,11 @@ class Runnable extends serializable_js_1.Serializable {
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"), undefined, options?.runType);
         let output;
         try {
-            output = await func.bind(this)(input);
+            output = await func.bind(this)(input, options, runManager);
         }
         catch (e) {
             await runManager?.handleChainError(e);
@@ -122,6 +141,30 @@ class Runnable extends serializable_js_1.Serializable {
         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 configs = this._getOptionsList((options ?? {}), inputs.length);
+        const callbackManagers = await Promise.all(configs.map(config_js_1.getCallbackMangerForConfig));
+        const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
+        let outputs;
+        try {
+            outputs = await func(inputs, configs, 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.
@@ -132,7 +175,7 @@ class Runnable extends serializable_js_1.Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
         let runManager;
         const serializedRepresentation = this.toJSON();
         async function* wrapInputForTracing() {
@@ -206,12 +249,215 @@ class Runnable extends serializable_js_1.Serializable {
             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) {
+                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);
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     static isRunnable(thing) {
         return thing.lc_runnable;
     }
 }
 exports.Runnable = Runnable;
+/**
+ * A runnable that delegates calls to another runnable with a set of kwargs.
+ */
+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, "kwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.bound = fields.bound;
+        this.kwargs = fields.kwargs;
+    }
+    bind(kwargs) {
+        return new RunnableBinding({
+            bound: this.bound,
+            kwargs: { ...this.kwargs, ...kwargs },
+        });
+    }
+    async invoke(input, options) {
+        return this.bound.invoke(input, { ...options, ...this.kwargs });
+    }
+    async batch(inputs, options, batchOptions) {
+        const mergedOptions = Array.isArray(options)
+            ? options.map((individualOption) => ({
+                ...individualOption,
+                ...this.kwargs,
+            }))
+            : { ...options, ...this.kwargs };
+        return this.bound.batch(inputs, mergedOptions, batchOptions);
+    }
+    async *_streamIterator(input, options) {
+        yield* this.bound._streamIterator(input, { ...options, ...this.kwargs });
+    }
+    async stream(input, options) {
+        return this.bound.stream(input, { ...options, ...this.kwargs });
+    }
+    async *transform(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    generator, options) {
+        yield* this.bound.transform(generator, options);
+    }
+    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);
+    }
+}
+exports.RunnableBinding = RunnableBinding;
+/**
+ * Base class for runnables that can be retried a
+ * specified number of times.
+ */
+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 (0, p_retry_1.default)((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 (0, p_retry_1.default)(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);
+    }
+}
+exports.RunnableRetry = RunnableRetry;
 /**
  * A sequence of runnables, where the output of each is the input of the next.
  */
@@ -260,7 +506,7 @@ class RunnableSequence extends Runnable {
         return [this.first, ...this.middle, this.last];
     }
     async invoke(input, options) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
         let nextStepInput = input;
         let finalOutput;
@@ -280,7 +526,7 @@ class RunnableSequence extends Runnable {
     }
     async batch(inputs, options, batchOptions) {
         const configList = this._getOptionsList(options ?? {}, inputs.length);
-        const callbackManagers = await Promise.all(configList.map((config) => manager_js_1.CallbackManager.configure(config?.callbacks, undefined, config?.tags, undefined, config?.metadata)));
+        const callbackManagers = await Promise.all(configList.map(config_js_1.getCallbackMangerForConfig));
         const runManagers = await Promise.all(callbackManagers.map((callbackManager, i) => callbackManager?.handleChainStart(this.toJSON(), _coerceToDict(inputs[i], "input"))));
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
         let nextStepInputs = inputs;
@@ -300,17 +546,20 @@ class RunnableSequence extends Runnable {
         return finalOutputs;
     }
     async *_streamIterator(input, options) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
         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 a .transform() method
+        // 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 = steps.length -
-            [...steps]
-                .reverse()
-                .findIndex((step) => typeof step.transform !== "function") -
-            1;
+        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 {
             for (const step of steps.slice(0, streamingStartStepIndex)) {
                 nextStepInput = await step.invoke(nextStepInput, this._patchConfig(options, runManager?.getChild()));
@@ -325,7 +574,6 @@ class RunnableSequence extends Runnable {
         try {
             let finalGenerator = await steps[streamingStartStepIndex]._streamIterator(nextStepInput, this._patchConfig(options, runManager?.getChild()));
             for (const step of steps.slice(streamingStartStepIndex + 1)) {
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
                 finalGenerator = await step.transform(finalGenerator, this._patchConfig(options, runManager?.getChild()));
             }
             for await (const chunk of finalGenerator) {
@@ -422,7 +670,7 @@ class RunnableMap extends Runnable {
     async invoke(input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await (0, config_js_1.getCallbackMangerForConfig)(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
         });
@@ -498,68 +746,6 @@ class RunnablePassthrough extends Runnable {
     }
 }
 exports.RunnablePassthrough = RunnablePassthrough;
-/**
- * A runnable that delegates calls to another runnable with a set of kwargs.
- */
-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, "kwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.bound = fields.bound;
-        this.kwargs = fields.kwargs;
-    }
-    bind(kwargs) {
-        return new RunnableBinding({
-            bound: this.bound,
-            kwargs: { ...this.kwargs, ...kwargs },
-        });
-    }
-    async invoke(input, options) {
-        return this.bound.invoke(input, { ...options, ...this.kwargs });
-    }
-    async batch(inputs, options, batchOptions) {
-        const mergedOptions = Array.isArray(options)
-            ? options.map((individualOption) => ({
-                ...individualOption,
-                ...this.kwargs,
-            }))
-            : { ...options, ...this.kwargs };
-        return this.bound.batch(inputs, mergedOptions, batchOptions);
-    }
-    async *_streamIterator(input, options) {
-        yield* this.bound._streamIterator(input, { ...options, ...this.kwargs });
-    }
-    async stream(input, options) {
-        return this.bound.stream(input, { ...options, ...this.kwargs });
-    }
-}
-exports.RunnableBinding = RunnableBinding;
 /**
  * A runnable that routes to a set of runnables based on Input['key'].
  * Returns the output of the selected runnable.
@@ -720,6 +906,7 @@ class RunnableWithFallbacks extends Runnable {
     }
 }
 exports.RunnableWithFallbacks = RunnableWithFallbacks;
+// TODO: Figure out why the compiler needs help eliminating Error as a RunOutput type
 function _coerceToRunnable(coerceable) {
     if (typeof coerceable === "function") {
         return new RunnableLambda({ func: coerceable });
@@ -732,7 +919,9 @@ function _coerceToRunnable(coerceable) {
         for (const [key, value] of Object.entries(coerceable)) {
             runnables[key] = _coerceToRunnable(value);
         }
-        return new RunnableMap({ steps: runnables });
+        return new RunnableMap({
+            steps: runnables,
+        });
     }
     else {
         throw new Error(`Expected a Runnable, function or object.\nInstead got an unsupported type.`);