langchain 0.0.197-rc.1 → 0.0.198

package/dist/embeddings/openai.js

@@ -1 +1,239 @@
-export { OpenAIEmbeddings, } from "@langchain/openai";
+import { OpenAI as OpenAIClient } from "openai";
+import { getEnvironmentVariable } from "../util/env.js";
+import { chunkArray } from "../util/chunk.js";
+import { Embeddings } from "./base.js";
+import { getEndpoint } from "../util/azure.js";
+import { wrapOpenAIClientError } from "../util/openai.js";
+/**
+ * Class for generating embeddings using the OpenAI API. Extends the
+ * Embeddings class and implements OpenAIEmbeddingsParams and
+ * AzureOpenAIInput.
+ * @example
+ * ```typescript
+ * // Embed a query using OpenAIEmbeddings to generate embeddings for a given text
+ * const model = new OpenAIEmbeddings();
+ * const res = await model.embedQuery(
+ *   "What would be a good company name for a company that makes colorful socks?",
+ * );
+ * console.log({ res });
+ *
+ * ```
+ */
+export class OpenAIEmbeddings extends Embeddings {
+    constructor(fields, configuration) {
+        const fieldsWithDefaults = { maxConcurrency: 2, ...fields };
+        super(fieldsWithDefaults);
+        Object.defineProperty(this, "modelName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text-embedding-ada-002"
+        });
+        Object.defineProperty(this, "batchSize", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: 512
+        });
+        Object.defineProperty(this, "stripNewLines", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "timeout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiVersion", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiInstanceName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIApiDeploymentName", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "azureOpenAIBasePath", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "organization", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "client", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "clientConfig", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        let apiKey = fieldsWithDefaults?.openAIApiKey ??
+            getEnvironmentVariable("OPENAI_API_KEY");
+        const azureApiKey = fieldsWithDefaults?.azureOpenAIApiKey ??
+            getEnvironmentVariable("AZURE_OPENAI_API_KEY");
+        if (!azureApiKey && !apiKey) {
+            throw new Error("OpenAI or Azure OpenAI API key not found");
+        }
+        const azureApiInstanceName = fieldsWithDefaults?.azureOpenAIApiInstanceName ??
+            getEnvironmentVariable("AZURE_OPENAI_API_INSTANCE_NAME");
+        const azureApiDeploymentName = (fieldsWithDefaults?.azureOpenAIApiEmbeddingsDeploymentName ||
+            fieldsWithDefaults?.azureOpenAIApiDeploymentName) ??
+            (getEnvironmentVariable("AZURE_OPENAI_API_EMBEDDINGS_DEPLOYMENT_NAME") ||
+                getEnvironmentVariable("AZURE_OPENAI_API_DEPLOYMENT_NAME"));
+        const azureApiVersion = fieldsWithDefaults?.azureOpenAIApiVersion ??
+            getEnvironmentVariable("AZURE_OPENAI_API_VERSION");
+        this.azureOpenAIBasePath =
+            fieldsWithDefaults?.azureOpenAIBasePath ??
+                getEnvironmentVariable("AZURE_OPENAI_BASE_PATH");
+        this.organization =
+            fieldsWithDefaults?.configuration?.organization ??
+                getEnvironmentVariable("OPENAI_ORGANIZATION");
+        this.modelName = fieldsWithDefaults?.modelName ?? this.modelName;
+        this.batchSize =
+            fieldsWithDefaults?.batchSize ?? (azureApiKey ? 1 : this.batchSize);
+        this.stripNewLines =
+            fieldsWithDefaults?.stripNewLines ?? this.stripNewLines;
+        this.timeout = fieldsWithDefaults?.timeout;
+        this.azureOpenAIApiVersion = azureApiVersion;
+        this.azureOpenAIApiKey = azureApiKey;
+        this.azureOpenAIApiInstanceName = azureApiInstanceName;
+        this.azureOpenAIApiDeploymentName = azureApiDeploymentName;
+        if (this.azureOpenAIApiKey) {
+            if (!this.azureOpenAIApiInstanceName && !this.azureOpenAIBasePath) {
+                throw new Error("Azure OpenAI API instance name not found");
+            }
+            if (!this.azureOpenAIApiDeploymentName) {
+                throw new Error("Azure OpenAI API deployment name not found");
+            }
+            if (!this.azureOpenAIApiVersion) {
+                throw new Error("Azure OpenAI API version not found");
+            }
+            apiKey = apiKey ?? "";
+        }
+        this.clientConfig = {
+            apiKey,
+            organization: this.organization,
+            baseURL: configuration?.basePath,
+            dangerouslyAllowBrowser: true,
+            defaultHeaders: configuration?.baseOptions?.headers,
+            defaultQuery: configuration?.baseOptions?.params,
+            ...configuration,
+            ...fields?.configuration,
+        };
+    }
+    /**
+     * Method to generate embeddings for an array of documents. Splits the
+     * documents into batches and makes requests to the OpenAI API to generate
+     * embeddings.
+     * @param texts Array of documents to generate embeddings for.
+     * @returns Promise that resolves to a 2D array of embeddings for each document.
+     */
+    async embedDocuments(texts) {
+        const batches = chunkArray(this.stripNewLines ? texts.map((t) => t.replace(/\n/g, " ")) : texts, this.batchSize);
+        const batchRequests = batches.map((batch) => this.embeddingWithRetry({
+            model: this.modelName,
+            input: batch,
+        }));
+        const batchResponses = await Promise.all(batchRequests);
+        const embeddings = [];
+        for (let i = 0; i < batchResponses.length; i += 1) {
+            const batch = batches[i];
+            const { data: batchResponse } = batchResponses[i];
+            for (let j = 0; j < batch.length; j += 1) {
+                embeddings.push(batchResponse[j].embedding);
+            }
+        }
+        return embeddings;
+    }
+    /**
+     * Method to generate an embedding for a single document. Calls the
+     * embeddingWithRetry method with the document as the input.
+     * @param text Document to generate an embedding for.
+     * @returns Promise that resolves to an embedding for the document.
+     */
+    async embedQuery(text) {
+        const { data } = await this.embeddingWithRetry({
+            model: this.modelName,
+            input: this.stripNewLines ? text.replace(/\n/g, " ") : text,
+        });
+        return data[0].embedding;
+    }
+    /**
+     * Private method to make a request to the OpenAI API to generate
+     * embeddings. Handles the retry logic and returns the response from the
+     * API.
+     * @param request Request to send to the OpenAI API.
+     * @returns Promise that resolves to the response from the API.
+     */
+    async embeddingWithRetry(request) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new OpenAIClient(params);
+        }
+        const requestOptions = {};
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.embeddings.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = wrapOpenAIClientError(e);
+                throw error;
+            }
+        });
+    }
+}

