langchain 0.0.197 → 0.0.198

package/dist/chat_models/llama_cpp.cjs

@@ -4,6 +4,7 @@ exports.ChatLlamaCpp = void 0;
 const node_llama_cpp_1 = require("node-llama-cpp");
 const base_js_1 = require("./base.cjs");
 const llama_cpp_js_1 = require("../util/llama_cpp.cjs");
+const index_js_1 = require("../schema/index.cjs");
 /**
  *  To use this model you need to have the `node-llama-cpp` module installed.
  *  This can be installed using `npm install -S node-llama-cpp` and the minimum
@@ -139,6 +140,29 @@ class ChatLlamaCpp extends base_js_1.SimpleChatModel {
             throw new Error("Error getting prompt completion.");
         }
     }
+    async *_streamResponseChunks(input, _options, runManager) {
+        if (input.length !== 1) {
+            throw new Error("Only one human message should be provided.");
+        }
+        else {
+            const promptOptions = {
+                temperature: this?.temperature,
+                topK: this?.topK,
+                topP: this?.topP,
+            };
+            const stream = await this.caller.call(async () => this._context.evaluate(this._context.encode(`${input[0].content}`), promptOptions));
+            for await (const chunk of stream) {
+                yield new index_js_1.ChatGenerationChunk({
+                    text: this._context.decode([chunk]),
+                    message: new index_js_1.AIMessageChunk({
+                        content: this._context.decode([chunk]),
+                    }),
+                    generationInfo: {},
+                });
+                await runManager?.handleLLMNewToken(this._context.decode([chunk]) ?? "");
+            }
+        }
+    }
     // This constructs a new session if we need to adding in any sys messages or previous chats
     _buildSession(messages) {
         let prompt = "";

package/dist/chat_models/llama_cpp.d.ts

@@ -2,7 +2,8 @@ import { LlamaModel, LlamaContext, LlamaChatSession, type ConversationInteractio
 import { SimpleChatModel, BaseChatModelParams } from "./base.js";
 import { LlamaBaseCppInputs } from "../util/llama_cpp.js";
 import { BaseLanguageModelCallOptions } from "../base_language/index.js";
-import type { BaseMessage } from "../schema/index.js";
+import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { BaseMessage, ChatGenerationChunk } from "../schema/index.js";
 /**
  * Note that the modelPath is the only required parameter. For testing you
  * can set this in the environment variable `LLAMA_PATH`.
@@ -63,6 +64,7 @@ export declare class ChatLlamaCpp extends SimpleChatModel<LlamaCppCallOptions> {
     };
     /** @ignore */
     _call(messages: BaseMessage[], _options: this["ParsedCallOptions"]): Promise<string>;
+    _streamResponseChunks(input: BaseMessage[], _options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
     protected _buildSession(messages: BaseMessage[]): string;
     protected _convertMessagesToInteractions(messages: BaseMessage[]): ConversationInteraction[];
 }

package/dist/chat_models/llama_cpp.js

@@ -1,6 +1,7 @@
 import { LlamaChatSession, } from "node-llama-cpp";
 import { SimpleChatModel } from "./base.js";
 import { createLlamaModel, createLlamaContext, } from "../util/llama_cpp.js";
