langchain 0.0.194 → 0.0.196

package/dist/experimental/openai_files/index.cjs

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OpenAIFiles = void 0;
+const openai_1 = require("openai");
+const serializable_js_1 = require("../../load/serializable.cjs");
+class OpenAIFiles extends serializable_js_1.Serializable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental"]
+        });
+        Object.defineProperty(this, "oaiClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.oaiClient = fields?.client ?? new openai_1.OpenAI(fields?.clientOptions);
+    }
+    /**
+     * Upload file
+     * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.
+     *
+     * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/create}
+     * @param {OpenAIClient.FileCreateParams['file']} file
+     * @param {OpenAIClient.FileCreateParams['purpose']} purpose
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObject>}
+     */
+    async createFile({ file, purpose, options, }) {
+        return this.oaiClient.files.create({ file, purpose }, options);
+    }
+    /**
+     * Delete a file.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/delete}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileDeleted>}
+     */
+    async deleteFile({ fileId, options, }) {
+        return this.oaiClient.files.del(fileId, options);
+    }
+    /**
+     * List files
+     * Returns a list of files that belong to the user's organization.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/list}
+     * @param {OpenAIClient.Files.FileListParams | undefined} query
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}
+     */
+    async listFiles(props) {
+        return this.oaiClient.files.list(props?.query, props?.options);
+    }
+    /**
+     * Retrieve file
+     * Returns information about a specific file.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/retrieve}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObject>}
+     */
+    async retrieveFile({ fileId, options, }) {
+        return this.oaiClient.files.retrieve(fileId, options);
+    }
+    /**
+     * Retrieve file content
+     * Returns the contents of the specified file.
+     *
+     * @note You can't retrieve the contents of a file that was uploaded with the "purpose": "assistants" API.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<string>}
+     */
+    async retrieveFileContent({ fileId, options, }) {
+        return this.oaiClient.files.retrieveContent(fileId, options);
+    }
+}
+exports.OpenAIFiles = OpenAIFiles;

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

@@ -0,0 +1,79 @@
+import { ClientOptions, OpenAI as OpenAIClient } from "openai";
+import { Serializable } from "../../load/serializable.js";
+export type OpenAIFilesInput = {
+    client?: OpenAIClient;
+    clientOptions?: ClientOptions;
+};
+export declare class OpenAIFiles extends Serializable {
+    lc_namespace: string[];
+    private oaiClient;
+    constructor(fields?: OpenAIFilesInput);
+    /**
+     * Upload file
+     * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.
+     *
+     * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/create}
+     * @param {OpenAIClient.FileCreateParams['file']} file
+     * @param {OpenAIClient.FileCreateParams['purpose']} purpose
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObject>}
+     */
+    createFile({ file, purpose, options, }: OpenAIClient.FileCreateParams & {
+        options?: OpenAIClient.RequestOptions;
+    }): Promise<OpenAIClient.Files.FileObject>;
+    /**
+     * Delete a file.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/delete}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileDeleted>}
+     */
+    deleteFile({ fileId, options, }: {
+        fileId: string;
+        options?: OpenAIClient.RequestOptions;
+    }): Promise<OpenAIClient.Files.FileDeleted>;
+    /**
+     * List files
+     * Returns a list of files that belong to the user's organization.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/list}
+     * @param {OpenAIClient.Files.FileListParams | undefined} query
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}
+     */
+    listFiles(props?: {
+        query?: OpenAIClient.Files.FileListParams;
+        options?: OpenAIClient.RequestOptions;
+    }): Promise<OpenAIClient.Files.FileObjectsPage>;
+    /**
+     * Retrieve file
+     * Returns information about a specific file.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/retrieve}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObject>}
+     */
+    retrieveFile({ fileId, options, }: {
+        fileId: string;
+        options?: OpenAIClient.RequestOptions;
+    }): Promise<OpenAIClient.Files.FileObject>;
+    /**
+     * Retrieve file content
+     * Returns the contents of the specified file.
+     *
+     * @note You can't retrieve the contents of a file that was uploaded with the "purpose": "assistants" API.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<string>}
+     */
+    retrieveFileContent({ fileId, options, }: {
+        fileId: string;
+        options?: OpenAIClient.RequestOptions;
+    }): Promise<string>;
+}

