langchain 0.0.146 → 0.0.147

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

@@ -1,6 +1,9 @@
-import { CallbackManager, } from "../callbacks/manager.js";
-import { Serializable } from "../load/serializable.js";
-import { IterableReadableStream } from "../util/stream.js";
+import pRetry from "p-retry";
+import { CallbackManager, } from "../../callbacks/manager.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"
@@ -30,6 +33,20 @@ export class Runnable extends 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.
@@ -52,28 +69,27 @@ export class Runnable extends 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 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.
@@ -106,11 +122,11 @@ export class Runnable extends Serializable {
         return [runnableConfig, callOptions];
     }
     async _callWithConfig(func, input, options) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await 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);
@@ -119,6 +135,30 @@ export class Runnable extends 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(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.
@@ -129,7 +169,7 @@ export class Runnable extends Serializable {
         let finalInputSupported = true;
         let finalOutput;
         let finalOutputSupported = true;
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await getCallbackMangerForConfig(options);
         let runManager;
         const serializedRepresentation = this.toJSON();
         async function* wrapInputForTracing() {
@@ -203,11 +243,212 @@ export class Runnable extends 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;
     }
 }
+/**
+ * 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, "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);
+    }
+}
+/**
+ * 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.
  */
@@ -256,7 +497,7 @@ export class RunnableSequence extends Runnable {
         return [this.first, ...this.middle, this.last];
     }
     async invoke(input, options) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await getCallbackMangerForConfig(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), _coerceToDict(input, "input"));
         let nextStepInput = input;
         let finalOutput;
@@ -276,7 +517,7 @@ export class RunnableSequence extends Runnable {
     }
     async batch(inputs, options, batchOptions) {
         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 callbackManagers = await Promise.all(configList.map(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;
@@ -296,17 +537,20 @@ export class RunnableSequence extends Runnable {
         return finalOutputs;
     }
     async *_streamIterator(input, options) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await 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()));
@@ -321,7 +565,6 @@ export 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) {
@@ -417,7 +660,7 @@ export class RunnableMap extends Runnable {
     async invoke(input, options
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     ) {
-        const callbackManager_ = await CallbackManager.configure(options?.callbacks, undefined, options?.tags, undefined, options?.metadata);
+        const callbackManager_ = await getCallbackMangerForConfig(options);
         const runManager = await callbackManager_?.handleChainStart(this.toJSON(), {
             input,
         });
@@ -490,67 +733,6 @@ export class RunnablePassthrough extends Runnable {
         return this._callWithConfig((input) => Promise.resolve(input), input, options);
     }
 }
-/**
- * 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, "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 });
-    }
-}
 /**
  * A runnable that routes to a set of runnables based on Input['key'].
  * Returns the output of the selected runnable.
@@ -709,6 +891,7 @@ export class RunnableWithFallbacks extends Runnable {
         throw firstError;
     }
 }
+// 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 });
@@ -721,7 +904,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.`);

package/dist/tools/base.d.ts

@@ -1,7 +1,7 @@
 import { z } from "zod";
 import { CallbackManagerForToolRun, Callbacks } from "../callbacks/manager.js";
 import { BaseLangChain, BaseLangChainParams } from "../base_language/index.js";
-import { RunnableConfig } from "../schema/runnable.js";
+import { RunnableConfig } from "../schema/runnable/config.js";
 /**
  * Parameters for the Tool classes.
  */

package/dist/util/async_caller.cjs

@@ -18,6 +18,32 @@ const STATUS_NO_RETRY = [
     408,
     409, // Conflict
 ];
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+const defaultFailedAttemptHandler = (error) => {
+    if (error.message.startsWith("Cancel") ||
+        error.message.startsWith("TimeoutError") ||
+        error.name === "TimeoutError" ||
+        error.message.startsWith("AbortError") ||
+        error.name === "AbortError") {
+        throw error;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.code === "ECONNABORTED") {
+        throw error;
+    }
+    const status = 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    error?.response?.status ?? error?.status;
+    if (status && STATUS_NO_RETRY.includes(+status)) {
+        throw error;
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    if (error?.error?.code === "insufficient_quota") {
+        const err = new Error(error?.message);
+        err.name = "InsufficientQuotaError";
+        throw err;
+    }
+};
 /**
  * A class that can be used to make async calls with concurrency and retry logic.
  *
@@ -45,6 +71,12 @@ class AsyncCaller {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "onFailedAttempt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "queue", {
             enumerable: true,
             configurable: true,
@@ -53,6 +85,8 @@ class AsyncCaller {
         });
         this.maxConcurrency = params.maxConcurrency ?? Infinity;
         this.maxRetries = params.maxRetries ?? 6;
+        this.onFailedAttempt =
+            params.onFailedAttempt ?? defaultFailedAttemptHandler;
         const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
         this.queue = new PQueue({ concurrency: this.maxConcurrency });
     }
@@ -67,31 +101,7 @@ class AsyncCaller {
                 throw new Error(error);
             }
         }), {
-            onFailedAttempt(error) {
-                if (error.message.startsWith("Cancel") ||
-                    error.message.startsWith("TimeoutError") ||
-                    error.name === "TimeoutError" ||
-                    error.message.startsWith("AbortError") ||
-                    error.name === "AbortError") {
-                    throw error;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                if (error?.code === "ECONNABORTED") {
-                    throw error;
-                }
-                const status = 
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                error?.response?.status ?? error?.status;
-                if (status && STATUS_NO_RETRY.includes(+status)) {
-                    throw error;
-                }
-                // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                if (error?.error?.code === "insufficient_quota") {
-                    const err = new Error(error?.message);
-                    err.name = "InsufficientQuotaError";
-                    throw err;
-                }
-            },
+            onFailedAttempt: this.onFailedAttempt,
             retries: this.maxRetries,
             randomize: true,
             // If needed we can change some of the defaults here,

package/dist/util/async_caller.d.ts

@@ -1,3 +1,4 @@
+export type FailedAttemptHandler = (error: any) => any;
 export interface AsyncCallerParams {
     /**
      * The maximum number of concurrent calls that can be made.
@@ -9,6 +10,12 @@ export interface AsyncCallerParams {
      * with an exponential backoff between each attempt. Defaults to 6.
      */
     maxRetries?: number;
+    /**
+     * Custom handler to handle failed attempts. Takes the originally thrown
+     * error object as input, and should itself throw an error if the input
+     * error is not retryable.
+     */
+    onFailedAttempt?: FailedAttemptHandler;
 }
 export interface AsyncCallerCallOptions {
     signal?: AbortSignal;
@@ -29,6 +36,7 @@ export interface AsyncCallerCallOptions {
 export declare class AsyncCaller {
     protected maxConcurrency: AsyncCallerParams["maxConcurrency"];
     protected maxRetries: AsyncCallerParams["maxRetries"];
+    protected onFailedAttempt: AsyncCallerParams["onFailedAttempt"];
     private queue;
     constructor(params: AsyncCallerParams);
     call<A extends any[], T extends (...args: A) => Promise<any>>(callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;