langchain 0.0.195 → 0.0.196

package/dist/callbacks/promises.cjs

@@ -1,45 +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.awaitAllCallbacks = exports.consumeCallback = void 0;
-const p_queue_1 = __importDefault(require("p-queue"));
-let queue;
-/**
- * Creates a queue using the p-queue library. The queue is configured to
- * auto-start and has a concurrency of 1, meaning it will process tasks
- * one at a time.
- */
-function createQueue() {
-    const PQueue = "default" in p_queue_1.default ? p_queue_1.default.default : p_queue_1.default;
-    return new PQueue({
-        autoStart: true,
-        concurrency: 1,
-    });
-}
-/**
- * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promise Promise to consume
- * @param wait Whether to wait for the promise to resolve or resolve immediately
- */
-async function consumeCallback(promiseFn, wait) {
-    if (wait === true) {
-        await promiseFn();
-    }
-    else {
-        if (typeof queue === "undefined") {
-            queue = createQueue();
-        }
-        void queue.add(promiseFn);
-    }
-}
-exports.consumeCallback = consumeCallback;
-/**
- * Waits for all promises in the queue to resolve. If the queue is
- * undefined, it immediately resolves a promise.
- */
-function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
-}
-exports.awaitAllCallbacks = awaitAllCallbacks;
+__exportStar(require("langchain-core/callbacks/promises"), exports);

package/dist/callbacks/promises.d.ts

@@ -1,11 +1 @@
-/**
- * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promise Promise to consume
- * @param wait Whether to wait for the promise to resolve or resolve immediately
- */
-export declare function consumeCallback<T>(promiseFn: () => Promise<T> | T | void, wait: boolean): Promise<void>;
-/**
- * Waits for all promises in the queue to resolve. If the queue is
- * undefined, it immediately resolves a promise.
- */
-export declare function awaitAllCallbacks(): Promise<void>;
+export * from "langchain-core/callbacks/promises";

package/dist/callbacks/promises.js

@@ -1,37 +1 @@
-import PQueueMod from "p-queue";
-let queue;
-/**
- * Creates a queue using the p-queue library. The queue is configured to
- * auto-start and has a concurrency of 1, meaning it will process tasks
- * one at a time.
- */
-function createQueue() {
-    const PQueue = "default" in PQueueMod ? PQueueMod.default : PQueueMod;
-    return new PQueue({
-        autoStart: true,
-        concurrency: 1,
-    });
-}
-/**
- * Consume a promise, either adding it to the queue or waiting for it to resolve
- * @param promise Promise to consume
- * @param wait Whether to wait for the promise to resolve or resolve immediately
- */
-export async function consumeCallback(promiseFn, wait) {
-    if (wait === true) {
-        await promiseFn();
-    }
-    else {
-        if (typeof queue === "undefined") {
-            queue = createQueue();
-        }
-        void queue.add(promiseFn);
-    }
-}
-/**
- * Waits for all promises in the queue to resolve. If the queue is
- * undefined, it immediately resolves a promise.
- */
-export function awaitAllCallbacks() {
-    return typeof queue !== "undefined" ? queue.onIdle() : Promise.resolve();
-}
+export * from "langchain-core/callbacks/promises";

package/dist/chains/graph_qa/prompts.d.ts

@@ -1,7 +1,7 @@
 import { PromptTemplate } from "../../prompts/prompt.js";
 export declare const CYPHER_GENERATION_PROMPT: PromptTemplate<{
-    schema: any;
     question: any;
+    schema: any;
 }, any>;
 export declare const CYPHER_QA_PROMPT: PromptTemplate<{
     context: any;

package/dist/chains/openai_functions/structured_output.cjs

@@ -2,7 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createStructuredOutputChainFromZod = exports.createStructuredOutputChain = exports.FunctionCallStructuredOutputParser = void 0;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
-const index_js_1 = require("../../util/@cfworker/json-schema/index.cjs");
+const json_schema_1 = require("langchain-core/util/json_schema");
 const llm_chain_js_1 = require("../llm_chain.cjs");
 const openai_js_1 = require("../../chat_models/openai.cjs");
 const output_parser_js_1 = require("../../schema/output_parser.cjs");
@@ -38,7 +38,7 @@ class FunctionCallStructuredOutputParser extends output_parser_js_1.BaseLLMOutpu
             writable: true,
             value: void 0
         });