package/dist/experimental/openai_files/index.js

@@ -0,0 +1,84 @@
+import { OpenAI as OpenAIClient } from "openai";
+import { Serializable } from "../../load/serializable.js";
+export class OpenAIFiles extends Serializable {
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "experimental"]
+        });
+        Object.defineProperty(this, "oaiClient", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.oaiClient = fields?.client ?? new OpenAIClient(fields?.clientOptions);
+    }
+    /**
+     * Upload file
+     * Upload a file that can be used across various endpoints. The size of all the files uploaded by one organization can be up to 100 GB.
+     *
+     * @note The size of individual files can be a maximum of 512 MB. See the Assistants Tools guide to learn more about the types of files supported. The Fine-tuning API only supports .jsonl files.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/create}
+     * @param {OpenAIClient.FileCreateParams['file']} file
+     * @param {OpenAIClient.FileCreateParams['purpose']} purpose
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObject>}
+     */
+    async createFile({ file, purpose, options, }) {
+        return this.oaiClient.files.create({ file, purpose }, options);
+    }
+    /**
+     * Delete a file.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/delete}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileDeleted>}
+     */
+    async deleteFile({ fileId, options, }) {
+        return this.oaiClient.files.del(fileId, options);
+    }
+    /**
+     * List files
+     * Returns a list of files that belong to the user's organization.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/list}
+     * @param {OpenAIClient.Files.FileListParams | undefined} query
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObjectsPage>}
+     */
+    async listFiles(props) {
+        return this.oaiClient.files.list(props?.query, props?.options);
+    }
+    /**
+     * Retrieve file
+     * Returns information about a specific file.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/retrieve}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<OpenAIClient.Files.FileObject>}
+     */
+    async retrieveFile({ fileId, options, }) {
+        return this.oaiClient.files.retrieve(fileId, options);
+    }
+    /**
+     * Retrieve file content
+     * Returns the contents of the specified file.
+     *
+     * @note You can't retrieve the contents of a file that was uploaded with the "purpose": "assistants" API.
+     *
+     * @link {https://platform.openai.com/docs/api-reference/files/retrieve-contents}
+     * @param {string} fileId
+     * @param {OpenAIClient.RequestOptions | undefined} options
+     * @returns {Promise<string>}
+     */
+    async retrieveFileContent({ fileId, options, }) {
+        return this.oaiClient.files.retrieveContent(fileId, options);
+    }
+}

package/dist/experimental/plan_and_execute/prompt.d.ts

@@ -10,4 +10,4 @@ export declare const DEFAULT_STEP_EXECUTOR_HUMAN_CHAT_MESSAGE_TEMPLATE = "Previo
  * @param tools the tools available to the `planner`
  * @returns
  */
-export declare const getPlannerChatPrompt: (tools: Tool[] | DynamicStructuredTool[]) => Promise<ChatPromptTemplate<import("../../schema/index.js").InputValues<string>, any>>;
+export declare const getPlannerChatPrompt: (tools: Tool[] | DynamicStructuredTool[]) => Promise<ChatPromptTemplate<import("langchain-core/schema").InputValues<string>, any>>;

package/dist/llms/base.cjs

