langchain 0.0.152 → 0.0.154

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

@@ -46,5 +46,5 @@ export declare class FunctionCallStructuredOutputParser<T extends z.AnyZodObject
  * as well as an additional required "outputSchema" JSON Schema object.
  * @returns OpenAPIChain
  */
-export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, ChatOpenAI | BaseChatModel<BaseFunctionCallOptions>>;
-export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, ChatOpenAI | BaseChatModel<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChain<T extends z.AnyZodObject = z.AnyZodObject>(input: StructuredOutputChainInput): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;
+export declare function createStructuredOutputChainFromZod<T extends z.AnyZodObject>(zodSchema: T, input: Omit<StructuredOutputChainInput, "outputSchema">): LLMChain<any, BaseChatModel<BaseFunctionCallOptions> | ChatOpenAI<BaseFunctionCallOptions>>;

package/dist/chat_models/base.cjs

@@ -94,33 +94,18 @@ class BaseChatModel extends index_js_2.BaseLanguageModel {
             })));
         }
     }
-    /**
-     * 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;
-        }
+    /** @ignore */
+    async _generateUncached(messages, parsedOptions, handledOptions) {
         const baseMessages = messages.map((messageList) => messageList.map(index_js_1.coerceMessageLikeToMessage));
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
         // create callback manager and start run
-        const callbackManager_ = await manager_js_1.CallbackManager.configure(runnableConfig.callbacks ?? callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+        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: callOptions,
+            options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
         };
         const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra);
         // generate results
-        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...callOptions, promptIndex: i }, runManagers?.[i])));
+        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
         // handle results
         const generations = [];
         const llmOutputs = [];
@@ -155,6 +140,54 @@ class BaseChatModel extends index_js_2.BaseLanguageModel {
         });
         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
      */
@@ -165,6 +198,17 @@ class BaseChatModel extends index_js_2.BaseLanguageModel {
     _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.

package/dist/chat_models/base.d.ts

@@ -49,6 +49,8 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     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.
@@ -63,6 +65,11 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
     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.
@@ -109,7 +116,7 @@ export declare abstract class BaseChatModel<CallOptions extends BaseChatModelCal
  * An abstract class that extends BaseChatModel and provides a simple
  * implementation of _generate.
  */
-export declare abstract class SimpleChatModel extends BaseChatModel {
+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>;
 }

package/dist/chat_models/base.js

@@ -90,33 +90,18 @@ export class BaseChatModel extends BaseLanguageModel {
             })));
         }
     }
-    /**
-     * 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;
-        }
+    /** @ignore */
+    async _generateUncached(messages, parsedOptions, handledOptions) {
         const baseMessages = messages.map((messageList) => messageList.map(coerceMessageLikeToMessage));
-        const [runnableConfig, callOptions] = this._separateRunnableConfigFromCallOptions(parsedOptions);
         // create callback manager and start run
-        const callbackManager_ = await CallbackManager.configure(runnableConfig.callbacks ?? callbacks, this.callbacks, runnableConfig.tags, this.tags, runnableConfig.metadata, this.metadata, { verbose: this.verbose });
+        const callbackManager_ = await CallbackManager.configure(handledOptions.callbacks, this.callbacks, handledOptions.tags, this.tags, handledOptions.metadata, this.metadata, { verbose: this.verbose });
         const extra = {
-            options: callOptions,
+            options: parsedOptions,
             invocation_params: this?.invocationParams(parsedOptions),
         };
         const runManagers = await callbackManager_?.handleChatModelStart(this.toJSON(), baseMessages, undefined, undefined, extra);
         // generate results
-        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...callOptions, promptIndex: i }, runManagers?.[i])));
+        const results = await Promise.allSettled(baseMessages.map((messageList, i) => this._generate(messageList, { ...parsedOptions, promptIndex: i }, runManagers?.[i])));
         // handle results
         const generations = [];
         const llmOutputs = [];
