langchain 0.0.194 → 0.0.196

package/dist/schema/runnable/passthrough.js

@@ -1,111 +1 @@
-import { Runnable, RunnableMap } from "./base.js";
-/**
- * A runnable that assigns key-value pairs to inputs of type `Record<string, unknown>`.
- */
-export class RunnableAssign extends Runnable {
-    constructor(mapper) {
-        super();
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "schema", "runnable"]
-        });
-        Object.defineProperty(this, "mapper", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.mapper = mapper;
-    }
-    async invoke(input, options) {
-        const mapperResult = await this.mapper.invoke(input, options);
-        return {
-            ...input,
-            ...mapperResult,
-        };
-    }
-}
-/**
- * A runnable to passthrough inputs unchanged or with additional keys.
- *
- * This runnable behaves almost like the identity function, except that it
- * can be configured to add additional keys to the output, if the input is
- * an object.
- *
- * The example below demonstrates how to use `RunnablePassthrough to
- * passthrough the input from the `.invoke()`
- *
- * @example
- * ```typescript
- * const chain = RunnableSequence.from([
- *   {
- *     question: new RunnablePassthrough(),
- *     context: async () => loadContextFromStore(),
- *   },
- *   prompt,
- *   llm,
- *   outputParser,
- * ]);
- * const response = await chain.invoke(
- *   "I can pass a single string instead of an object since I'm using `RunnablePassthrough`."
- * );
- * ```
- */
-export class RunnablePassthrough extends Runnable {
-    constructor() {
-        super(...arguments);
-        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
-        });
-    }
-    static lc_name() {
-        return "RunnablePassthrough";
-    }
-    async invoke(input, options) {
-        return this._callWithConfig((input) => Promise.resolve(input), input, options);
-    }
-    /**
-     * A runnable that assigns key-value pairs to the input.
-     *
-     * The example below shows how you could use it with an inline function.
-     *
-     * @example
-     * ```typescript
-     * const prompt =
-     *   PromptTemplate.fromTemplate(`Write a SQL query to answer the question using the following schema: {schema}
-     * Question: {question}
-     * SQL Query:`);
-     *
-     * // The `RunnablePassthrough.assign()` is used here to passthrough the input from the `.invoke()`
-     * // call (in this example it's the question), along with any inputs passed to the `.assign()` method.
-     * // In this case, we're passing the schema.
-     * const sqlQueryGeneratorChain = RunnableSequence.from([
-     *   RunnablePassthrough.assign({
-     *     schema: async () => db.getTableInfo(),
-     *   }),
-     *   prompt,
-     *   new ChatOpenAI({}).bind({ stop: ["\nSQLResult:"] }),
-     *   new StringOutputParser(),
-     * ]);
-     * const result = await sqlQueryGeneratorChain.invoke({
-     *   question: "How many employees are there?",
-     * });
-     * ```
-     */
-    static assign(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    mapping) {
-        return new RunnableAssign(new RunnableMap({ steps: mapping }));
-    }
-}
+export { RunnableAssign, RunnablePassthrough } from "langchain-core/runnables";

package/dist/schema/runnable/router.cjs

@@ -1,74 +1,5 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouterRunnable = void 0;
-const base_js_1 = require("./base.cjs");
-/**
- * A runnable that routes to a set of runnables based on Input['key'].
- * Returns the output of the selected runnable.
- */
-class RouterRunnable extends base_js_1.Runnable {
-    static lc_name() {
-        return "RouterRunnable";
-    }
-    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, "runnables", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.runnables = fields.runnables;
-    }
-    async invoke(input, options) {
-        const { key, input: actualInput } = input;
-        const runnable = this.runnables[key];
-        if (runnable === undefined) {
-            throw new Error(`No runnable associated with key "${key}".`);
-        }
-        return runnable.invoke(actualInput, options);
-    }
-    async batch(inputs, options, batchOptions) {
-        const keys = inputs.map((input) => input.key);
-        const actualInputs = inputs.map((input) => input.input);
-        const missingKey = keys.find((key) => this.runnables[key] === undefined);
-        if (missingKey !== undefined) {
-            throw new Error(`One or more keys do not have a corresponding runnable.`);
-        }
-        const runnables = keys.map((key) => this.runnables[key]);
-        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
-        const batchResults = [];
-        for (let i = 0; i < actualInputs.length; i += batchSize) {
-            const batchPromises = actualInputs
-                .slice(i, i + batchSize)
-                .map((actualInput, i) => runnables[i].invoke(actualInput, optionsList[i]));
-            const batchResult = await Promise.all(batchPromises);
-            batchResults.push(batchResult);
-        }
-        return batchResults.flat();
-    }
-    async stream(input, options) {
-        const { key, input: actualInput } = input;
-        const runnable = this.runnables[key];
-        if (runnable === undefined) {
-            throw new Error(`No runnable associated with key "${key}".`);
-        }
-        return runnable.stream(actualInput, options);
-    }
-}
-exports.RouterRunnable = RouterRunnable;
+var runnables_1 = require("langchain-core/runnables");
+Object.defineProperty(exports, "RouterRunnable", { enumerable: true, get: function () { return runnables_1.RouterRunnable; } });