+import { ChatGenerationChunk, AIMessageChunk, } from "../schema/index.js";
 /**
  *  To use this model you need to have the `node-llama-cpp` module installed.
  *  This can be installed using `npm install -S node-llama-cpp` and the minimum
@@ -136,6 +137,29 @@ export class ChatLlamaCpp extends SimpleChatModel {
             throw new Error("Error getting prompt completion.");
         }
     }
+    async *_streamResponseChunks(input, _options, runManager) {
+        if (input.length !== 1) {
+            throw new Error("Only one human message should be provided.");
+        }
+        else {
+            const promptOptions = {
+                temperature: this?.temperature,
+                topK: this?.topK,
+                topP: this?.topP,
+            };
+            const stream = await this.caller.call(async () => this._context.evaluate(this._context.encode(`${input[0].content}`), promptOptions));
+            for await (const chunk of stream) {
+                yield new ChatGenerationChunk({
+                    text: this._context.decode([chunk]),
+                    message: new AIMessageChunk({
+                        content: this._context.decode([chunk]),
+                    }),
+                    generationInfo: {},
+                });
+                await runManager?.handleLLMNewToken(this._context.decode([chunk]) ?? "");
+            }
+        }
+    }
     // This constructs a new session if we need to adding in any sys messages or previous chats
     _buildSession(messages) {
         let prompt = "";

package/dist/document_loaders/fs/pptx.cjs

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PPTXLoader = void 0;
+const officeparser_1 = require("officeparser");
+const document_js_1 = require("../../document.cjs");
+const buffer_js_1 = require("./buffer.cjs");
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
+class PPTXLoader extends buffer_js_1.BufferLoader {
+    constructor(filePathOrBlob) {
+        super(filePathOrBlob);
+    }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `parseOfficeAsync` function from the `officeparser` module to extract
+     * the raw text content from the buffer. If the extracted powerpoint content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted powerpoint content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
+    async parse(raw, metadata) {
+        const pptx = await (0, officeparser_1.parseOfficeAsync)(raw, { outputErrorToConsole: true });
+        if (!pptx)
+            return [];
+        return [
+            new document_js_1.Document({
+                pageContent: pptx,
+                metadata,
+            }),
+        ];
+    }
+}
+exports.PPTXLoader = PPTXLoader;

package/dist/document_loaders/fs/pptx.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="node" resolution-mode="require"/>
+import { Document } from "../../document.js";
+import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
+export declare class PPTXLoader extends BufferLoader {
+    constructor(filePathOrBlob: string | Blob);
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `parseOfficeAsync` function from the `officeparser` module to extract
+     * the raw text content from the buffer. If the extracted powerpoint content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted powerpoint content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
+    parse(raw: Buffer, metadata: Document["metadata"]): Promise<Document[]>;
+}

package/dist/document_loaders/fs/pptx.js

@@ -0,0 +1,35 @@
+import { parseOfficeAsync } from "officeparser";
+import { Document } from "../../document.js";
+import { BufferLoader } from "./buffer.js";
+/**
+ * A class that extends the `BufferLoader` class. It represents a document
+ * loader that loads documents from PDF files.
+ */
+export class PPTXLoader extends BufferLoader {
+    constructor(filePathOrBlob) {
+        super(filePathOrBlob);
+    }
+    /**
+     * A method that takes a `raw` buffer and `metadata` as parameters and
+     * returns a promise that resolves to an array of `Document` instances. It
+     * uses the `parseOfficeAsync` function from the `officeparser` module to extract
+     * the raw text content from the buffer. If the extracted powerpoint content is
+     * empty, it returns an empty array. Otherwise, it creates a new
+     * `Document` instance with the extracted powerpoint content and the provided
+     * metadata, and returns it as an array.
+     * @param raw The buffer to be parsed.
+     * @param metadata The metadata of the document.
+     * @returns A promise that resolves to an array of `Document` instances.
+     */
+    async parse(raw, metadata) {
+        const pptx = await parseOfficeAsync(raw, { outputErrorToConsole: true });
+        if (!pptx)
+            return [];
+        return [
+            new Document({
+                pageContent: pptx,
+                metadata,
+            }),
+        ];
+    }
+}

package/dist/experimental/openai_assistant/index.cjs

@@ -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

@@ -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

@@ -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/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;

package/dist/experimental/tools/pyinterpreter.d.ts

@@ -0,0 +1,18 @@
+import { loadPyodide, type PyodideInterface } from "pyodide";
+import { Tool, ToolParams } from "../../tools/base.js";
+export type PythonInterpreterToolParams = Parameters<typeof loadPyodide>[0] & ToolParams & {
+    instance: PyodideInterface;
+};
+export declare class PythonInterpreterTool extends Tool {
+    static lc_name(): string;
+    name: string;
+    description: string;
+    pyodideInstance: PyodideInterface;
+    stdout: string;
+    stderr: string;
+    constructor(options: PythonInterpreterToolParams);
+    addPackage(packageName: string): Promise<void>;
+    get availableDefaultPackages(): string;
+    static initialize(options: Omit<PythonInterpreterToolParams, "instance">): Promise<PythonInterpreterTool>;
+    _call(script: string): Promise<string>;
+}