@@ -151,6 +136,54 @@ export class BaseChatModel extends BaseLanguageModel {
         });
         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(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
      */
@@ -161,6 +194,17 @@ export class BaseChatModel extends BaseLanguageModel {
     _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.

package/dist/chat_models/fireworks.cjs

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatFireworks = void 0;
+const openai_js_1 = require("./openai.cjs");
+const env_js_1 = require("../util/env.cjs");
+/**
+ * Wrapper around Fireworks API for large language models fine-tuned for chat
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+class ChatFireworks extends openai_js_1.ChatOpenAI {
+    static lc_name() {
+        return "ChatFireworks";
+    }
+    _llmType() {
+        return "fireworks";
+    }
+    get lc_secrets() {
+        return {
+            fireworksApiKey: "FIREWORKS_API_KEY",
+        };
+    }
+    constructor(fields) {
+        const fireworksApiKey = fields?.fireworksApiKey || (0, env_js_1.getEnvironmentVariable)("FIREWORKS_API_KEY");
+        if (!fireworksApiKey) {
+            throw new Error(`Fireworks API key not found. Please set the FIREWORKS_API_KEY environment variable or provide the key into "fireworksApiKey"`);
+        }
+        super({
+            ...fields,
+            modelName: fields?.modelName || "accounts/fireworks/models/llama-v2-13b-chat",
+            openAIApiKey: fireworksApiKey,
+            configuration: {
+                baseURL: "https://api.fireworks.ai/inference/v1",
+            },
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fireworksApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fireworksApiKey = fireworksApiKey;
+    }
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Calls the Fireworks API with retry logic in case of failures.
+     * @param request The request to send to the Fireworks API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the Fireworks API.
+     */
+    async completionWithRetry(request, options) {
+        delete request.frequency_penalty;
+        delete request.presence_penalty;
+        delete request.logit_bias;
+        delete request.functions;
+        if (request.stream === true) {
+            return super.completionWithRetry(request, options);
+        }
+        return super.completionWithRetry(request, options);
+    }
+}
+exports.ChatFireworks = ChatFireworks;

package/dist/chat_models/fireworks.d.ts

@@ -0,0 +1,33 @@
+import type { OpenAI as OpenAIClient } from "openai";
+import type { ChatOpenAICallOptions, OpenAIChatInput } from "./openai.js";
+import type { OpenAICoreRequestOptions } from "../types/openai-types.js";
+import type { BaseChatModelParams } from "./base.js";
+import { ChatOpenAI } from "./openai.js";
+type FireworksUnsupportedArgs = "frequencyPenalty" | "presencePenalty" | "logitBias" | "functions";
+type FireworksUnsupportedCallOptions = "functions" | "function_call" | "tools";
+export type ChatFireworksCallOptions = Partial<Omit<ChatOpenAICallOptions, FireworksUnsupportedCallOptions>>;
+/**
+ * Wrapper around Fireworks API for large language models fine-tuned for chat
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+export declare class ChatFireworks extends ChatOpenAI<ChatFireworksCallOptions> {
+    static lc_name(): string;
+    _llmType(): string;
+    get lc_secrets(): {
+        [key: string]: string;
+    } | undefined;
+    lc_serializable: boolean;
+    fireworksApiKey?: string;
+    constructor(fields?: Partial<Omit<OpenAIChatInput, "openAIApiKey" | FireworksUnsupportedArgs>> & BaseChatModelParams & {
+        fireworksApiKey?: string;
+    });
+    toJSON(): import("../load/serializable.js").Serialized;
+    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsStreaming, options?: OpenAICoreRequestOptions): Promise<AsyncIterable<OpenAIClient.Chat.Completions.ChatCompletionChunk>>;
+    completionWithRetry(request: OpenAIClient.Chat.ChatCompletionCreateParamsNonStreaming, options?: OpenAICoreRequestOptions): Promise<OpenAIClient.Chat.Completions.ChatCompletion>;
+}
+export {};

package/dist/chat_models/fireworks.js

@@ -0,0 +1,77 @@
+import { ChatOpenAI } from "./openai.js";
+import { getEnvironmentVariable } from "../util/env.js";
+/**
+ * Wrapper around Fireworks API for large language models fine-tuned for chat
+ *
+ * Fireworks API is compatible to the OpenAI API with some limitations described in
+ * https://readme.fireworks.ai/docs/openai-compatibility.
+ *
+ * To use, you should have the `openai` package installed and
+ * the `FIREWORKS_API_KEY` environment variable set.
+ */
+export class ChatFireworks extends ChatOpenAI {
+    static lc_name() {
+        return "ChatFireworks";
+    }
+    _llmType() {
+        return "fireworks";
+    }
+    get lc_secrets() {
+        return {
+            fireworksApiKey: "FIREWORKS_API_KEY",
+        };
+    }
+    constructor(fields) {
+        const fireworksApiKey = fields?.fireworksApiKey || getEnvironmentVariable("FIREWORKS_API_KEY");
+        if (!fireworksApiKey) {
+            throw new Error(`Fireworks API key not found. Please set the FIREWORKS_API_KEY environment variable or provide the key into "fireworksApiKey"`);
+        }
+        super({
+            ...fields,
+            modelName: fields?.modelName || "accounts/fireworks/models/llama-v2-13b-chat",
+            openAIApiKey: fireworksApiKey,
+            configuration: {
+                baseURL: "https://api.fireworks.ai/inference/v1",
+            },
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "fireworksApiKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.fireworksApiKey = fireworksApiKey;
+    }
+    toJSON() {
+        const result = super.toJSON();
+        if ("kwargs" in result &&
+            typeof result.kwargs === "object" &&
+            result.kwargs != null) {
+            delete result.kwargs.openai_api_key;
+            delete result.kwargs.configuration;
+        }
+        return result;
+    }
+    /**
+     * Calls the Fireworks API with retry logic in case of failures.
+     * @param request The request to send to the Fireworks API.
+     * @param options Optional configuration for the API call.
+     * @returns The response from the Fireworks API.
+     */
+    async completionWithRetry(request, options) {
+        delete request.frequency_penalty;
+        delete request.presence_penalty;
+        delete request.logit_bias;
+        delete request.functions;
+        if (request.stream === true) {
+            return super.completionWithRetry(request, options);
+        }
+        return super.completionWithRetry(request, options);
+    }
+}

package/dist/chat_models/ollama.cjs

@@ -303,11 +303,28 @@ class ChatOllama extends base_js_1.SimpleChatModel {
             prompt: this._formatMessagesAsPrompt(input),
         }, options));
         for await (const chunk of stream) {
-            yield new index_js_1.ChatGenerationChunk({
-                text: chunk.response,
-                message: new index_js_1.AIMessageChunk({ content: chunk.response }),
-            });
-            await runManager?.handleLLMNewToken(chunk.response ?? "");
+            if (!chunk.done) {
+                yield new index_js_1.ChatGenerationChunk({
+                    text: chunk.response,
+                    message: new index_js_1.AIMessageChunk({ content: chunk.response }),
+                });
+                await runManager?.handleLLMNewToken(chunk.response ?? "");
+            }
+            else {
+                yield new index_js_1.ChatGenerationChunk({
+                    text: "",
+                    message: new index_js_1.AIMessageChunk({ content: "" }),
+                    generationInfo: {
+                        model: chunk.model,
+                        total_duration: chunk.total_duration,
+                        load_duration: chunk.load_duration,
+                        prompt_eval_count: chunk.prompt_eval_count,
+                        prompt_eval_duration: chunk.prompt_eval_duration,
+                        eval_count: chunk.eval_count,
+                        eval_duration: chunk.eval_duration,
+                    },
+                });
+            }
         }
     }
     _formatMessagesAsPrompt(messages) {

package/dist/chat_models/ollama.d.ts

@@ -14,8 +14,7 @@ export interface OllamaCallOptions extends BaseLanguageModelCallOptions {
  * models in a chat-like fashion. It extends the SimpleChatModel class and
  * implements the OllamaInput interface.
  */
-export declare class ChatOllama extends SimpleChatModel implements OllamaInput {
-    CallOptions: OllamaCallOptions;
+export declare class ChatOllama extends SimpleChatModel<OllamaCallOptions> implements OllamaInput {
     static lc_name(): string;
     lc_serializable: boolean;
     model: string;

package/dist/chat_models/ollama.js

@@ -300,11 +300,28 @@ export class ChatOllama extends SimpleChatModel {
             prompt: this._formatMessagesAsPrompt(input),
         }, options));
         for await (const chunk of stream) {
-            yield new ChatGenerationChunk({
-                text: chunk.response,
-                message: new AIMessageChunk({ content: chunk.response }),
-            });
-            await runManager?.handleLLMNewToken(chunk.response ?? "");
+            if (!chunk.done) {
+                yield new ChatGenerationChunk({
+                    text: chunk.response,
+                    message: new AIMessageChunk({ content: chunk.response }),
+                });
+                await runManager?.handleLLMNewToken(chunk.response ?? "");
+            }
+            else {
+                yield new ChatGenerationChunk({
+                    text: "",
+                    message: new AIMessageChunk({ content: "" }),
+                    generationInfo: {
+                        model: chunk.model,
+                        total_duration: chunk.total_duration,
+                        load_duration: chunk.load_duration,
+                        prompt_eval_count: chunk.prompt_eval_count,
+                        prompt_eval_duration: chunk.prompt_eval_duration,
+                        eval_count: chunk.eval_count,
+                        eval_duration: chunk.eval_duration,
+                    },
+                });
+            }
         }
     }
     _formatMessagesAsPrompt(messages) {

package/dist/chat_models/openai.d.ts

@@ -37,9 +37,9 @@ export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCa
  * `openai.createChatCompletion`} can be passed through {@link modelKwargs}, even
  * if not explicitly available on this class.
  */
-export declare class ChatOpenAI extends BaseChatModel<ChatOpenAICallOptions> implements OpenAIChatInput, AzureOpenAIInput {
+export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatModel<CallOptions> implements OpenAIChatInput, AzureOpenAIInput {
     static lc_name(): string;
-    get callKeys(): (keyof ChatOpenAICallOptions)[];
+    get callKeys(): string[];
     lc_serializable: boolean;
     get lc_secrets(): {
         [key: string]: string;

package/dist/llms/base.cjs

@@ -1,16 +1,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LLM = exports.BaseLLM = void 0;
-const index_js_1 = require("../cache/index.cjs");
-const index_js_2 = require("../schema/index.cjs");
-const index_js_3 = require("../base_language/index.cjs");
+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");
 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_3.BaseLanguageModel {
-    constructor({ cache, concurrency, ...rest }) {
+class BaseLLM extends index_js_2.BaseLanguageModel {
+    constructor({ concurrency, ...rest }) {
         super(concurrency ? { maxConcurrency: concurrency, ...rest } : rest);
         Object.defineProperty(this, "lc_namespace", {
             enumerable: true,
@@ -18,21 +17,6 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
             writable: true,
             value: ["langchain", "llms", this._llmType()]
         });
-        Object.defineProperty(this, "cache", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        if (typeof cache === "object") {
-            this.cache = cache;
-        }
-        else if (cache) {
-            this.cache = index_js_1.InMemoryCache.global();
-        }
-        else {
-            this.cache = undefined;
-        }
     }
     /**
      * This method takes an input and options, and returns a string. It
@@ -72,7 +56,7 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
                 invocation_params: this?.invocationParams(callOptions),
             };
             const runManagers = await callbackManager_?.handleLLMStart(this.toJSON(), [prompt.toString()], undefined, undefined, extra);
-            let generation = new index_js_2.GenerationChunk({
+            let generation = new index_js_1.GenerationChunk({
                 text: "",
             });
             try {
@@ -160,7 +144,7 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
         // 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_2.RUN_KEY, {
+        Object.defineProperty(output, index_js_1.RUN_KEY, {
             value: runIds ? { runIds } : undefined,
             configurable: true,
         });
@@ -186,9 +170,7 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
             return this._generateUncached(prompts, callOptions, runnableConfig);
         }
         const { cache } = this;
-        const params = this.serialize();
-        params.stop = callOptions.stop ?? params.stop;
-        const llmStringKey = `${Object.entries(params).sort()}`;
+        const llmStringKey = this._getSerializedCacheKeyParametersForCall(callOptions);
         const missingPromptIndices = [];
         const generations = await Promise.all(prompts.map(async (prompt, index) => {
             const result = await cache.lookup(prompt, llmStringKey);
@@ -238,7 +220,7 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
     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_2.AIMessage(prediction);
+        return new index_js_1.AIMessage(prediction);
     }
     /**
      * Get the identifying parameters of the LLM.
@@ -248,6 +230,7 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
         return {};
     }
     /**
+     * @deprecated
      * Return a json-like object representing this LLM.
      */
     serialize() {
@@ -261,6 +244,7 @@ class BaseLLM extends index_js_3.BaseLanguageModel {
         return "base_llm";
     }
     /**
+     * @deprecated
      * Load an LLM from a json-like object describing it.
      */
     static async deserialize(data) {