package/dist/schema/runnable/router.d.ts

@@ -1,29 +1 @@
-import { Runnable, type RunnableBatchOptions } from "./base.js";
-import { IterableReadableStream } from "../../util/stream.js";
-import type { RunnableConfig } from "./config.js";
-export type RouterInput = {
-    key: string;
-    input: any;
-};
-/**
- * A runnable that routes to a set of runnables based on Input['key'].
- * Returns the output of the selected runnable.
- */
-export declare class RouterRunnable<RunInput extends RouterInput, RunnableInput, RunOutput> extends Runnable<RunInput, RunOutput> {
-    static lc_name(): string;
-    lc_namespace: string[];
-    lc_serializable: boolean;
-    runnables: Record<string, Runnable<RunnableInput, RunOutput>>;
-    constructor(fields: {
-        runnables: Record<string, Runnable<RunnableInput, RunOutput>>;
-    });
-    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunOutput>;
-    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)[]>;
-    stream(input: RunInput, options?: Partial<RunnableConfig>): Promise<IterableReadableStream<RunOutput>>;
-}
+export { type RouterInput, RouterRunnable } from "langchain-core/runnables";

package/dist/schema/runnable/router.js

@@ -1,70 +1 @@
-import { Runnable } from "./base.js";
-/**
- * A runnable that routes to a set of runnables based on Input['key'].
- * Returns the output of the selected runnable.
- */
-export class RouterRunnable extends Runnable {
-    static lc_name() {
-        return "RouterRunnable";
-    }
-    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, "runnables", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.runnables = fields.runnables;
-    }
-    async invoke(input, options) {
-        const { key, input: actualInput } = input;
-        const runnable = this.runnables[key];
-        if (runnable === undefined) {
-            throw new Error(`No runnable associated with key "${key}".`);
-        }
-        return runnable.invoke(actualInput, options);
-    }
-    async batch(inputs, options, batchOptions) {
-        const keys = inputs.map((input) => input.key);
-        const actualInputs = inputs.map((input) => input.input);
-        const missingKey = keys.find((key) => this.runnables[key] === undefined);
-        if (missingKey !== undefined) {
-            throw new Error(`One or more keys do not have a corresponding runnable.`);
-        }
-        const runnables = keys.map((key) => this.runnables[key]);
-        const optionsList = this._getOptionsList(options ?? {}, inputs.length);
-        const batchSize = batchOptions?.maxConcurrency && batchOptions.maxConcurrency > 0
-            ? batchOptions?.maxConcurrency
-            : inputs.length;
-        const batchResults = [];
-        for (let i = 0; i < actualInputs.length; i += batchSize) {
-            const batchPromises = actualInputs
-                .slice(i, i + batchSize)
-                .map((actualInput, i) => runnables[i].invoke(actualInput, optionsList[i]));
-            const batchResult = await Promise.all(batchPromises);
-            batchResults.push(batchResult);
-        }
-        return batchResults.flat();
-    }
-    async stream(input, options) {
-        const { key, input: actualInput } = input;
-        const runnable = this.runnables[key];
-        if (runnable === undefined) {
-            throw new Error(`No runnable associated with key "${key}".`);
-        }
-        return runnable.stream(actualInput, options);
-    }
-}
+export { RouterRunnable } from "langchain-core/runnables";

