langchain 0.0.146 → 0.0.148

package/dist/schema/{runnable.d.ts → runnable/index.d.ts}

@@ -1,11 +1,20 @@
-import { BaseCallbackConfig, CallbackManager, CallbackManagerForChainRun } from "../callbacks/manager.js";
-import { Serializable } from "../load/serializable.js";
-import { IterableReadableStream } from "../util/stream.js";
-export type RunnableConfig = BaseCallbackConfig;
+import { CallbackManager, CallbackManagerForChainRun, BaseCallbackConfig } from "../../callbacks/manager.js";
+import { Serializable } from "../../load/serializable.js";
+import { IterableReadableStream } from "../../util/stream.js";
+import { RunnableConfig as _RunnableConfig } from "./config.js";
+export type RunnableConfig = _RunnableConfig;
 export type RunnableFunc<RunInput, RunOutput> = (input: RunInput) => RunOutput | Promise<RunOutput>;
 export type RunnableLike<RunInput = any, RunOutput = any> = Runnable<RunInput, RunOutput> | RunnableFunc<RunInput, RunOutput> | {
     [key: string]: RunnableLike<RunInput, RunOutput>;
 };
+export type RunnableBatchOptions = {
+    maxConcurrency?: number;
+    returnExceptions?: boolean;
+};
+export type RunnableRetryFailedAttemptHandler = (error: any) => any;
+type RunnableConfigAndOptions = RunnableConfig & {
+    runType?: string;
+};
 /**
  * A Runnable is a generic unit of work that can be invoked, batched, streamed, and/or
  * transformed.
@@ -19,6 +28,15 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @returns A new RunnableBinding that, when invoked, will apply the bound args.
      */
     bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
+    /**
+     * 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?: {
+        stopAfterAttempt?: number;
+        onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    }): RunnableRetry<RunInput, RunOutput, CallOptions>;
     /**
      * Create a new runnable from the current one that will try invoking
      * other passed fallback runnables if the initial invocation fails.
@@ -35,11 +53,16 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @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
+     * @param batchOptions.returnExceptions Whether to return errors rather than throwing on the first one
+     * @returns An array of RunOutputs, or mixed RunOutputs and errors if batchOptions.returnExceptions is set
      */
-    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: {
-        maxConcurrency?: number;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
     }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     /**
      * Default streaming implementation.
      * Subclasses should override this method if they support streaming output.
@@ -55,9 +78,17 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      */
     stream(input: RunInput, options?: Partial<CallOptions>): Promise<IterableReadableStream<RunOutput>>;
     protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, Omit<Partial<CallOptions>, keyof RunnableConfig>];
-    protected _callWithConfig<T extends RunInput>(func: (input: T) => Promise<RunOutput>, input: T, options?: RunnableConfig & {
-        runType?: string;
-    }): Promise<RunOutput>;
+    protected _callWithConfig<T extends RunInput>(func: ((input: T) => Promise<RunOutput>) | ((input: T, config?: RunnableConfig, runManager?: CallbackManagerForChainRun) => Promise<RunOutput>), input: T, options?: RunnableConfigAndOptions): Promise<RunOutput>;
+    /**
+     * 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.
+     */
+    _batchWithConfig<T extends RunInput>(func: (inputs: T[], configs?: RunnableConfig[], runManagers?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions) => Promise<(RunOutput | Error)[]>, inputs: T[], options?: Partial<RunnableConfigAndOptions> | Partial<RunnableConfigAndOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     /**
      * Helper method to transform an Iterator of Input values into an Iterator of
      * Output values, with callbacks.
@@ -73,7 +104,7 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @param coerceable A runnable, function, or object whose values are functions or runnables.
      * @returns A new runnable sequence.
      */
-    pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, NewRunOutput>;
+    pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, Exclude<NewRunOutput, Error>>;
     /**
      * Default implementation of transform, which buffers input and then calls stream.
      * Subclasses should override this method if they can start producing output while
@@ -81,9 +112,72 @@ export declare abstract class Runnable<RunInput = any, RunOutput = any, CallOpti
      * @param generator
      * @param options
      */
-    transform?(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
     static isRunnable(thing: any): thing is Runnable;
 }
+export type RunnableBindingArgs<RunInput, RunOutput, CallOptions extends RunnableConfig> = {
+    bound: Runnable<RunInput, RunOutput, CallOptions>;
+    kwargs: Partial<CallOptions>;
+};
+/**
+ * A runnable that delegates calls to another runnable with a set of kwargs.
+ */
+export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends BaseCallbackConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    bound: Runnable<RunInput, RunOutput, CallOptions>;
+    protected kwargs: Partial<CallOptions>;
+    constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions>);
+    bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
+    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+    _streamIterator(input: RunInput, options?: Partial<CallOptions> | undefined): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
+    stream(input: RunInput, options?: Partial<CallOptions> | undefined): Promise<IterableReadableStream<RunOutput>>;
+    transform(generator: AsyncGenerator<RunInput>, options: Partial<CallOptions>): AsyncGenerator<RunOutput>;
+    static isRunnableBinding(thing: any): thing is RunnableBinding<any, any, any>;
+}
+/**
+ * Base class for runnables that can be retried a
+ * specified number of times.
+ */
+export declare class RunnableRetry<RunInput = any, RunOutput = any, CallOptions extends RunnableConfig = RunnableConfig> extends RunnableBinding<RunInput, RunOutput, CallOptions> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    protected maxAttemptNumber: number;
+    onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    constructor(fields: RunnableBindingArgs<RunInput, RunOutput, CallOptions> & {
+        maxAttemptNumber?: number;
+        onFailedAttempt?: RunnableRetryFailedAttemptHandler;
+    });
+    _patchConfigForRetry(attempt: number, config?: Partial<CallOptions>, runManager?: CallbackManagerForChainRun): Partial<CallOptions>;
+    protected _invoke(input: RunInput, config?: CallOptions, runManager?: CallbackManagerForChainRun): Promise<RunOutput>;
+    /**
+     * 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.
+     */
+    invoke(input: RunInput, config?: CallOptions): Promise<RunOutput>;
+    _batch<ReturnExceptions extends boolean = false>(inputs: RunInput[], configs?: RunnableConfig[], runManagers?: (CallbackManagerForChainRun | undefined)[], batchOptions?: RunnableBatchOptions): Promise<ReturnExceptions extends false ? RunOutput[] : (Error | RunOutput)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
+    }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
+}
 /**
  * A sequence of runnables, where the output of each is the input of the next.
  */
