langchain 0.0.148 → 0.0.149

package/dist/schema/runnable/passthrough.cjs

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RunnablePassthrough = void 0;
+const base_js_1 = require("./base.cjs");
+/**
+ * A runnable that passes through the input.
+ */
+class RunnablePassthrough extends base_js_1.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);
+    }
+}
+exports.RunnablePassthrough = RunnablePassthrough;

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

@@ -0,0 +1,11 @@
+import { Runnable } from "./base.js";
+import type { RunnableConfig } from "./config.js";
+/**
+ * A runnable that passes through the input.
+ */
+export declare class RunnablePassthrough<RunInput> extends Runnable<RunInput, RunInput> {
+    static lc_name(): string;
+    lc_namespace: string[];
+    lc_serializable: boolean;
+    invoke(input: RunInput, options?: Partial<RunnableConfig>): Promise<RunInput>;
+}

package/dist/schema/runnable/passthrough.js

@@ -0,0 +1,27 @@
+import { Runnable } from "./base.js";
+/**
+ * A runnable that passes through the input.
+ */
+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);
+    }
+}

package/dist/schema/runnable/router.cjs

@@ -0,0 +1,74 @@
+"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;

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

@@ -0,0 +1,29 @@
+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>>;
+}

package/dist/schema/runnable/router.js

@@ -0,0 +1,70 @@
+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);
+    }
+}

package/dist/vectorstores/opensearch.cjs

@@ -106,15 +106,17 @@ class OpenSearchVectorStore extends base_js_1.VectorStore {
      * exists, then adds the vectors and associated documents to the index.
      * @param vectors The vectors to be added to the OpenSearch index.
      * @param documents The documents associated with the vectors.
+     * @param options Optional parameter that can contain the IDs for the documents.
      * @returns Promise resolving to void.
      */
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
         await this.ensureIndexExists(vectors[0].length, this.engine, this.spaceType, this.efSearch, this.efConstruction, this.m);
+        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v4());
         const operations = vectors.flatMap((embedding, idx) => [
             {
                 index: {
                     _index: this.indexName,
-                    _id: uuid.v4(),
+                    _id: documentIds[idx],
                 },
             },
             {

package/dist/vectorstores/opensearch.d.ts

@@ -61,9 +61,12 @@ export declare class OpenSearchVectorStore extends VectorStore {
      * exists, then adds the vectors and associated documents to the index.
      * @param vectors The vectors to be added to the OpenSearch index.
      * @param documents The documents associated with the vectors.
+     * @param options Optional parameter that can contain the IDs for the documents.
      * @returns Promise resolving to void.
      */
-    addVectors(vectors: number[][], documents: Document[]): Promise<void>;
+    addVectors(vectors: number[][], documents: Document[], options?: {
+        ids?: string[];
+    }): Promise<void>;
     /**
      * Method to perform a similarity search on the OpenSearch index using a
      * query vector. It returns the k most similar documents and their scores.

package/dist/vectorstores/opensearch.js

@@ -80,15 +80,17 @@ export class OpenSearchVectorStore extends VectorStore {
      * exists, then adds the vectors and associated documents to the index.
      * @param vectors The vectors to be added to the OpenSearch index.
      * @param documents The documents associated with the vectors.
+     * @param options Optional parameter that can contain the IDs for the documents.
      * @returns Promise resolving to void.
      */
-    async addVectors(vectors, documents) {
+    async addVectors(vectors, documents, options) {
         await this.ensureIndexExists(vectors[0].length, this.engine, this.spaceType, this.efSearch, this.efConstruction, this.m);
+        const documentIds = options?.ids ?? Array.from({ length: vectors.length }, () => uuid.v4());
         const operations = vectors.flatMap((embedding, idx) => [
             {
                 index: {
                     _index: this.indexName,
-                    _id: uuid.v4(),
+                    _id: documentIds[idx],
                 },
             },
             {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "langchain",
-  "version": "0.0.148",
+  "version": "0.0.149",
   "description": "Typescript bindings for langchain",
   "type": "module",
   "engines": {