@@ -1,280 +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.LLM = exports.BaseLLM = void 0;
-const index_js_1 = require("../schema/index.cjs");
-const manager_js_1 = require("../callbacks/manager.cjs");
-const index_js_2 = require("../base_language/index.cjs");
-const base_js_1 = require("../memory/base.cjs");
-/**
- * LLM Wrapper. Provides an {@link call} (an {@link generate}) function that takes in a prompt (or prompts) and returns a string.
- */
-class BaseLLM extends index_js_2.BaseLanguageModel {
-    constructor({ concurrency, ...rest }) {
-        super(concurrency ? { maxConcurrency: concurrency, ...rest } : rest);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "llms", this._llmType()]
-        });
-    }
-    /**
-     * This method takes an input and options, and returns a string. It
-     * converts the input to a prompt value and generates a result based on
-     * the prompt.
-     * @param input Input for the LLM.
-     * @param options Options for the LLM call.
-     * @returns A string result based on the prompt.
-     */
-    async invoke(input, options) {
-        const promptValue = BaseLLM._convertInputToPromptValue(input);
-        const result = await this.generatePrompt([promptValue], options, options?.callbacks);
-        return result.generations[0][0].text;
-    }
-    // eslint-disable-next-line require-yield
-    async *_streamResponseChunks(_input, _options, _runManager) {
-        throw new Error("Not implemented.");
-    }
-    _separateRunnableConfigFromCallOptions(options) {
-        const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
-        if (callOptions?.timeout && !callOptions.signal) {
-            callOptions.signal = AbortSignal.timeout(callOptions.timeout);
-        }
-        return [runnableConfig, callOptions];
-    }
-    async *_streamIterator(input, options) {
-        // Subclass check required to avoid double callbacks with default implementation
-        if (this._streamResponseChunks === BaseLLM.prototype._streamResponseChunks) {
-            yield this.invoke(input, options);
-        }
-        else {
-            const prompt = BaseLLM._convertInputToPromptValue(input);
-            const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(options);
-            const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
-            const extra = {
-                options: callOptions,
-                invocation_params: this?.invocationParams(callOptions),
-                batch_size: 1,
-            };
-            const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
-            let generation = new index_js_1.GenerationChunk({
-                text: "",
-            });
-            try {
-                for await (const chunk of this._streamResponseChunks(input.toString(), callOptions, runManagers?.[0])) {
-                    if (!generation) {
-                        generation = chunk;
-                    }
-                    else {
-                        generation = generation.concat(chunk);
-                    }
-                    if (typeof chunk.text === "string") {
-                        yield chunk.text;
-                    }
-                }
-            }
-            catch (err) {
-                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-                throw err;
-            }
-            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({
-                generations: [[generation]],
-            })));
-        }
-    }
-    /**
-     * This method takes prompt values, options, and callbacks, and generates
-     * a result based on the prompts.
-     * @param promptValues Prompt values for the LLM.
-     * @param options Options for the LLM call.
-     * @param callbacks Callbacks for the LLM call.
-     * @returns An LLMResult based on the prompts.
-     */
-    async generatePrompt(promptValues, options, callbacks) {
-        const prompts = promptValues.map((promptValue) => promptValue.toString());
-        return this.generate(prompts, options, callbacks);
-    }
-    /**
-     * Get the parameters used to invoke the model
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    invocationParams(_options) {
-        return {};
-    }
-    _flattenLLMResult(llmResult) {
-        const llmResults = [];
-        for (let i = 0; i < llmResult.generations.length; i += 1) {
-            const genList = llmResult.generations[i];
-            if (i === 0) {
-                llmResults.push({
-                    generations: [genList],
-                    llmOutput: llmResult.llmOutput,
-                });
-            }
-            else {
-                const llmOutput = llmResult.llmOutput
-                    ? { ...llmResult.llmOutput, tokenUsage: {} }
-                    : undefined;
-                llmResults.push({
-                    generations: [genList],
-                    llmOutput,
-                });
-            }
-        }
-        return llmResults;
-    }
-    /** @ignore */
-    async _generateUncached(prompts, parsedOptions, handledOptions) {
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
-        const extra = {
-            options: parsedOptions,
-            invocation_params: this?.invocationParams(parsedOptions),
-            batch_size: prompts.length,
-        };
-        const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), prompts, undefined, undefined, extra, undefined, undefined, handledOptions?.runName);
-        let output;
-        try {
-            output = await this._generate(prompts, parsedOptions, runManagers?.[0]);
-        }
-        catch (err) {
-            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-            throw err;
-        }
-        const flattenedOutputs = this._flattenLLMResult(output);
-        await Promise.all((runManagers ?? []).map((runManager, i) => runManager?.handleLLMEnd(flattenedOutputs[i])));
-        const runIds = runManagers?.map((manager) => manager.runId) || undefined;
-        // This defines RUN_KEY as a non-enumerable property on the output object
-        // so that it is not serialized when the output is stringified, and so that
-        // it isnt included when listing the keys of the output object.
-        Object.defineProperty(output, index_js_1.RUN_KEY, {
-            value: runIds ? { runIds } : undefined,
-            configurable: true,
-        });
-        return output;
-    }
-    /**
-     * Run the LLM on the given prompts and input, handling caching.
-     */
-    async generate(prompts, options, callbacks) {
-        if (!Array.isArray(prompts)) {
-            throw new Error("Argument 'prompts' is expected to be a string[]");
-        }
-        let parsedOptions;
-        if (Array.isArray(options)) {
-            parsedOptions = { stop: options };
-        }
-        else {
-            parsedOptions = options;
-        }
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
-        runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
-        if (!this.cache) {
-            return this._generateUncached(prompts, callOptions, runnableConfig);
-        }
-        const { cache } = this;
-        const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const missingPromptIndices = [];
-        const generations = await Promise.all(prompts.map(async (prompt, index) => {
-            const result = await cache.lookup(prompt, llmStringKey);
-            if (!result) {
-                missingPromptIndices.push(index);
-            }
-            return result;
-        }));
-        let llmOutput = {};
-        if (missingPromptIndices.length > 0) {
-            const results = await this._generateUncached(missingPromptIndices.map((i) => prompts[i]), callOptions, runnableConfig);
-            await Promise.all(results.generations.map(async (generation, index) => {
-                const promptIndex = missingPromptIndices[index];
-                generations[promptIndex] = generation;
-                return cache.update(prompts[promptIndex], llmStringKey, generation);
-            }));
-            llmOutput = results.llmOutput ?? {};
-        }
-        return { generations, llmOutput };
-    }
-    /**
-     * Convenience wrapper for {@link generate} that takes in a single string prompt and returns a single string output.
-     */
-    async call(prompt, options, callbacks) {
-        const { generations } = await this.generate([prompt], options, callbacks);
-        return generations[0][0].text;
-    }
-    /**
-     * This method is similar to `call`, but it's used for making predictions
-     * based on the input text.
-     * @param text Input text for the prediction.
-     * @param options Options for the LLM call.
-     * @param callbacks Callbacks for the LLM call.
-     * @returns A prediction based on the input text.
-     */
-    async predict(text, options, callbacks) {
-        return this.call(text, options, callbacks);
-    }
-    /**
-     * This method takes a list of messages, options, and callbacks, and
-     * returns a predicted message.
-     * @param messages A list of messages for the prediction.
-     * @param options Options for the LLM call.
-     * @param callbacks Callbacks for the LLM call.
-     * @returns A predicted message based on the list of messages.
-     */
-    async predictMessages(messages, options, callbacks) {
-        const text = (0, base_js_1.getBufferString)(messages);
-        const prediction = await this.call(text, options, callbacks);
-        return new index_js_1.AIMessage(prediction);
-    }
-    /**
-     * Get the identifying parameters of the LLM.
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    _identifyingParams() {
-        return {};
-    }
-    /**
-     * @deprecated
-     * Return a json-like object representing this LLM.
-     */
-    serialize() {
-        return {
-            ...this._identifyingParams(),
-            _type: this._llmType(),
-            _model: this._modelType(),
-        };
-    }
-    _modelType() {
-        return "base_llm";
-    }
-    /**
-     * @deprecated
-     * Load an LLM from a json-like object describing it.
-     */
-    static async deserialize(data) {
-        const { _type, _model, ...rest } = data;
-        if (_model && _model !== "base_llm") {
-            throw new Error(`Cannot load LLM with model ${_model}`);
-        }
-        const Cls = {
-            openai: (await import("./openai.js")).OpenAI,
-        }[_type];
-        if (Cls === undefined) {
-            throw new Error(`Cannot load  LLM with type ${_type}`);
-        }
-        return new Cls(rest);
-    }
-}
-exports.BaseLLM = BaseLLM;
-/**
- * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.
- *
- * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.
- *
- * @augments BaseLLM
- */
-class LLM extends BaseLLM {
-    async _generate(prompts, options, runManager) {
-        const generations = await Promise.all(prompts.map((prompt, promptIndex) => this._call(prompt, { ...options, promptIndex }, runManager).then((text) => [{ text }])));
-        return { generations };
-    }
-}
-exports.LLM = LLM;
+__exportStar(require("langchain-core/llm"), exports);