@@ -101,17 +195,21 @@ export declare class RunnableSequence<RunInput = any, RunOutput = any> extends R
     });
     get steps(): Runnable<RunInput, any, BaseCallbackConfig>[];
     invoke(input: RunInput, options?: RunnableConfig): Promise<RunOutput>;
-    batch(inputs: RunInput[], options?: RunnableConfig | RunnableConfig[], batchOptions?: {
-        maxConcurrency?: number;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
     }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<RunnableConfig> | Partial<RunnableConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     _streamIterator(input: RunInput, options?: RunnableConfig): AsyncGenerator<RunOutput>;
-    pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, NewRunOutput>;
+    pipe<NewRunOutput>(coerceable: RunnableLike<RunOutput, NewRunOutput>): RunnableSequence<RunInput, Exclude<NewRunOutput, Error>>;
     static isRunnableSequence(thing: any): thing is RunnableSequence;
     static from<RunInput, RunOutput>([first, ...runnables]: [
         RunnableLike<RunInput>,
         ...RunnableLike[],
         RunnableLike<any, RunOutput>
-    ]): RunnableSequence<RunInput, RunOutput>;
+    ]): RunnableSequence<RunInput, Exclude<RunOutput, Error>>;
 }
 /**
  * A runnable that runs a mapping of runnables in parallel,
@@ -148,27 +246,6 @@ export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, Ru
     lc_serializable: boolean;
     invoke(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<RunInput>;
 }
-/**
- * A runnable that delegates calls to another runnable with a set of kwargs.
- */
-export declare class RunnableBinding<RunInput, RunOutput, CallOptions extends BaseCallbackConfig> extends Runnable<RunInput, RunOutput, CallOptions> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
-    protected bound: Runnable<RunInput, RunOutput, CallOptions>;
-    protected kwargs: Partial<CallOptions>;
-    constructor(fields: {
-        bound: Runnable<RunInput, RunOutput, CallOptions>;
-        kwargs: Partial<CallOptions>;
-    });
-    bind(kwargs: Partial<CallOptions>): RunnableBinding<RunInput, RunOutput, CallOptions>;
-    invoke(input: RunInput, options?: Partial<CallOptions>): Promise<RunOutput>;
-    batch(inputs: RunInput[], options?: Partial<CallOptions> | Partial<CallOptions>[], batchOptions?: {
-        maxConcurrency?: number;
-    }): Promise<RunOutput[]>;
-    _streamIterator(input: RunInput, options?: Partial<CallOptions> | undefined): AsyncGenerator<Awaited<RunOutput>, void, unknown>;
-    stream(input: RunInput, options?: Partial<CallOptions> | undefined): Promise<IterableReadableStream<RunOutput>>;
-}
 export type RouterInput = {
     key: string;
     input: any;
@@ -186,9 +263,13 @@ export declare class RouterRunnable<RunInput extends RouterInput, RunnableInput,
         runnables: Record<string, Runnable<RunnableInput, RunOutput>>;
     });
     invoke(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<RunOutput>;
-    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: {
-        maxConcurrency?: number;
+    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
     }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
     stream(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<IterableReadableStream<RunOutput>>;
 }
 /**
@@ -206,7 +287,12 @@ export declare class RunnableWithFallbacks<RunInput, RunOutput> extends Runnable
     });
     runnables(): Generator<Runnable<RunInput, RunOutput, BaseCallbackConfig>, void, unknown>;
     invoke(input: RunInput, options?: Partial<BaseCallbackConfig>): Promise<RunOutput>;
-    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: {
-        maxConcurrency?: number;
+    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions?: false;
     }): Promise<RunOutput[]>;
+    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions & {
+        returnExceptions: true;
+    }): Promise<(RunOutput | Error)[]>;
+    batch(inputs: RunInput[], options?: Partial<BaseCallbackConfig> | Partial<BaseCallbackConfig>[], batchOptions?: RunnableBatchOptions): Promise<(RunOutput | Error)[]>;
 }
+export {};