@langchain/openai 0.0.27 → 0.0.29

package/dist/azure/chat_models.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AzureChatOpenAI = void 0;
+const openai_1 = require("openai");
 const chat_models_js_1 = require("../chat_models.cjs");
+const azure_js_1 = require("../utils/azure.cjs");
 class AzureChatOpenAI extends chat_models_js_1.ChatOpenAI {
     _llmType() {
         return "azure_openai";
@@ -14,21 +16,59 @@ class AzureChatOpenAI extends chat_models_js_1.ChatOpenAI {
         };
     }
     constructor(fields) {
-        // assume the base URL does not contain "openai" nor "deployments" prefix
-        let basePath = fields?.openAIBasePath ?? "";
-        if (!basePath.endsWith("/"))
-            basePath += "/";
-        if (!basePath.endsWith("openai/deployments"))
-            basePath += "openai/deployments";
         const newFields = fields ? { ...fields } : fields;
         if (newFields) {
-            newFields.azureOpenAIBasePath = basePath;
             newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
             newFields.azureOpenAIApiKey = newFields.openAIApiKey;
             newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
         }
         super(newFields);
     }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = (0, azure_js_1.getEndpoint)(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new openai_1.AzureOpenAI({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                deployment: this.azureOpenAIApiDeploymentName,
+                ...params,
+            });
+        }
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return requestOptions;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON() {
         const json = super.toJSON();

package/dist/azure/chat_models.d.ts

@@ -1,7 +1,7 @@
 import { type ClientOptions } from "openai";
 import { type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import { ChatOpenAI } from "../chat_models.js";
-import { AzureOpenAIInput, LegacyOpenAIInput, OpenAIChatInput } from "../types.js";
+import { AzureOpenAIInput, LegacyOpenAIInput, OpenAIChatInput, OpenAICoreRequestOptions } from "../types.js";
 export declare class AzureChatOpenAI extends ChatOpenAI {
     _llmType(): string;
     get lc_aliases(): Record<string, string>;
@@ -13,5 +13,6 @@ export declare class AzureChatOpenAI extends ChatOpenAI {
     } & BaseChatModelParams & {
         configuration?: ClientOptions & LegacyOpenAIInput;
     });
+    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     toJSON(): any;
 }

package/dist/azure/chat_models.js

@@ -1,4 +1,6 @@
+import { AzureOpenAI as AzureOpenAIClient } from "openai";
 import { ChatOpenAI } from "../chat_models.js";
+import { getEndpoint } from "../utils/azure.js";
 export class AzureChatOpenAI extends ChatOpenAI {
     _llmType() {
         return "azure_openai";
@@ -11,21 +13,59 @@ export class AzureChatOpenAI extends ChatOpenAI {
         };
     }
     constructor(fields) {
-        // assume the base URL does not contain "openai" nor "deployments" prefix
-        let basePath = fields?.openAIBasePath ?? "";
-        if (!basePath.endsWith("/"))
-            basePath += "/";
-        if (!basePath.endsWith("openai/deployments"))
-            basePath += "openai/deployments";
         const newFields = fields ? { ...fields } : fields;
         if (newFields) {
-            newFields.azureOpenAIBasePath = basePath;
             newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
             newFields.azureOpenAIApiKey = newFields.openAIApiKey;
             newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
         }
         super(newFields);
     }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new AzureOpenAIClient({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                deployment: this.azureOpenAIApiDeploymentName,
+                ...params,
+            });
+        }
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return requestOptions;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON() {
         const json = super.toJSON();

package/dist/azure/embeddings.cjs

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AzureOpenAIEmbeddings = void 0;
+const openai_1 = require("openai");
+const embeddings_js_1 = require("../embeddings.cjs");
+const azure_js_1 = require("../utils/azure.cjs");
+const openai_js_1 = require("../utils/openai.cjs");
+class AzureOpenAIEmbeddings extends embeddings_js_1.OpenAIEmbeddings {
+    constructor(fields, configuration) {
+        const newFields = { ...fields };
+        if (Object.entries(newFields).length) {
+            newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
+            newFields.azureOpenAIApiKey = newFields.apiKey;
+            newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
+        }
+        super(newFields, configuration);
+    }
+    async embeddingWithRetry(request) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = (0, azure_js_1.getEndpoint)(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new openai_1.AzureOpenAI({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                deployment: this.azureOpenAIApiDeploymentName,
+                ...params,
+            });
+        }
+        const requestOptions = {};
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.embeddings.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = (0, openai_js_1.wrapOpenAIClientError)(e);
+                throw error;
+            }
+        });
+    }
+}
+exports.AzureOpenAIEmbeddings = AzureOpenAIEmbeddings;