package/dist/experimental/openai_assistant/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIAssistantRunnable = void 0;
-const openai_1 = require("@langchain/openai");
+const openai_1 = require("openai");
 const base_js_1 = require("../../schema/runnable/base.cjs");
 const time_js_1 = require("../../util/time.cjs");
 const base_js_2 = require("../../tools/base.cjs");
@@ -39,7 +39,7 @@ class OpenAIAssistantRunnable extends base_js_1.Runnable {
             writable: true,
             value: void 0
         });
-        this.client = fields.client ?? new openai_1.OpenAIClient(fields?.clientOptions);
+        this.client = fields.client ?? new openai_1.OpenAI(fields?.clientOptions);
         this.assistantId = fields.assistantId;
         this.asAgent = fields.asAgent ?? this.asAgent;
     }
@@ -51,7 +51,7 @@ class OpenAIAssistantRunnable extends base_js_1.Runnable {
             }
             return tool;
         }) ?? [];
-        const oaiClient = client ?? new openai_1.OpenAIClient(clientOptions);
+        const oaiClient = client ?? new openai_1.OpenAI(clientOptions);
         const assistant = await oaiClient.beta.assistants.create({
             name,
             instructions,
@@ -109,6 +109,38 @@ class OpenAIAssistantRunnable extends base_js_1.Runnable {
         }
         return this._getResponse(run.id, run.thread_id);
     }
+    /**
+     * Delete an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/deleteAssistant}
+     * @returns {Promise<AssistantDeleted>}
+     */
+    async deleteAssistant() {
+        return await this.client.beta.assistants.del(this.assistantId);
+    }
+    /**
+     * Retrieves an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/getAssistant}
+     * @returns {Promise<OpenAIClient.Beta.Assistants.Assistant>}
+     */
+    async getAssistant() {
+        return await this.client.beta.assistants.retrieve(this.assistantId);
+    }
+    /**
+     * Modifies an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/modifyAssistant}
+     * @returns {Promise<OpenAIClient.Beta.Assistants.Assistant>}
+     */
+    async modifyAssistant({ model, name, instructions, fileIds, }) {
+        return await this.client.beta.assistants.update(this.assistantId, {
+            name,
+            instructions,
+            model,
+            file_ids: fileIds,
+        });
+    }
     async _parseStepsInput(input) {
         const { action: { runId, threadId }, } = input.steps[input.steps.length - 1];
         const run = await this._waitForRun(runId, threadId);

package/dist/experimental/openai_assistant/index.d.ts

@@ -1,4 +1,4 @@
-import { type ClientOptions, OpenAIClient } from "@langchain/openai";
+import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { Runnable } from "../../schema/runnable/base.js";
 import type { RunnableConfig } from "../../schema/runnable/config.js";
 import type { OpenAIAssistantFinish, OpenAIAssistantAction, OpenAIToolType } from "./schema.js";
@@ -28,6 +28,32 @@ export declare class OpenAIAssistantRunnable<AsAgent extends boolean | undefined
         fileIds?: string[];
     }): Promise<OpenAIAssistantRunnable<AsAgent, Record<string, any>>>;
     invoke(input: RunInput, _options?: RunnableConfig): Promise<ExtractRunOutput<AsAgent>>;
