langchain 0.0.74 → 0.0.76

package/dist/chains/summarization/load.js

@@ -3,39 +3,48 @@ import { StuffDocumentsChain, MapReduceDocumentsChain, RefineDocumentsChain, } f
 import { DEFAULT_PROMPT } from "./stuff_prompts.js";
 import { REFINE_PROMPT } from "./refine_prompts.js";
 export const loadSummarizationChain = (llm, params = { type: "map_reduce" }) => {
+    const { verbose } = params;
     if (params.type === "stuff") {
         const { prompt = DEFAULT_PROMPT } = params;
-        const llmChain = new LLMChain({ prompt, llm });
+        const llmChain = new LLMChain({ prompt, llm, verbose });
         const chain = new StuffDocumentsChain({
             llmChain,
             documentVariableName: "text",
+            verbose,
         });
         return chain;
     }
     if (params.type === "map_reduce") {
         const { combineMapPrompt = DEFAULT_PROMPT, combinePrompt = DEFAULT_PROMPT, returnIntermediateSteps, } = params;
-        const llmChain = new LLMChain({ prompt: combineMapPrompt, llm });
-        const combineLLMChain = new LLMChain({ prompt: combinePrompt, llm });
+        const llmChain = new LLMChain({ prompt: combineMapPrompt, llm, verbose });
+        const combineLLMChain = new LLMChain({
+            prompt: combinePrompt,
+            llm,
+            verbose,
+        });
         const combineDocumentChain = new StuffDocumentsChain({
             llmChain: combineLLMChain,
             documentVariableName: "text",
+            verbose,
         });
         const chain = new MapReduceDocumentsChain({
             llmChain,
             combineDocumentChain,
             documentVariableName: "text",
             returnIntermediateSteps,
+            verbose,
         });
         return chain;
     }
     if (params.type === "refine") {
         const { refinePrompt = REFINE_PROMPT, questionPrompt = DEFAULT_PROMPT } = params;
-        const llmChain = new LLMChain({ prompt: questionPrompt, llm });
-        const refineLLMChain = new LLMChain({ prompt: refinePrompt, llm });
+        const llmChain = new LLMChain({ prompt: questionPrompt, llm, verbose });
+        const refineLLMChain = new LLMChain({ prompt: refinePrompt, llm, verbose });
         const chain = new RefineDocumentsChain({
             llmChain,
             refineLLMChain,
             documentVariableName: "text",
+            verbose,
         });
         return chain;
     }

package/dist/chat_models/anthropic.cjs

@@ -31,6 +31,9 @@ const DEFAULT_STOP_SEQUENCES = [sdk_1.HUMAN_PROMPT];
  *
  */
 class ChatAnthropic extends base_js_1.BaseChatModel {
+    get callKeys() {
+        return ["stop", "signal", "options"];
+    }
     constructor(fields) {
         super(fields ?? {});
         Object.defineProperty(this, "apiKey", {
@@ -160,18 +163,18 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
             .join("") + sdk_1.AI_PROMPT);
     }
     /** @ignore */
-    async _generate(messages, stopSequences, runManager) {
-        if (this.stopSequences && stopSequences) {
+    async _generate(messages, options, runManager) {
+        if (this.stopSequences && options.stop) {
             throw new Error(`"stopSequence" parameter found in input and default params`);
         }
         const params = this.invocationParams();
-        params.stop_sequences = stopSequences
-            ? stopSequences.concat(DEFAULT_STOP_SEQUENCES)
+        params.stop_sequences = options.stop
+            ? options.stop.concat(DEFAULT_STOP_SEQUENCES)
             : params.stop_sequences;
         const response = await this.completionWithRetry({
             ...params,
             prompt: this.formatMessagesAsPrompt(messages),
-        }, runManager);
+        }, { signal: options.signal }, runManager);
         const generations = response.completion
             .split(sdk_1.AI_PROMPT)
             .map((message) => ({
@@ -183,7 +186,7 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
         };
     }
     /** @ignore */
-    async completionWithRetry(request, runManager) {
+    async completionWithRetry(request, options, runManager) {
         if (!this.apiKey) {
             throw new Error("Missing Anthropic API key.");
         }
@@ -194,7 +197,8 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
             }
             makeCompletionRequest = async () => {
                 let currentCompletion = "";
-                return this.streamingClient.completeStream(request, {
+                return (this.streamingClient
+                    .completeStream(request, {
                     onUpdate: (data) => {
                         if (data.stop_reason) {
                             return;
@@ -207,14 +211,37 @@ class ChatAnthropic extends base_js_1.BaseChatModel {
                             void runManager?.handleLLMNewToken(delta ?? "");
                         }
                     },
-                });
+                    signal: options.signal,
+                })
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    .catch((e) => {
+                    // Anthropic doesn't actually throw JavaScript error objects at the moment.
+                    // We convert the error so the async caller can recognize it correctly.
+                    if (e?.name === "AbortError") {
+                        throw new Error(`${e.name}: ${e.message}`);
+                    }
+                    throw e;
+                }));
             };
         }
         else {
             if (!this.batchClient) {
                 this.batchClient = new sdk_1.Client(this.apiKey);
             }
-            makeCompletionRequest = async () => this.batchClient.complete(request);
+            makeCompletionRequest = async () => this.batchClient
+                .complete(request, {
+                signal: options.signal,
+            })
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .catch((e) => {
+                console.log(e);
+                // Anthropic doesn't actually throw JavaScript error objects at the moment.
+                // We convert the error so the async caller can recognize it correctly.
+                if (e?.type === "aborted") {
+                    throw new Error(`${e.name}: ${e.message}`);
+                }
+                throw e;
+            });
         }
         return this.caller.call(makeCompletionRequest);
     }

package/dist/chat_models/anthropic.d.ts

@@ -1,7 +1,8 @@
-import { CompletionResponse, SamplingParameters } from "@anthropic-ai/sdk";
+import { SamplingParameters } from "@anthropic-ai/sdk";
 import { BaseChatModel, BaseChatModelParams } from "./base.js";
 import { BaseChatMessage, ChatResult } from "../schema/index.js";
 import { CallbackManagerForLLMRun } from "../callbacks/manager.js";
+import { BaseLanguageModelCallOptions } from "../base_language/index.js";
 /**
  * Input to AnthropicChat class.
  */
@@ -60,6 +61,8 @@ type Kwargs = Record<string, any>;
  *
  */
 export declare class ChatAnthropic extends BaseChatModel implements AnthropicInput {
+    CallOptions: BaseLanguageModelCallOptions;
+    get callKeys(): string[];
     apiKey?: string;
     temperature: number;
     topK: number;
@@ -108,9 +111,9 @@ export declare class ChatAnthropic extends BaseChatModel implements AnthropicInp
     };
     private formatMessagesAsPrompt;
     /** @ignore */
-    _generate(messages: BaseChatMessage[], stopSequences?: string[], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _generate(messages: BaseChatMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     /** @ignore */
-    completionWithRetry(request: SamplingParameters & Kwargs, runManager?: CallbackManagerForLLMRun): Promise<CompletionResponse>;
+    private completionWithRetry;
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(): never[];

package/dist/chat_models/anthropic.js

@@ -28,6 +28,9 @@ const DEFAULT_STOP_SEQUENCES = [HUMAN_PROMPT];
  *
  */
 export class ChatAnthropic extends BaseChatModel {
+    get callKeys() {
+        return ["stop", "signal", "options"];
+    }
     constructor(fields) {
         super(fields ?? {});
         Object.defineProperty(this, "apiKey", {
@@ -157,18 +160,18 @@ export class ChatAnthropic extends BaseChatModel {
             .join("") + AI_PROMPT);
     }
     /** @ignore */
-    async _generate(messages, stopSequences, runManager) {
-        if (this.stopSequences && stopSequences) {
+    async _generate(messages, options, runManager) {
+        if (this.stopSequences && options.stop) {
             throw new Error(`"stopSequence" parameter found in input and default params`);
         }
         const params = this.invocationParams();
-        params.stop_sequences = stopSequences
-            ? stopSequences.concat(DEFAULT_STOP_SEQUENCES)
+        params.stop_sequences = options.stop
+            ? options.stop.concat(DEFAULT_STOP_SEQUENCES)
             : params.stop_sequences;
         const response = await this.completionWithRetry({
             ...params,
             prompt: this.formatMessagesAsPrompt(messages),
-        }, runManager);
+        }, { signal: options.signal }, runManager);
         const generations = response.completion
             .split(AI_PROMPT)
             .map((message) => ({
@@ -180,7 +183,7 @@ export class ChatAnthropic extends BaseChatModel {
         };
     }
     /** @ignore */
-    async completionWithRetry(request, runManager) {
+    async completionWithRetry(request, options, runManager) {
         if (!this.apiKey) {
             throw new Error("Missing Anthropic API key.");
         }
@@ -191,7 +194,8 @@ export class ChatAnthropic extends BaseChatModel {
             }
             makeCompletionRequest = async () => {
                 let currentCompletion = "";
-                return this.streamingClient.completeStream(request, {
+                return (this.streamingClient
+                    .completeStream(request, {
                     onUpdate: (data) => {
                         if (data.stop_reason) {
                             return;
@@ -204,14 +208,37 @@ export class ChatAnthropic extends BaseChatModel {
                             void runManager?.handleLLMNewToken(delta ?? "");
                         }
                     },
-                });
+                    signal: options.signal,
+                })
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    .catch((e) => {
+                    // Anthropic doesn't actually throw JavaScript error objects at the moment.
+                    // We convert the error so the async caller can recognize it correctly.
+                    if (e?.name === "AbortError") {
+                        throw new Error(`${e.name}: ${e.message}`);
+                    }
+                    throw e;
+                }));
             };
         }
         else {
             if (!this.batchClient) {
                 this.batchClient = new AnthropicApi(this.apiKey);
             }
-            makeCompletionRequest = async () => this.batchClient.complete(request);
+            makeCompletionRequest = async () => this.batchClient
+                .complete(request, {
+                signal: options.signal,
+            })
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                .catch((e) => {
+                console.log(e);
+                // Anthropic doesn't actually throw JavaScript error objects at the moment.
+                // We convert the error so the async caller can recognize it correctly.
+                if (e?.type === "aborted") {
+                    throw new Error(`${e.name}: ${e.message}`);
+                }
+                throw e;
+            });
         }
         return this.caller.call(makeCompletionRequest);
     }

package/dist/chat_models/base.cjs

@@ -3,20 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.SimpleChatModel = exports.BaseChatModel = void 0;
 const index_js_1 = require("../schema/index.cjs");
 const index_js_2 = require("../base_language/index.cjs");
-const base_js_1 = require("../memory/base.cjs");
 const manager_js_1 = require("../callbacks/manager.cjs");
 class BaseChatModel extends index_js_2.BaseLanguageModel {
     constructor(fields) {
         super(fields);
     }
-    async generate(messages, stop, callbacks) {
+    async generate(messages, options, callbacks) {
         const generations = [];
         const llmOutputs = [];
-        const messageStrings = messages.map((messageList) => (0, base_js_1.getBufferString)(messageList));
+        let parsedOptions;
+        if (Array.isArray(options)) {
+            parsedOptions = { stop: options };
+        }
+        else if (options?.timeout && !options.signal) {
+            parsedOptions = {
+                ...options,
+                signal: AbortSignal.timeout(options.timeout),
+            };
+        }
+        else {
+            parsedOptions = options ?? {};
+        }
         const callbackManager_ = await manager_js_1.CallbackManager.configure(callbacks, this.callbacks, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleLLMStart({ name: this._llmType() }, messageStrings);
+        const invocationParams = { invocation_params: this?.invocationParams() };
+        const runManager = await callbackManager_?.handleChatModelStart({ name: this._llmType() }, messages, undefined, undefined, invocationParams);
         try {
-            const results = await Promise.all(messages.map((messageList) => this._generate(messageList, stop, runManager)));
+            const results = await Promise.all(messages.map((messageList) => this._generate(messageList, parsedOptions, runManager)));
             for (const result of results) {
                 if (result.llmOutput) {
                     llmOutputs.push(result.llmOutput);
@@ -41,27 +53,42 @@ class BaseChatModel extends index_js_2.BaseLanguageModel {
         });
         return output;
     }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    invocationParams() {
+        return {};
+    }
     _modelType() {
         return "base_chat_model";
     }
-    async generatePrompt(promptValues, stop, callbacks) {
+    async generatePrompt(promptValues, options, callbacks) {
         const promptMessages = promptValues.map((promptValue) => promptValue.toChatMessages());
-        return this.generate(promptMessages, stop, callbacks);
+        return this.generate(promptMessages, options, callbacks);
     }
-    async call(messages, stop, callbacks) {
-        const result = await this.generate([messages], stop, callbacks);
+    async call(messages, options, callbacks) {
+        const result = await this.generate([messages], options, callbacks);
         const generations = result.generations;
         return generations[0][0].message;
     }
-    async callPrompt(promptValue, stop, callbacks) {
+    async callPrompt(promptValue, options, callbacks) {
         const promptMessages = promptValue.toChatMessages();
-        return this.call(promptMessages, stop, callbacks);
+        return this.call(promptMessages, options, callbacks);
+    }
+    async predictMessages(messages, options, callbacks) {
+        return this.call(messages, options, callbacks);
+    }
+    async predict(text, options, callbacks) {
+        const message = new index_js_1.HumanChatMessage(text);
+        const result = await this.call([message], options, callbacks);
+        return result.text;
     }
 }
 exports.BaseChatModel = BaseChatModel;
 class SimpleChatModel extends BaseChatModel {
-    async _generate(messages, stop, runManager) {
-        const text = await this._call(messages, stop, runManager);
+    async _generate(messages, options, runManager) {
+        const text = await this._call(messages, options, runManager);
         const message = new index_js_1.AIChatMessage(text);
         return {
             generations: [

package/dist/chat_models/base.d.ts

@@ -13,17 +13,24 @@ export type BaseChatModelParams = BaseLanguageModelParams;
 export type BaseChatModelCallOptions = BaseLanguageModelCallOptions;
 export declare abstract class BaseChatModel extends BaseLanguageModel {
     CallOptions: BaseChatModelCallOptions;
+    ParsedCallOptions: Omit<this["CallOptions"], "timeout">;
     constructor(fields: BaseChatModelParams);
     abstract _combineLLMOutput?(...llmOutputs: LLMResult["llmOutput"][]): LLMResult["llmOutput"];
-    generate(messages: BaseChatMessage[][], stop?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
+    generate(messages: BaseChatMessage[][], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
+    /**
+     * Get the parameters used to invoke the model
+     */
+    invocationParams(): any;
     _modelType(): string;
     abstract _llmType(): string;
-    generatePrompt(promptValues: BasePromptValue[], stop?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
-    abstract _generate(messages: BaseChatMessage[], stop?: string[] | this["CallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
-    call(messages: BaseChatMessage[], stop?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
-    callPrompt(promptValue: BasePromptValue, stop?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
+    generatePrompt(promptValues: BasePromptValue[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<LLMResult>;
+    abstract _generate(messages: BaseChatMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    call(messages: BaseChatMessage[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
+    callPrompt(promptValue: BasePromptValue, options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
+    predictMessages(messages: BaseChatMessage[], options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<BaseChatMessage>;
+    predict(text: string, options?: string[] | this["CallOptions"], callbacks?: Callbacks): Promise<string>;
 }
 export declare abstract class SimpleChatModel extends BaseChatModel {
-    abstract _call(messages: BaseChatMessage[], stop?: string[] | this["CallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
-    _generate(messages: BaseChatMessage[], stop?: string[] | this["CallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    abstract _call(messages: BaseChatMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<string>;
+    _generate(messages: BaseChatMessage[], options: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
 }

package/dist/chat_models/base.js

@@ -1,19 +1,31 @@
-import { AIChatMessage, RUN_KEY, } from "../schema/index.js";
+import { AIChatMessage, HumanChatMessage, RUN_KEY, } from "../schema/index.js";
 import { BaseLanguageModel, } from "../base_language/index.js";
-import { getBufferString } from "../memory/base.js";
 import { CallbackManager, } from "../callbacks/manager.js";
 export class BaseChatModel extends BaseLanguageModel {
     constructor(fields) {
         super(fields);
     }
-    async generate(messages, stop, callbacks) {
+    async generate(messages, options, callbacks) {
         const generations = [];
         const llmOutputs = [];
-        const messageStrings = messages.map((messageList) => getBufferString(messageList));
+        let parsedOptions;
+        if (Array.isArray(options)) {
+            parsedOptions = { stop: options };
+        }
+        else if (options?.timeout && !options.signal) {
+            parsedOptions = {
+                ...options,
+                signal: AbortSignal.timeout(options.timeout),
+            };
+        }
+        else {
+            parsedOptions = options ?? {};
+        }
         const callbackManager_ = await CallbackManager.configure(callbacks, this.callbacks, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleLLMStart({ name: this._llmType() }, messageStrings);
+        const invocationParams = { invocation_params: this?.invocationParams() };
+        const runManager = await callbackManager_?.handleChatModelStart({ name: this._llmType() }, messages, undefined, undefined, invocationParams);
         try {
-            const results = await Promise.all(messages.map((messageList) => this._generate(messageList, stop, runManager)));
+            const results = await Promise.all(messages.map((messageList) => this._generate(messageList, parsedOptions, runManager)));
             for (const result of results) {
                 if (result.llmOutput) {
                     llmOutputs.push(result.llmOutput);
@@ -38,26 +50,41 @@ export class BaseChatModel extends BaseLanguageModel {
         });
         return output;
     }
+    /**
+     * Get the parameters used to invoke the model
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    invocationParams() {
+        return {};
+    }
     _modelType() {
         return "base_chat_model";
     }
-    async generatePrompt(promptValues, stop, callbacks) {
+    async generatePrompt(promptValues, options, callbacks) {
         const promptMessages = promptValues.map((promptValue) => promptValue.toChatMessages());
-        return this.generate(promptMessages, stop, callbacks);
+        return this.generate(promptMessages, options, callbacks);
     }
-    async call(messages, stop, callbacks) {
-        const result = await this.generate([messages], stop, callbacks);
+    async call(messages, options, callbacks) {
+        const result = await this.generate([messages], options, callbacks);
         const generations = result.generations;
         return generations[0][0].message;
     }
-    async callPrompt(promptValue, stop, callbacks) {
+    async callPrompt(promptValue, options, callbacks) {
         const promptMessages = promptValue.toChatMessages();
-        return this.call(promptMessages, stop, callbacks);
+        return this.call(promptMessages, options, callbacks);
+    }
+    async predictMessages(messages, options, callbacks) {
+        return this.call(messages, options, callbacks);
+    }
+    async predict(text, options, callbacks) {
+        const message = new HumanChatMessage(text);
+        const result = await this.call([message], options, callbacks);
+        return result.text;
     }
 }
 export class SimpleChatModel extends BaseChatModel {
-    async _generate(messages, stop, runManager) {
-        const text = await this._call(messages, stop, runManager);
+    async _generate(messages, options, runManager) {
+        const text = await this._call(messages, options, runManager);
         const message = new AIChatMessage(text);
         return {
             generations: [

package/dist/chat_models/openai.cjs

@@ -4,8 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ChatOpenAI = void 0;
-const browser_or_node_1 = require("browser-or-node");
 const openai_1 = require("openai");
+const env_js_1 = require("../util/env.cjs");
 const axios_fetch_adapter_js_1 = __importDefault(require("../util/axios-fetch-adapter.cjs"));
 const base_js_1 = require("./base.cjs");
 const index_js_1 = require("../schema/index.cjs");
@@ -53,6 +53,9 @@ function openAIResponseToChatMessage(role, text) {
  * if not explicitly available on this class.
  */
 class ChatOpenAI extends base_js_1.BaseChatModel {
+    get callKeys() {
+        return ["stop", "signal", "timeout", "options"];
+    }
     constructor(fields, configuration) {
         super(fields ?? {});
         Object.defineProperty(this, "temperature", {
@@ -259,19 +262,13 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
         return this._identifyingParams();
     }
     /** @ignore */
-    async _generate(messages, stopOrOptions, runManager) {
-        const stop = Array.isArray(stopOrOptions)
-            ? stopOrOptions
-            : stopOrOptions?.stop;
-        const options = Array.isArray(stopOrOptions)
-            ? {}
-            : stopOrOptions?.options ?? {};
+    async _generate(messages, options, runManager) {
         const tokenUsage = {};
-        if (this.stop && stop) {
+        if (this.stop && options?.stop) {
             throw new Error("Stop found in input and default params");
         }
         const params = this.invocationParams();
-        params.stop = stop ?? params.stop;
+        params.stop = options?.stop ?? params.stop;
         const messagesMapped = messages.map((message) => ({
             role: messageTypeToOpenAIRole(message._getType()),
             content: message.text,
@@ -286,7 +283,8 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
                     ...params,
                     messages: messagesMapped,
                 }, {
-                    ...options,
+                    signal: options?.signal,
+                    ...options?.options,
                     adapter: axios_fetch_adapter_js_1.default,
                     responseType: "stream",
                     onmessage: (event) => {
@@ -352,7 +350,10 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
             : await this.completionWithRetry({
                 ...params,
                 messages: messagesMapped,
-            }, options);
+            }, {
+                signal: options?.signal,
+                ...options?.options,
+            });
         const { completion_tokens: completionTokens, prompt_tokens: promptTokens, total_tokens: totalTokens, } = data.usage ?? {};
         if (completionTokens) {
             tokenUsage.completionTokens =
@@ -393,10 +394,15 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
         }
         const countPerMessage = await Promise.all(messages.map(async (message) => {
             const textCount = await this.getNumTokens(message.text);
-            const count = textCount + tokensPerMessage + (message.name ? tokensPerName : 0);
+            const roleCount = await this.getNumTokens(messageTypeToOpenAIRole(message._getType()));
+            const nameCount = message.name !== undefined
+                ? tokensPerName + (await this.getNumTokens(message.name))
+                : 0;
+            const count = textCount + tokensPerMessage + roleCount + nameCount;
             totalCount += count;
             return count;
         }));
+        totalCount += 3; // every reply is primed with <|start|>assistant<|message|>
         return { totalCount, countPerMessage };
     }
     /** @ignore */
@@ -416,7 +422,7 @@ class ChatOpenAI extends base_js_1.BaseChatModel {
             this.client = new openai_1.OpenAIApi(clientConfig);
         }
         const axiosOptions = {
-            adapter: browser_or_node_1.isNode ? undefined : axios_fetch_adapter_js_1.default,
+            adapter: (0, env_js_1.isNode)() ? undefined : axios_fetch_adapter_js_1.default,
             ...this.clientConfig.baseOptions,
             ...options,
         };

package/dist/chat_models/openai.d.ts

@@ -33,6 +33,7 @@ interface OpenAILLMOutput {
  */
 export declare class ChatOpenAI extends BaseChatModel implements OpenAIChatInput, AzureOpenAIInput {
     CallOptions: OpenAICallOptions;
+    get callKeys(): (keyof OpenAICallOptions)[];
     temperature: number;
     topP: number;
     frequencyPenalty: number;
@@ -109,7 +110,7 @@ export declare class ChatOpenAI extends BaseChatModel implements OpenAIChatInput
         model_name: string;
     };
     /** @ignore */
-    _generate(messages: BaseChatMessage[], stopOrOptions?: string[] | this["CallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
+    _generate(messages: BaseChatMessage[], options?: this["ParsedCallOptions"], runManager?: CallbackManagerForLLMRun): Promise<ChatResult>;
     getNumTokensFromMessages(messages: BaseChatMessage[]): Promise<{
         totalCount: number;
         countPerMessage: number[];