package/dist/schema/storage.cjs

@@ -1,10 +1,17 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseStore = void 0;
-const serializable_js_1 = require("../load/serializable.cjs");
-/**
- * Abstract interface for a key-value store.
- */
-class BaseStore extends serializable_js_1.Serializable {
-}
-exports.BaseStore = BaseStore;
+__exportStar(require("langchain-core/schema/storage"), exports);

package/dist/schema/storage.d.ts

@@ -1,57 +1 @@
-import { Serializable } from "../load/serializable.js";
-/** @deprecated For backwards compatibility only. Remove on next minor version upgrade. */
-export interface BaseStoreInterface<K, V> {
-    /**
-     * Method to get multiple values for a set of keys.
-     * @param {K[]} keys - An array of keys.
-     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.
-     */
-    mget(keys: K[]): Promise<(V | undefined)[]>;
-    /**
-     * Method to set a value for multiple keys.
-     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.
-     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.
-     */
-    mset(keyValuePairs: [K, V][]): Promise<void>;
-    /**
-     * Method to delete multiple keys.
-     * @param {K[]} keys - An array of keys to delete.
-     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.
-     */
-    mdelete(keys: K[]): Promise<void>;
-    /**
-     * Method to yield keys optionally based on a prefix.
-     * @param {string} prefix - Optional prefix to filter keys.
-     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.
-     */
-    yieldKeys(prefix?: string): AsyncGenerator<K | string>;
-}
-/**
- * Abstract interface for a key-value store.
- */
-export declare abstract class BaseStore<K, V> extends Serializable implements BaseStoreInterface<K, V> {
-    /**
-     * Abstract method to get multiple values for a set of keys.
-     * @param {K[]} keys - An array of keys.
-     * @returns {Promise<(V | undefined)[]>} - A Promise that resolves with array of values or undefined if key not found.
-     */
-    abstract mget(keys: K[]): Promise<(V | undefined)[]>;
-    /**
-     * Abstract method to set a value for multiple keys.
-     * @param {[K, V][]} keyValuePairs - An array of key-value pairs.
-     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.
-     */
-    abstract mset(keyValuePairs: [K, V][]): Promise<void>;
-    /**
-     * Abstract method to delete multiple keys.
-     * @param {K[]} keys - An array of keys to delete.
-     * @returns {Promise<void>} - A Promise that resolves when the operation is complete.
-     */
-    abstract mdelete(keys: K[]): Promise<void>;
-    /**
-     * Abstract method to yield keys optionally based on a prefix.
-     * @param {string} prefix - Optional prefix to filter keys.
-     * @returns {AsyncGenerator<K | string>} - An asynchronous generator that yields keys on iteration.
-     */
-    abstract yieldKeys(prefix?: string): AsyncGenerator<K | string>;
-}
+export * from "langchain-core/schema/storage";

package/dist/schema/storage.js

@@ -1,6 +1 @@
-import { Serializable } from "../load/serializable.js";
-/**
- * Abstract interface for a key-value store.
- */
-export class BaseStore extends Serializable {
-}
+export * from "langchain-core/schema/storage";

package/dist/tools/bingserpapi.d.ts