-        this.jsonSchemaValidator = new index_js_1.Validator(schema, "7");
+        this.jsonSchemaValidator = new json_schema_1.Validator(schema, "7");
     }
     /**
      * Method to parse the result of chat generations. It first parses the

package/dist/chains/openai_functions/structured_output.d.ts

@@ -1,6 +1,6 @@
 import { z } from "zod";
 import { JsonSchema7Type } from "zod-to-json-schema/src/parseDef.js";
-import { Validator } from "../../util/@cfworker/json-schema/index.js";
+import { Validator } from "langchain-core/util/json_schema";
 import { LLMChain, LLMChainInput } from "../llm_chain.js";
 import { ChatOpenAI } from "../../chat_models/openai.js";
 import { BasePromptTemplate } from "../../prompts/index.js";

package/dist/chains/openai_functions/structured_output.js

@@ -1,5 +1,5 @@
 import { zodToJsonSchema } from "zod-to-json-schema";
-import { Validator } from "../../util/@cfworker/json-schema/index.js";
+import { Validator } from "langchain-core/util/json_schema";
 import { LLMChain } from "../llm_chain.js";
 import { ChatOpenAI } from "../../chat_models/openai.js";
 import { BaseLLMOutputParser, OutputParserException, } from "../../schema/output_parser.js";

package/dist/chat_models/baiduwenxin.d.ts

@@ -131,8 +131,8 @@ export declare class ChatBaiduWenxin extends BaseChatModel implements BaiduWenxi
      * Get the identifying parameters for the model
      */
     identifyingParams(): {
-        system?: string | undefined;
         stream?: boolean | undefined;
+        system?: string | undefined;
         temperature?: number | undefined;
         top_p?: number | undefined;
         user_id?: string | undefined;

package/dist/chat_models/base.cjs

@@ -1,298 +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.SimpleChatModel = exports.BaseChatModel = exports.createChatMessageChunkEncoderStream = void 0;
-const index_js_1 = require("../schema/index.cjs");
-const index_js_2 = require("../base_language/index.cjs");
-const manager_js_1 = require("../callbacks/manager.cjs");
-/**
- * Creates a transform stream for encoding chat message chunks.
- * @deprecated Use {@link BytesOutputParser} instead
- * @returns A TransformStream instance that encodes chat message chunks.
- */
-function createChatMessageChunkEncoderStream() {
-    const textEncoder = new TextEncoder();
-    return new TransformStream({
-        transform(chunk, controller) {
-            controller.enqueue(textEncoder.encode(typeof chunk.content === "string"
-                ? chunk.content
-                : JSON.stringify(chunk.content)));
-        },
-    });
-}
-exports.createChatMessageChunkEncoderStream = createChatMessageChunkEncoderStream;
-/**
- * Base class for chat models. It extends the BaseLanguageModel class and
- * provides methods for generating chat based on input messages.
- */
-class BaseChatModel extends index_js_2.BaseLanguageModel {
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "chat_models", this._llmType()]
-        });
-    }
-    _separateRunnableConfigFromCallOptions(options) {
-        const [runnableConfig, callOptions] = super._separateRunnableConfigFromCallOptions(options);
-        if (callOptions?.timeout && !callOptions.signal) {
-            callOptions.signal = AbortSignal.timeout(callOptions.timeout);
-        }
-        return [runnableConfig, callOptions];
-    }
-    /**
-     * Invokes the chat model with a single input.
-     * @param input The input for the language model.
-     * @param options The call options.
-     * @returns A Promise that resolves to a BaseMessageChunk.
-     */
-    async invoke(input, options) {
-        const promptValue = BaseChatModel._convertInputToPromptValue(input);
-        const result = await this.generatePrompt([promptValue], options, options?.callbacks);
-        const chatGeneration = result.generations[0][0];
-        // TODO: Remove cast after figuring out inheritance
-        return chatGeneration.message;
-    }
-    // eslint-disable-next-line require-yield
-    async *_streamResponseChunks(_messages, _options, _runManager) {
-        throw new Error("Not implemented.");
-    }
-    async *_streamIterator(input, options) {
-        // Subclass check required to avoid double callbacks with default implementation
-        if (this._streamResponseChunks ===
-            BaseChatModel.prototype._streamResponseChunks) {
-            yield this.invoke(input, options);
-        }
-        else {
-            const prompt = BaseChatModel._convertInputToPromptValue(input);
-            const messages = prompt.toChatMessages();
-            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_?.handleChatModelStart(this.toJSON(), [messages], undefined, undefined, extra, undefined, undefined, runnableConfig.runName);
-            let generationChunk;
-            try {
-                for await (const chunk of this._streamResponseChunks(messages, callOptions, runManagers?.[0])) {
-                    yield chunk.message;
-                    if (!generationChunk) {
-                        generationChunk = chunk;
-                    }
-                    else {
-                        generationChunk = generationChunk.concat(chunk);
-                    }
-                }
-            }
-            catch (err) {
-                await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMError(err)));
-                throw err;
-            }
-            await Promise.all((runManagers ?? []).map((runManager) => runManager?.handleLLMEnd({
-                // TODO: Remove cast after figuring out inheritance
-                generations: [[generationChunk]],
-            })));
-        }
-    }
-    /** @ignore */
-    async _generateUncached(messages, parsedOptions, handledOptions) {
-        const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
-        // create callback manager and start run
-        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: 1,
-        };
-        const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra, undefined, undefined, handledOptions.runName);
-        // generate results
-        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
-        // handle results
-        const generations = [];
-        const llmOutputs = [];
-        await Promise.all(results.map(async (pResult, i) => {
-            if (pResult.status === "fulfilled") {
-                const result = pResult.value;
-                generations[i] = result.generations;
-                llmOutputs[i] = result.llmOutput;
-                return runManagers?.[i]?.handleLLMEnd({
-                    generations: [result.generations],
-                    llmOutput: result.llmOutput,
-                });
-            }
-            else {
-                // status === "rejected"
-                await runManagers?.[i]?.handleLLMError(pResult.reason);
-                return Promise.reject(pResult.reason);
-            }
-        }));
-        // create combined output
-        const output = {
-            generations,
-            llmOutput: llmOutputs.length
-                ? this._combineLLMOutput?.(...llmOutputs)
-                : undefined,
-        };
-        Object.defineProperty(output, index_js_1.RUN_KEY, {
-            value: runManagers
-                ? { runIds: runManagers?.map((manager) => manager.runId) }
-                : undefined,
-            configurable: true,
-        });
-        return output;
-    }
-    /**
-     * Generates chat based on the input messages.
-     * @param messages An array of arrays of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    async generate(messages, options, callbacks) {
-        // parse call options
-        let parsedOptions;
-        if (Array.isArray(options)) {
-            parsedOptions = { stop: options };
-        }
-        else {
-            parsedOptions = options;
-        }
-        const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
-        runnableConfig.callbacks = runnableConfig.callbacks ?? callbacks;
-        if (!this.cache) {
-            return this._generateUncached(baseMessages, callOptions, runnableConfig);
-        }
-        const { cache } = this;
-        const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
-        const missingPromptIndices = [];
-        const generations = await Promise.all(baseMessages.map(async (baseMessage, index) => {
-            // Join all content into one string for the prompt index
-            const prompt = BaseChatModel._convertInputToPromptValue(baseMessage).toString();
-            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) => baseMessages[i]), callOptions, runnableConfig);
-            await Promise.all(results.generations.map(async (generation, index) => {
-                const promptIndex = missingPromptIndices[index];
-                generations[promptIndex] = generation;
-                // Join all content into one string for the prompt index
-                const prompt = BaseChatModel._convertInputToPromptValue(baseMessages[promptIndex]).toString();
-                return cache.update(prompt, llmStringKey, generation);
-            }));
-            llmOutput = results.llmOutput ?? {};
-        }
-        return { generations, llmOutput };
-    }
-    /**
-     * Get the parameters used to invoke the model
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    invocationParams(_options) {
-        return {};
-    }
-    _modelType() {
-        return "base_chat_model";
-    }
-    /**
-     * @deprecated
-     * Return a json-like object representing this LLM.
-     */
-    serialize() {
-        return {
-            ...this.invocationParams(),
-            _type: this._llmType(),
-            _model: this._modelType(),
-        };
-    }
-    /**
-     * Generates a prompt based on the input prompt values.
-     * @param promptValues An array of BasePromptValue instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    async generatePrompt(promptValues, options, callbacks) {
-        const promptMessages = promptValues.map((promptValue) => promptValue.toChatMessages());
-        return this.generate(promptMessages, options, callbacks);
-    }
-    /**
-     * Makes a single call to the chat model.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    async call(messages, options, callbacks) {
-        const result = await this.generate([messages.map(index_js_1.coerceMessageLikeToMessage)], options, callbacks);
-        const generations = result.generations;
-        return generations[0][0].message;
-    }
-    /**
-     * Makes a single call to the chat model with a prompt value.
-     * @param promptValue The value of the prompt.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    async callPrompt(promptValue, options, callbacks) {
-        const promptMessages = promptValue.toChatMessages();
-        return this.call(promptMessages, options, callbacks);
-    }
-    /**
-     * Predicts the next message based on the input messages.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    async predictMessages(messages, options, callbacks) {
-        return this.call(messages, options, callbacks);
-    }
-    /**
-     * Predicts the next message based on a text input.
-     * @param text The text input.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a string.
-     */
-    async predict(text, options, callbacks) {
-        const message = new index_js_1.HumanMessage(text);
-        const result = await this.call([message], options, callbacks);
-        if (typeof result.content !== "string") {
-            throw new Error("Cannot use predict when output is not a string.");
-        }
-        return result.content;
-    }
-}
-exports.BaseChatModel = BaseChatModel;
-/**
- * An abstract class that extends BaseChatModel and provides a simple
- * implementation of _generate.
- */
-class SimpleChatModel extends BaseChatModel {
-    async _generate(messages, options, runManager) {
-        const text = await this._call(messages, options, runManager);
-        const message = new index_js_1.AIMessage(text);
-        if (typeof message.content !== "string") {
-            throw new Error("Cannot generate with a simple chat model when output is not a string.");
-        }
-        return {
-            generations: [
-                {
-                    text: message.content,
-                    message,
-                },
-            ],
-        };
-    }
-}
-exports.SimpleChatModel = SimpleChatModel;
+__exportStar(require("langchain-core/chat_model"), exports);