package/dist/llms/base.d.ts

@@ -1,115 +1 @@
-import { BaseMessage, BasePromptValue, GenerationChunk, LLMResult } from "../schema/index.js";
-import { BaseCallbackConfig, CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
-import { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelInput, BaseLanguageModelParams } from "../base_language/index.js";
-import { RunnableConfig } from "../schema/runnable/config.js";
-export type SerializedLLM = {
-    _model: string;
-    _type: string;
-} & Record<string, any>;
-export interface BaseLLMParams extends BaseLanguageModelParams {
-    /**
-     * @deprecated Use `maxConcurrency` instead
-     */
-    concurrency?: number;
-}
-export interface BaseLLMCallOptions extends BaseLanguageModelCallOptions {
-}
-/**
- * LLM Wrapper. Provides an {@link call} (an {@link generate}) function that takes in a prompt (or prompts) and returns a string.
- */
-export declare abstract class BaseLLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLanguageModel<string, CallOptions> {
-    ParsedCallOptions: Omit<CallOptions, keyof RunnableConfig & "timeout">;
-    lc_namespace: string[];
-    constructor({ concurrency, ...rest }: BaseLLMParams);
-    /**
-     * This method takes an input and options, and returns a string. It
-     * converts the input to a prompt value and generates a result based on
-     * the prompt.
-     * @param input Input for the LLM.
-     * @param options Options for the LLM call.
-     * @returns A string result based on the prompt.
-     */
-    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<string>;
-    _streamResponseChunks(_input: string, _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<GenerationChunk>;
-    protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
-    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<string>;
-    /**
-     * This method takes prompt values, options, and callbacks, and generates
-     * a result based on the prompts.
-     * @param promptValues Prompt values for the LLM.
-     * @param options Options for the LLM call.
-     * @param callbacks Callbacks for the LLM call.
-     * @returns An LLMResult based on the prompts.
-     */
-    generatePrompt(promptValues: BasePromptValue[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
-    /**
-     * Run the LLM on the given prompts and input.
-     */
-    abstract _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
-    /**
-     * Get the parameters used to invoke the model
-     */
-    invocationParams(_options?: this["ParsedCallOptions"]): any;
-    _flattenLLMResult(llmResult: LLMResult): LLMResult[];
-    /** @ignore */
-    _generateUncached(prompts: string[], parsedOptions: this["ParsedCallOptions"], handledOptions: BaseCallbackConfig): Promise<LLMResult>;
-    /**
-     * Run the LLM on the given prompts and input, handling caching.
-     */
-    generate(prompts: string[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
-    /**
-     * Convenience wrapper for {@link generate} that takes in a single string prompt and returns a single string output.
-     */
-    call(prompt: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
-    /**
-     * This method is similar to `call`, but it's used for making predictions
-     * based on the input text.
-     * @param text Input text for the prediction.
-     * @param options Options for the LLM call.
-     * @param callbacks Callbacks for the LLM call.
-     * @returns A prediction based on the input text.
-     */
-    predict(text: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
-    /**
-     * This method takes a list of messages, options, and callbacks, and
-     * returns a predicted message.
-     * @param messages A list of messages for the prediction.
-     * @param options Options for the LLM call.
-     * @param callbacks Callbacks for the LLM call.
-     * @returns A predicted message based on the list of messages.
-     */
-    predictMessages(messages: BaseMessage[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Get the identifying parameters of the LLM.
-     */
-    _identifyingParams(): Record<string, any>;
-    /**
-     * Return the string type key uniquely identifying this class of LLM.
-     */
-    abstract _llmType(): string;
-    /**
-     * @deprecated
-     * Return a json-like object representing this LLM.
-     */
-    serialize(): SerializedLLM;
-    _modelType(): string;
-    /**
-     * @deprecated
-     * Load an LLM from a json-like object describing it.
-     */
-    static deserialize(data: SerializedLLM): Promise<BaseLLM>;
-}
-/**
- * LLM class that provides a simpler interface to subclass than {@link BaseLLM}.
- *
- * Requires only implementing a simpler {@link _call} method instead of {@link _generate}.
- *
- * @augments BaseLLM
- */
-export declare abstract class LLM<CallOptions extends BaseLLMCallOptions = BaseLLMCallOptions> extends BaseLLM<CallOptions> {
-    /**
-     * Run the LLM on the given prompt and input.
-     */
-    abstract _call(prompt: string, options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
-    _generate(prompts: string[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<LLMResult>;
-}
+export * from "langchain-core/llm";