@@ -11,7 +11,7 @@ declare class BingSerpAPI extends Tool {
     /**
      * Not implemented. Will throw an error if called.
      */
-    toJSON(): import("../load/serializable.js").SerializedNotImplemented;
+    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
     name: string;
     description: string;
     key: string;

package/dist/tools/searchapi.d.ts

@@ -62,7 +62,7 @@ export declare class SearchApi extends Tool {
      * and will throw an error if called.
      * @returns Throws an error.
      */
-    toJSON(): import("../load/serializable.js").SerializedNotImplemented;
+    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
     protected apiKey: string;
     protected params: Partial<SearchApiParameters>;
     constructor(apiKey?: string | undefined, params?: Partial<SearchApiParameters>);

package/dist/tools/serpapi.d.ts

@@ -281,7 +281,7 @@ type UrlParameters = Record<string, string | number | boolean | undefined | null
  */
 export declare class SerpAPI extends Tool {
     static lc_name(): string;
-    toJSON(): import("../load/serializable.js").SerializedNotImplemented;
+    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
     protected key: string;
     protected params: Partial<SerpAPIParameters>;
     protected baseUrl: string;

package/dist/tools/serper.d.ts

@@ -21,7 +21,7 @@ export declare class Serper extends Tool {
      * and will throw an error if called.
      * @returns Throws an error.
      */
-    toJSON(): import("../load/serializable.js").SerializedNotImplemented;
+    toJSON(): import("langchain-core/load/serializable").SerializedNotImplemented;
     protected key: string;
     protected params: Partial<SerperParameters>;
     constructor(apiKey?: string | undefined, params?: Partial<SerperParameters>);

package/dist/util/async_caller.cjs

@@ -1,131 +1,17 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AsyncCaller = void 0;
-const p_retry_1 = __importDefault(require("p-retry"));
-const p_queue_1 = __importDefault(require("p-queue"));
-const STATUS_NO_RETRY = [
-    400,
-    401,
-    402,
-    403,
-    404,
-    405,
-    406,
-    407,
-    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.
- *
- * This is useful for making calls to any kind of "expensive" external resource,
- * be it because it's rate-limited, subject to network issues, etc.
- *
- * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
- * to `Infinity`. This means that by default, all calls will be made in parallel.
- *
- * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
- * means that by default, each call will be retried up to 6 times, with an
- * exponential backoff between each attempt.
- */
-class AsyncCaller {
-    constructor(params) {
-        Object.defineProperty(this, "maxConcurrency", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "maxRetries", {
-            enumerable: true,
-            configurable: true,
-            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,
-            writable: true,
-            value: void 0
-        });
-        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 });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    call(callable, ...args) {
-        return this.queue.add(() => (0, p_retry_1.default)(() => callable(...args).catch((error) => {
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            if (error instanceof Error) {
-                throw error;
-            }
-            else {
-                throw new Error(error);
-            }
-        }), {
-            onFailedAttempt: this.onFailedAttempt,
-            retries: this.maxRetries,
-            randomize: true,
-            // If needed we can change some of the defaults here,
-            // but they're quite sensible.
-        }), { throwOnTimeout: true });
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    callWithOptions(options, callable, ...args) {
-        // Note this doesn't cancel the underlying request,
-        // when available prefer to use the signal option of the underlying call
-        if (options.signal) {
-            return Promise.race([
-                this.call(callable, ...args),
-                new Promise((_, reject) => {
-                    options.signal?.addEventListener("abort", () => {
-                        reject(new Error("AbortError"));
-                    });
-                }),
-            ]);
-        }
-        return this.call(callable, ...args);
-    }
-    fetch(...args) {
-        return this.call(() => fetch(...args).then((res) => (res.ok ? res : Promise.reject(res))));
-    }
-}
-exports.AsyncCaller = AsyncCaller;
+__exportStar(require("langchain-core/util/async_caller"), exports);

package/dist/util/async_caller.d.ts

@@ -1,45 +1 @@
-export type FailedAttemptHandler = (error: any) => any;
-export interface AsyncCallerParams {
-    /**
-     * The maximum number of concurrent calls that can be made.
-     * Defaults to `Infinity`, which means no limit.
-     */
-    maxConcurrency?: number;
-    /**
-     * The maximum number of retries that can be made for a single call,
-     * 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;
-}
-/**
- * A class that can be used to make async calls with concurrency and retry logic.
- *
- * This is useful for making calls to any kind of "expensive" external resource,
- * be it because it's rate-limited, subject to network issues, etc.
- *
- * Concurrent calls are limited by the `maxConcurrency` parameter, which defaults
- * to `Infinity`. This means that by default, all calls will be made in parallel.
- *
- * Retries are limited by the `maxRetries` parameter, which defaults to 6. This
- * means that by default, each call will be retried up to 6 times, with an
- * exponential backoff between each attempt.
- */
-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>>>;
-    callWithOptions<A extends any[], T extends (...args: A) => Promise<any>>(options: AsyncCallerCallOptions, callable: T, ...args: Parameters<T>): Promise<Awaited<ReturnType<T>>>;
-    fetch(...args: Parameters<typeof fetch>): ReturnType<typeof fetch>;
-}
+export * from "langchain-core/util/async_caller";