+    /**
+     * Delete an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/deleteAssistant}
+     * @returns {Promise<AssistantDeleted>}
+     */
+    deleteAssistant(): Promise<OpenAIClient.Beta.Assistants.AssistantDeleted>;
+    /**
+     * Retrieves an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/getAssistant}
+     * @returns {Promise<OpenAIClient.Beta.Assistants.Assistant>}
+     */
+    getAssistant(): Promise<OpenAIClient.Beta.Assistants.Assistant>;
+    /**
+     * Modifies an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/modifyAssistant}
+     * @returns {Promise<OpenAIClient.Beta.Assistants.Assistant>}
+     */
+    modifyAssistant<AsAgent extends boolean>({ model, name, instructions, fileIds, }: Omit<OpenAIAssistantRunnableInput<AsAgent>, "assistantId" | "tools"> & {
+        model?: string;
+        name?: string;
+        instructions?: string;
+        fileIds?: string[];
+    }): Promise<OpenAIClient.Beta.Assistants.Assistant>;
     private _parseStepsInput;
     private _createRun;
     private _createThreadAndRun;

package/dist/experimental/openai_assistant/index.js

@@ -1,4 +1,4 @@
-import { OpenAIClient } from "@langchain/openai";
+import { OpenAI as OpenAIClient } from "openai";
 import { Runnable } from "../../schema/runnable/base.js";
 import { sleep } from "../../util/time.js";
 import { StructuredTool } from "../../tools/base.js";
@@ -106,6 +106,38 @@ export class OpenAIAssistantRunnable extends Runnable {
         }
         return this._getResponse(run.id, run.thread_id);
     }