package/dist/azure/embeddings.d.ts

@@ -0,0 +1,14 @@
+import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
+import { OpenAIEmbeddings, OpenAIEmbeddingsParams } from "../embeddings.js";
+import { AzureOpenAIInput, LegacyOpenAIInput } from "../types.js";
+export declare class AzureOpenAIEmbeddings extends OpenAIEmbeddings {
+    constructor(fields?: Partial<OpenAIEmbeddingsParams> & Partial<AzureOpenAIInput> & {
+        verbose?: boolean;
+        /** The OpenAI API key to use. */
+        apiKey?: string;
+        configuration?: ClientOptions;
+        deploymentName?: string;
+        openAIApiVersion?: string;
+    }, configuration?: ClientOptions & LegacyOpenAIInput);
+    protected embeddingWithRetry(request: OpenAIClient.EmbeddingCreateParams): Promise<OpenAIClient.Embeddings.CreateEmbeddingResponse>;
+}

package/dist/azure/embeddings.js

@@ -0,0 +1,66 @@
+import { AzureOpenAI as AzureOpenAIClient, } from "openai";
+import { OpenAIEmbeddings } from "../embeddings.js";
+import { getEndpoint } from "../utils/azure.js";
+import { wrapOpenAIClientError } from "../utils/openai.js";
+export class AzureOpenAIEmbeddings extends OpenAIEmbeddings {
+    constructor(fields, configuration) {
+        const newFields = { ...fields };
+        if (Object.entries(newFields).length) {
+            newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
+            newFields.azureOpenAIApiKey = newFields.apiKey;
+            newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
+        }
+        super(newFields, configuration);
+    }
+    async embeddingWithRetry(request) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new AzureOpenAIClient({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                deployment: this.azureOpenAIApiDeploymentName,
+                ...params,
+            });
+        }
+        const requestOptions = {};
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return this.caller.call(async () => {
+            try {
+                const res = await this.client.embeddings.create(request, requestOptions);
+                return res;
+            }
+            catch (e) {
+                const error = wrapOpenAIClientError(e);
+                throw error;
+            }
+        });
+    }
+}

package/dist/azure/llms.cjs

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AzureOpenAI = void 0;
+const openai_1 = require("openai");
 const llms_js_1 = require("../llms.cjs");