package/dist/chat_models/base.d.ts

@@ -1,122 +1 @@
-import { BaseMessage, BaseMessageChunk, BaseMessageLike, BasePromptValue, ChatGenerationChunk, ChatResult, LLMResult } from "../schema/index.js";
-import { BaseLanguageModel, BaseLanguageModelCallOptions, BaseLanguageModelInput, BaseLanguageModelParams } from "../base_language/index.js";
-import { CallbackManagerForLLMRun, Callbacks } from "../callbacks/manager.js";
-import { RunnableConfig } from "../schema/runnable/config.js";
-/**
- * Represents a serialized chat model.
- */
-export type SerializedChatModel = {
-    _model: string;
-    _type: string;
-} & Record<string, any>;
-/**
- * Represents a serialized large language model.
- */
-export type SerializedLLM = {
-    _model: string;
-    _type: string;
-} & Record<string, any>;
-/**
- * Represents the parameters for a base chat model.
- */
-export type BaseChatModelParams = BaseLanguageModelParams;
-/**
- * Represents the call options for a base chat model.
- */
-export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
-/**
- * Creates a transform stream for encoding chat message chunks.
- * @deprecated Use {@link BytesOutputParser} instead
- * @returns A TransformStream instance that encodes chat message chunks.
- */
-export declare function createChatMessageChunkEncoderStream(): TransformStream<BaseMessageChunk, any>;
-/**
- * Base class for chat models. It extends the BaseLanguageModel class and
- * provides methods for generating chat based on input messages.
- */
-export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseLanguageModel<BaseMessageChunk, CallOptions> {
-    ParsedCallOptions: Omit<CallOptions, keyof RunnableConfig & "timeout">;
-    lc_namespace: string[];
-    constructor(fields: BaseChatModelParams);
-    abstract _combineLLMOutput?(...llmOutputs: LLMResult["llmOutput"][]): LLMResult["llmOutput"];
-    protected _separateRunnableConfigFromCallOptions(options?: Partial<CallOptions>): [RunnableConfig, this["ParsedCallOptions"]];
-    /**
-     * Invokes the chat model with a single input.
-     * @param input The input for the language model.
-     * @param options The call options.
-     * @returns A Promise that resolves to a BaseMessageChunk.
-     */
-    invoke(input: BaseLanguageModelInput, options?: CallOptions): Promise<BaseMessageChunk>;
-    _streamResponseChunks(_messages: BaseMessage[], _options: this["ParsedCallOptions"], _runManager?: CallbackManagerForLLMRun): AsyncGenerator<ChatGenerationChunk>;
-    _streamIterator(input: BaseLanguageModelInput, options?: CallOptions): AsyncGenerator<BaseMessageChunk>;
-    /** @ignore */
-    _generateUncached(messages: BaseMessageLike[][], parsedOptions: this["ParsedCallOptions"], handledOptions: RunnableConfig): Promise<LLMResult>;
-    /**
-     * Generates chat based on the input messages.
-     * @param messages An array of arrays of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    generate(messages: BaseMessageLike[][], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
-    /**
-     * Get the parameters used to invoke the model
-     */
-    invocationParams(_options?: this["ParsedCallOptions"]): any;
-    _modelType(): string;
-    abstract _llmType(): string;
-    /**
-     * @deprecated
-     * Return a json-like object representing this LLM.
-     */
-    serialize(): SerializedLLM;
-    /**
-     * Generates a prompt based on the input prompt values.
-     * @param promptValues An array of BasePromptValue instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to an LLMResult.
-     */
-    generatePrompt(promptValues: BasePromptValue[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<LLMResult>;
-    abstract _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    /**
-     * Makes a single call to the chat model.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    call(messages: BaseMessageLike[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Makes a single call to the chat model with a prompt value.
-     * @param promptValue The value of the prompt.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    callPrompt(promptValue: BasePromptValue, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Predicts the next message based on the input messages.
-     * @param messages An array of BaseMessage instances.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a BaseMessage.
-     */
-    predictMessages(messages: BaseMessage[], options?: string[] | CallOptions, callbacks?: Callbacks): Promise<BaseMessage>;
-    /**
-     * Predicts the next message based on a text input.
-     * @param text The text input.
-     * @param options The call options or an array of stop sequences.
-     * @param callbacks The callbacks for the language model.
-     * @returns A Promise that resolves to a string.
-     */
-    predict(text: string, options?: string[] | CallOptions, callbacks?: Callbacks): Promise<string>;
-}
-/**
- * An abstract class that extends BaseChatModel and provides a simple
- * implementation of _generate.
- */
-export declare abstract class SimpleChatModel<CallOptions extends BaseChatModelCallOptions = BaseChatModelCallOptions> extends BaseChatModel<CallOptions> {
-    abstract _call(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
-    _generate(messages: BaseMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-}
+export * from "langchain-core/chat_model";