+    /**
+     * Delete an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/deleteAssistant}
+     * @returns {Promise<AssistantDeleted>}
+     */
+    async deleteAssistant() {
+        return await this.client.beta.assistants.del(this.assistantId);
+    }
+    /**
+     * Retrieves an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/getAssistant}
+     * @returns {Promise<OpenAIClient.Beta.Assistants.Assistant>}
+     */
+    async getAssistant() {
+        return await this.client.beta.assistants.retrieve(this.assistantId);
+    }
+    /**
+     * Modifies an assistant.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/assistants/modifyAssistant}
+     * @returns {Promise<OpenAIClient.Beta.Assistants.Assistant>}
+     */
+    async modifyAssistant({ model, name, instructions, fileIds, }) {
+        return await this.client.beta.assistants.update(this.assistantId, {
+            name,
+            instructions,
+            model,
+            file_ids: fileIds,
+        });
+    }
     async _parseStepsInput(input) {
         const { action: { runId, threadId }, } = input.steps[input.steps.length - 1];
         const run = await this._waitForRun(runId, threadId);

package/dist/experimental/openai_assistant/schema.d.ts

@@ -1,4 +1,4 @@
-import type { OpenAIClient } from "@langchain/openai";
+import type { OpenAI as OpenAIClient } from "openai";
 import type { AgentFinish, AgentAction } from "../../schema/index.js";
 export type OpenAIAssistantFinish = AgentFinish & {
     runId: string;

package/dist/experimental/openai_files/index.cjs

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.OpenAIFiles = void 0;
-const openai_1 = require("@langchain/openai");
+const openai_1 = require("openai");
 const serializable_js_1 = require("../../load/serializable.cjs");
 class OpenAIFiles extends serializable_js_1.Serializable {
     constructor(fields) {
@@ -18,7 +18,7 @@ class OpenAIFiles extends serializable_js_1.Serializable {
             writable: true,
             value: void 0
         });
-        this.oaiClient = fields?.client ?? new openai_1.OpenAIClient(fields?.clientOptions);
+        this.oaiClient = fields?.client ?? new openai_1.OpenAI(fields?.clientOptions);
     }
     /**
      * Upload file

package/dist/experimental/openai_files/index.d.ts

@@ -1,4 +1,4 @@
-import { OpenAIClient, type ClientOptions } from "@langchain/openai";
+import { OpenAI as OpenAIClient, type ClientOptions } from "openai";
 import { Serializable } from "../../load/serializable.js";
 export type OpenAIFilesInput = {
     client?: OpenAIClient;

package/dist/experimental/openai_files/index.js

@@ -1,4 +1,4 @@
-import { OpenAIClient } from "@langchain/openai";
+import { OpenAI as OpenAIClient } from "openai";
 import { Serializable } from "../../load/serializable.js";
 export class OpenAIFiles extends Serializable {
     constructor(fields) {

package/dist/experimental/tools/pyinterpreter.cjs

@@ -0,0 +1,248 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PythonInterpreterTool = void 0;
+const pyodide_1 = require("pyodide");
+const base_js_1 = require("../../tools/base.cjs");
+class PythonInterpreterTool extends base_js_1.Tool {
+    static lc_name() {
+        return "PythonInterpreterTool";
+    }
+    constructor(options) {
+        super(options);
+        Object.defineProperty(this, "name", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "python_interpreter"
+        });
+        Object.defineProperty(this, "description", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: `Evaluates python code in a sandbox environment. The environment resets on every execution. You must send the whole script every time and print your outputs. Script should be pure python code that can be evaluated. Packages available:
+${this.availableDefaultPackages}`
+        });
+        Object.defineProperty(this, "pyodideInstance", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "stdout", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        Object.defineProperty(this, "stderr", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ""
+        });
+        this.pyodideInstance = options.instance;
+        this.pyodideInstance.setStderr({
+            batched: (text) => {
+                this.stderr += text;
+            },
+        });
+        this.pyodideInstance.setStdout({
+            batched: (text) => {
+                this.stdout += text;
+            },
+        });
+    }
+    async addPackage(packageName) {
+        await this.pyodideInstance.loadPackage(packageName);
+        this.description += `, ${packageName}`;
+    }
+    get availableDefaultPackages() {
+        return [
+            "asciitree",
+            "astropy",
+            "atomicwrites",
+            "attrs",
+            "autograd",
+            "awkward-cpp",
+            "bcrypt",
+            "beautifulsoup4",
+            "biopython",
+            "bitarray",
+            "bitstring",
+            "bleach",
+            "bokeh",
+            "boost-histogram",
+            "brotli",
+            "cachetools",
+            "Cartopy",
+            "cbor-diag",
+            "certifi",
+            "cffi",
+            "cffi_example",
+            "cftime",
+            "click",
+            "cligj",
+            "cloudpickle",
+            "cmyt",
+            "colorspacious",
+            "contourpy",
+            "coolprop",
+            "coverage",
+            "cramjam",
+            "cryptography",
+            "cssselect",
+            "cycler",
+            "cytoolz",
+            "decorator",
+            "demes",
+            "deprecation",
+            "distlib",
+            "docutils",
+            "exceptiongroup",
+            "fastparquet",
+            "fiona",
+            "fonttools",
+            "freesasa",
+            "fsspec",
+            "future",
+            "galpy",
+            "gensim",
+            "geopandas",
+            "gmpy2",
+            "gsw",
+            "h5py",
+            "html5lib",
+            "idna",
+            "igraph",
+            "imageio",
+            "iniconfig",
+            "jedi",
+            "Jinja2",
+            "joblib",
+            "jsonschema",
+            "kiwisolver",
+            "lazy-object-proxy",
+            "lazy_loader",
+            "lightgbm",
+            "logbook",
+            "lxml",
+            "MarkupSafe",
+            "matplotlib",
+            "matplotlib-pyodide",
+            "micropip",
+            "mne",
+            "more-itertools",
+            "mpmath",
+            "msgpack",
+            "msprime",
+            "multidict",
+            "munch",
+            "mypy",
+            "netcdf4",
+            "networkx",
+            "newick",
+            "nlopt",
+            "nltk",
+            "nose",
+            "numcodecs",
+            "numpy",
+            "opencv-python",
+            "optlang",
+            "orjson",
+            "packaging",
+            "pandas",
+            "parso",
+            "patsy",
+            "peewee",
+            "Pillow",
+            "pillow_heif",
+            "pkgconfig",
+            "pluggy",
+            "protobuf",
+            "py",
+            "pyb2d",
+            "pyclipper",
+            "pycparser",
+            "pycryptodome",
+            "pydantic",
+            "pyerfa",
+            "Pygments",
+            "pyheif",
+            "pyinstrument",
+            "pynacl",
+            "pyodide-http",
+            "pyodide-tblib",
+            "pyparsing",
+            "pyproj",
+            "pyrsistent",
+            "pyshp",
+            "pytest",
+            "pytest-benchmark",
+            "python-dateutil",
+            "python-magic",
+            "python-sat",
+            "python_solvespace",
+            "pytz",
+            "pywavelets",
+            "pyxel",
+            "pyyaml",
+            "rebound",
+            "reboundx",
+            "regex",
+            "retrying",
+            "RobotRaconteur",
+            "ruamel.yaml",
+            "rust-panic-test",
+            "scikit-image",
+            "scikit-learn",
+            "scipy",
+            "screed",
+            "setuptools",
+            "shapely",
+            "simplejson",
+            "six",
+            "smart_open",
+            "soupsieve",
+            "sourmash",
+            "sparseqr",
+            "sqlalchemy",
+            "statsmodels",
+            "svgwrite",
+            "swiglpk",
+            "sympy",
+            "termcolor",
+            "texttable",
+            "threadpoolctl",
+            "tomli",
+            "tomli-w",
+            "toolz",
+            "tqdm",
+            "traits",
+            "tskit",
+            "typing-extensions",
+            "uncertainties",
+            "unyt",
+            "webencodings",
+            "wordcloud",
+            "wrapt",
+            "xarray",
+            "xgboost",
+            "xlrd",
+            "xyzservices",
+            "yarl",
+            "yt",
+            "zarr",
+        ].join(", ");
+    }
+    static async initialize(options) {
+        const instance = await (0, pyodide_1.loadPyodide)(options);
+        return new this({ ...options, instance });
+    }
+    async _call(script) {
+        this.stdout = "";
+        this.stderr = "";
+        await this.pyodideInstance.runPythonAsync(script);
+        return JSON.stringify({ stdout: this.stdout, stderr: this.stderr });
+    }
+}
+exports.PythonInterpreterTool = PythonInterpreterTool;