+const azure_js_1 = require("../utils/azure.cjs");
 class AzureOpenAI extends llms_js_1.OpenAI {
     get lc_aliases() {
         return {
@@ -11,21 +13,58 @@ class AzureOpenAI extends llms_js_1.OpenAI {
         };
     }
     constructor(fields) {
-        // assume the base URL does not contain "openai" nor "deployments" prefix
-        let basePath = fields?.openAIBasePath ?? "";
-        if (!basePath.endsWith("/"))
-            basePath += "/";
-        if (!basePath.endsWith("openai/deployments"))
-            basePath += "openai/deployments";
         const newFields = fields ? { ...fields } : fields;
         if (newFields) {
-            newFields.azureOpenAIBasePath = basePath;
             newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
             newFields.azureOpenAIApiKey = newFields.openAIApiKey;
             newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
         }
         super(newFields);
     }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = (0, azure_js_1.getEndpoint)(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new openai_1.AzureOpenAI({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                ...params,
+            });
+        }
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return requestOptions;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON() {
         const json = super.toJSON();

package/dist/azure/llms.d.ts

@@ -1,7 +1,7 @@
 import { type ClientOptions } from "openai";
 import { type BaseLLMParams } from "@langchain/core/language_models/llms";
 import { OpenAI } from "../llms.js";
-import type { OpenAIInput, AzureOpenAIInput, LegacyOpenAIInput } from "../types.js";
+import type { OpenAIInput, AzureOpenAIInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "../types.js";
 export declare class AzureOpenAI extends OpenAI {
     get lc_aliases(): Record<string, string>;
     constructor(fields?: Partial<OpenAIInput> & {
@@ -12,5 +12,6 @@ export declare class AzureOpenAI extends OpenAI {
     } & Partial<AzureOpenAIInput> & BaseLLMParams & {
         configuration?: ClientOptions & LegacyOpenAIInput;
     });
+    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     toJSON(): any;
 }

package/dist/azure/llms.js

@@ -1,4 +1,6 @@
+import { AzureOpenAI as AzureOpenAIClient } from "openai";
 import { OpenAI } from "../llms.js";
+import { getEndpoint } from "../utils/azure.js";
 export class AzureOpenAI extends OpenAI {
     get lc_aliases() {
         return {
@@ -8,21 +10,58 @@ export class AzureOpenAI extends OpenAI {
         };
     }
     constructor(fields) {
-        // assume the base URL does not contain "openai" nor "deployments" prefix
-        let basePath = fields?.openAIBasePath ?? "";
-        if (!basePath.endsWith("/"))
-            basePath += "/";
-        if (!basePath.endsWith("openai/deployments"))
-            basePath += "openai/deployments";
         const newFields = fields ? { ...fields } : fields;
         if (newFields) {
-            newFields.azureOpenAIBasePath = basePath;
             newFields.azureOpenAIApiDeploymentName = newFields.deploymentName;
             newFields.azureOpenAIApiKey = newFields.openAIApiKey;
             newFields.azureOpenAIApiVersion = newFields.openAIApiVersion;
         }
         super(newFields);
     }
+    _getClientOptions(options) {
+        if (!this.client) {
+            const openAIEndpointConfig = {
+                azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
+                azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
+                azureOpenAIApiKey: this.azureOpenAIApiKey,
+                azureOpenAIBasePath: this.azureOpenAIBasePath,
+                baseURL: this.clientConfig.baseURL,
+            };
+            const endpoint = getEndpoint(openAIEndpointConfig);
+            const params = {
+                ...this.clientConfig,
+                baseURL: endpoint,
+                timeout: this.timeout,
+                maxRetries: 0,
+            };
+            if (!this.azureADTokenProvider) {
+                params.apiKey = openAIEndpointConfig.azureOpenAIApiKey;
+            }
+            if (!params.baseURL) {
+                delete params.baseURL;
+            }
+            this.client = new AzureOpenAIClient({
+                apiVersion: this.azureOpenAIApiVersion,
+                azureADTokenProvider: this.azureADTokenProvider,
+                ...params,
+            });
+        }
+        const requestOptions = {
+            ...this.clientConfig,
+            ...options,
+        };
+        if (this.azureOpenAIApiKey) {
+            requestOptions.headers = {
+                "api-key": this.azureOpenAIApiKey,
+                ...requestOptions.headers,
+            };
+            requestOptions.query = {
+                "api-version": this.azureOpenAIApiVersion,
+                ...requestOptions.query,
+            };
+        }
+        return requestOptions;
+    }
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     toJSON() {
         const json = super.toJSON();

package/dist/chat_models.cjs

@@ -48,12 +48,30 @@ function messageToOpenAIRole(message) {
 }
 exports.messageToOpenAIRole = messageToOpenAIRole;
 function openAIResponseToChatMessage(message) {
+    const rawToolCalls = message.tool_calls;
     switch (message.role) {
-        case "assistant":
-            return new messages_1.AIMessage(message.content || "", {
-                function_call: message.function_call,
-                tool_calls: message.tool_calls,
+        case "assistant": {
+            const toolCalls = [];
+            const invalidToolCalls = [];
+            for (const rawToolCall of rawToolCalls ?? []) {
+                try {
+                    toolCalls.push((0, openai_tools_1.parseToolCall)(rawToolCall, { returnId: true }));
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                }
+                catch (e) {
+                    invalidToolCalls.push((0, openai_tools_1.makeInvalidToolCall)(rawToolCall, e.message));
+                }
+            }
+            return new messages_1.AIMessage({
+                content: message.content || "",
+                tool_calls: toolCalls,
+                invalid_tool_calls: invalidToolCalls,
+                additional_kwargs: {
+                    function_call: message.function_call,
+                    tool_calls: rawToolCalls,
+                },
             });
+        }
         default:
             return new messages_1.ChatMessage(message.content || "", message.role ?? "unknown");
     }
@@ -81,7 +99,22 @@ delta, defaultRole) {
         return new messages_1.HumanMessageChunk({ content });
     }
     else if (role === "assistant") {
-        return new messages_1.AIMessageChunk({ content, additional_kwargs });
+        const toolCallChunks = [];
+        if (Array.isArray(delta.tool_calls)) {
+            for (const rawToolCall of delta.tool_calls) {
+                toolCallChunks.push({
+                    name: rawToolCall.function?.name,
+                    args: rawToolCall.function?.arguments,
+                    id: rawToolCall.id,
+                    index: rawToolCall.index,
+                });
+            }
+        }
+        return new messages_1.AIMessageChunk({
+            content,
+            tool_call_chunks: toolCallChunks,
+            additional_kwargs,
+        });
     }
     else if (role === "system") {
         return new messages_1.SystemMessageChunk({ content });
@@ -118,11 +151,16 @@ function convertMessagesToOpenAIParams(messages) {
         if (message.additional_kwargs.function_call != null) {
             completionParam.function_call = message.additional_kwargs.function_call;
         }
-        if (message.additional_kwargs.tool_calls != null) {
-            completionParam.tool_calls = message.additional_kwargs.tool_calls;
+        if ((0, messages_1.isAIMessage)(message) && !!message.tool_calls?.length) {
+            completionParam.tool_calls = message.tool_calls.map(openai_tools_1.convertLangChainToolCallToOpenAI);
         }
-        if (message.tool_call_id != null) {
-            completionParam.tool_call_id = message.tool_call_id;
+        else {
+            if (message.additional_kwargs.tool_calls != null) {
+                completionParam.tool_calls = message.additional_kwargs.tool_calls;
+            }
+            if (message.tool_call_id != null) {
+                completionParam.tool_call_id = message.tool_call_id;
+            }
         }
         return completionParam;
     });
@@ -333,6 +371,12 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             writable: true,
             value: void 0
         });
+        Object.defineProperty(this, "azureADTokenProvider", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
         Object.defineProperty(this, "azureOpenAIApiInstanceName", {
             enumerable: true,
             configurable: true,
@@ -377,8 +421,9 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         this.azureOpenAIApiKey =
             fields?.azureOpenAIApiKey ??
                 (0, env_1.getEnvironmentVariable)("AZURE_OPENAI_API_KEY");
-        if (!this.azureOpenAIApiKey && !this.apiKey) {
-            throw new Error("OpenAI or Azure OpenAI API key not found");
+        this.azureADTokenProvider = fields?.azureADTokenProvider ?? undefined;
+        if (!this.azureOpenAIApiKey && !this.apiKey && !this.azureADTokenProvider) {
+            throw new Error("OpenAI or Azure OpenAI API key or Token Provider not found");
         }
         this.azureOpenAIApiInstanceName =
             fields?.azureOpenAIApiInstanceName ??
@@ -412,7 +457,7 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
         this.stopSequences = this?.stop;
         this.user = fields?.user;
         this.streaming = fields?.streaming ?? false;
-        if (this.azureOpenAIApiKey) {
+        if (this.azureOpenAIApiKey || this.azureADTokenProvider) {
             if (!this.azureOpenAIApiInstanceName && !this.azureOpenAIBasePath) {
                 throw new Error("Azure OpenAI API instance name not found");
             }
@@ -437,6 +482,12 @@ class ChatOpenAI extends chat_models_1.BaseChatModel {
             ...fields?.configuration,
         };
     }
+    bindTools(tools, kwargs) {
+        return this.bind({
+            tools: tools.map(function_calling_1.convertToOpenAITool),
+            ...kwargs,
+        });
+    }
     /**
      * Get the parameters used to invoke the model
      */

package/dist/chat_models.d.ts

@@ -1,12 +1,12 @@
 import { type ClientOptions, OpenAI as OpenAIClient } from "openai";
 import { CallbackManagerForLLMRun } from "@langchain/core/callbacks/manager";
-import { type BaseMessage } from "@langchain/core/messages";
+import { AIMessageChunk, type BaseMessage } from "@langchain/core/messages";
 import { ChatGenerationChunk, type ChatResult } from "@langchain/core/outputs";
 import { type StructuredToolInterface } from "@langchain/core/tools";
 import { BaseChatModel, type BaseChatModelParams } from "@langchain/core/language_models/chat_models";
 import type { BaseFunctionCallOptions, BaseLanguageModelInput, StructuredOutputMethodOptions, StructuredOutputMethodParams } from "@langchain/core/language_models/base";
 import { z } from "zod";
-import { Runnable } from "@langchain/core/runnables";
+import { Runnable, RunnableInterface } from "@langchain/core/runnables";
 import type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput, OpenAICoreRequestOptions, LegacyOpenAIInput } from "./types.js";
 export type { AzureOpenAIInput, OpenAICallOptions, OpenAIChatInput };
 interface TokenUsage {
@@ -62,7 +62,7 @@ export interface ChatOpenAICallOptions extends OpenAICallOptions, BaseFunctionCa
  *
  * ```
  */
-export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatModel<CallOptions> implements OpenAIChatInput, AzureOpenAIInput {
+export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = ChatOpenAICallOptions> extends BaseChatModel<CallOptions, AIMessageChunk> implements OpenAIChatInput, AzureOpenAIInput {
     static lc_name(): string;
     get callKeys(): string[];
     lc_serializable: boolean;
@@ -91,17 +91,19 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
     apiKey?: string;
     azureOpenAIApiVersion?: string;
     azureOpenAIApiKey?: string;
+    azureADTokenProvider?: () => Promise<string>;
     azureOpenAIApiInstanceName?: string;
     azureOpenAIApiDeploymentName?: string;
     azureOpenAIBasePath?: string;
     organization?: string;
-    private client;
-    private clientConfig;
+    protected client: OpenAIClient;
+    protected clientConfig: ClientOptions;
     constructor(fields?: Partial<OpenAIChatInput> & Partial<AzureOpenAIInput> & BaseChatModelParams & {
         configuration?: ClientOptions & LegacyOpenAIInput;
     }, 
     /** @deprecated */
     configuration?: ClientOptions & LegacyOpenAIInput);
+    bindTools(tools: (Record<string, unknown> | StructuredToolInterface)[], kwargs?: Partial<CallOptions>): RunnableInterface<BaseLanguageModelInput, AIMessageChunk, CallOptions>;
     /**
      * Get the parameters used to invoke the model
      */
@@ -141,7 +143,7 @@ export declare class ChatOpenAI<CallOptions extends ChatOpenAICallOptions = Chat
      */
     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>;
-    private _getClientOptions;
+    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
     _llmType(): string;
     /** @ignore */
     _combineLLMOutput(...llmOutputs: OpenAILLMOutput[]): OpenAILLMOutput;