@librechat/agents 2.4.38 → 2.4.40

package/dist/types/llm/openai/index.d.ts

@@ -2,8 +2,40 @@ import { AzureOpenAI as AzureOpenAIClient } from 'openai';
 import { ChatXAI as OriginalChatXAI } from '@langchain/xai';
 import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
 import { OpenAIClient, ChatOpenAI as OriginalChatOpenAI, AzureChatOpenAI as OriginalAzureChatOpenAI } from '@langchain/openai';
-import type { OpenAICoreRequestOptions } from 'node_modules/@langchain/deepseek/node_modules/@langchain/openai';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { AIMessageChunk } from '@langchain/core/messages';
+import type { Runnable } from '@langchain/core/runnables';
 import type * as t from '@langchain/openai';
+import { BaseLanguageModelInput } from '@langchain/core/language_models/base';
+type ResponsesCreateParams = Parameters<OpenAIClient.Responses['create']>[0];
+type ResponsesTool = Exclude<ResponsesCreateParams['tools'], undefined>[number];
+type ChatOpenAIToolType = BindToolsInput | OpenAIClient.ChatCompletionTool | ResponsesTool;
+type HeaderValue = string | undefined | null;
+export type HeadersLike = Headers | readonly HeaderValue[][] | Record<string, HeaderValue | readonly HeaderValue[]> | undefined | null | {
+    values: Headers;
+    [key: string]: unknown;
+};
+export declare function isHeaders(headers: unknown): headers is Headers;
+export declare function normalizeHeaders(headers: HeadersLike): Record<string, HeaderValue | readonly HeaderValue[]>;
+type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
+/**
+ * Formats a tool in either OpenAI format, or LangChain structured tool format
+ * into an OpenAI tool format. If the tool is already in OpenAI format, return without
+ * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
+ * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
+ * returned from the `zodFunction` util are not defined.
+ *
+ * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
+ * @param {Object} [fields] Additional fields to add to the OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+ */
+export declare function _convertToOpenAITool(tool: BindToolsInput, fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+}): OpenAIClient.ChatCompletionTool;
 export declare class CustomOpenAIClient extends OpenAIClient {
     abortHandler?: () => void;
     fetchWithTimeout(url: RequestInfo, init: RequestInit | undefined, ms: number, controller: AbortController): Promise<Response>;
@@ -14,11 +46,12 @@ export declare class CustomAzureOpenAIClient extends AzureOpenAIClient {
 }
 export declare class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
     get exposedClient(): CustomOpenAIClient;
-    protected _getClientOptions(options?: t.OpenAICoreRequestOptions): t.OpenAICoreRequestOptions;
+    bindTools(tools: ChatOpenAIToolType[], kwargs?: Partial<t.ChatOpenAICallOptions>): Runnable<BaseLanguageModelInput, AIMessageChunk, t.ChatOpenAICallOptions>;
+    protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
 }
 export declare class AzureChatOpenAI extends OriginalAzureChatOpenAI {
     get exposedClient(): CustomOpenAIClient;
-    protected _getClientOptions(options: t.OpenAICoreRequestOptions | undefined): t.OpenAICoreRequestOptions;
+    protected _getClientOptions(options: OpenAICoreRequestOptions | undefined): OpenAICoreRequestOptions;
 }
 export declare class ChatDeepSeek extends OriginalChatDeepSeek {
     get exposedClient(): CustomOpenAIClient;
@@ -28,3 +61,4 @@ export declare class ChatXAI extends OriginalChatXAI {
     get exposedClient(): CustomOpenAIClient;
     protected _getClientOptions(options?: OpenAICoreRequestOptions): OpenAICoreRequestOptions;
 }
+export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@librechat/agents",
-  "version": "2.4.38",
+  "version": "2.4.40",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -72,18 +72,18 @@
     "format": "prettier --write ."
   },
   "dependencies": {
-    "@langchain/anthropic": "^0.3.21",
-    "@langchain/aws": "^0.1.10",
-    "@langchain/community": "^0.3.44",
-    "@langchain/core": "^0.3.57",
-    "@langchain/deepseek": "^0.0.1",
-    "@langchain/google-genai": "^0.2.9",
-    "@langchain/google-vertexai": "^0.2.9",
-    "@langchain/langgraph": "^0.2.73",
-    "@langchain/mistralai": "^0.2.0",
-    "@langchain/ollama": "^0.2.0",
-    "@langchain/openai": "^0.5.11",
-    "@langchain/xai": "^0.0.2",
+    "@langchain/anthropic": "^0.3.23",
+    "@langchain/aws": "^0.1.11",
+    "@langchain/community": "^0.3.47",
+    "@langchain/core": "^0.3.60",
+    "@langchain/deepseek": "^0.0.2",
+    "@langchain/google-genai": "^0.2.13",
+    "@langchain/google-vertexai": "^0.2.13",
+    "@langchain/langgraph": "^0.3.4",
+    "@langchain/mistralai": "^0.2.1",
+    "@langchain/ollama": "^0.2.3",
+    "@langchain/openai": "^0.5.14",
+    "@langchain/xai": "^0.0.3",
     "cheerio": "^1.0.0",
     "dotenv": "^16.4.7",
     "https-proxy-agent": "^7.0.6",

package/src/graphs/Graph.ts

@@ -184,10 +184,9 @@ export class StandardGraph extends Graph<t.BaseGraphState, GraphNode> {
       finalInstructions &&
       provider === Providers.ANTHROPIC &&
       ((
-        clientOptions as t.AnthropicClientOptions
-      ).clientOptions?.defaultHeaders?.['anthropic-beta']?.includes(
-        'prompt-caching'
-      ) ??
+        (clientOptions as t.AnthropicClientOptions).clientOptions
+          ?.defaultHeaders as Record<string, string> | undefined
+      )?.['anthropic-beta']?.includes('prompt-caching') ??
         false)
     ) {
       finalInstructions = {

package/src/llm/anthropic/types.ts

@@ -1,6 +1,10 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { BindToolsInput } from '@langchain/core/language_models/chat_models';
 
+export type AnthropicStreamUsage = Anthropic.Usage;
+export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
+export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
+
 export type AnthropicToolResponse = {
   type: 'tool_use';
   id: string;
@@ -9,10 +13,7 @@ export type AnthropicToolResponse = {
   input: Record<string, any>;
 };
 
-export type AnthropicStreamUsage = Anthropic.Usage;
 export type AnthropicMessageParam = Anthropic.MessageParam;
-export type AnthropicMessageDeltaEvent = Anthropic.MessageDeltaEvent;
-export type AnthropicMessageStartEvent = Anthropic.MessageStartEvent;
 export type AnthropicMessageResponse =
   | Anthropic.ContentBlock
   | AnthropicToolResponse;
@@ -42,6 +43,25 @@ export type AnthropicDocumentBlockParam = Anthropic.Messages.DocumentBlockParam;
 export type AnthropicThinkingBlockParam = Anthropic.Messages.ThinkingBlockParam;
 export type AnthropicRedactedThinkingBlockParam =
   Anthropic.Messages.RedactedThinkingBlockParam;
+export type AnthropicServerToolUseBlockParam =
+  Anthropic.Messages.ServerToolUseBlockParam;
+export type AnthropicWebSearchToolResultBlockParam =
+  Anthropic.Messages.WebSearchToolResultBlockParam;
+export type AnthropicWebSearchResultBlockParam =
+  Anthropic.Messages.WebSearchResultBlockParam;
+
+// Union of all possible content block types including server tool use
+export type AnthropicContentBlock =
+  | AnthropicTextBlockParam
+  | AnthropicImageBlockParam
+  | AnthropicToolUseBlockParam
+  | AnthropicToolResultBlockParam
+  | AnthropicDocumentBlockParam
+  | AnthropicThinkingBlockParam
+  | AnthropicRedactedThinkingBlockParam
+  | AnthropicServerToolUseBlockParam
+  | AnthropicWebSearchToolResultBlockParam
+  | AnthropicWebSearchResultBlockParam;
 
 export function isAnthropicImageBlockParam(
   block: unknown

package/src/llm/anthropic/utils/message_inputs.ts

@@ -21,7 +21,7 @@ import {
   parseBase64DataUrl,
 } from '@langchain/core/messages';
 import { ToolCall } from '@langchain/core/messages/tool';
-import type {
+import {
   AnthropicImageBlockParam,
   AnthropicMessageCreateParams,
   AnthropicTextBlockParam,
@@ -31,8 +31,10 @@ import type {
   AnthropicDocumentBlockParam,
   AnthropicThinkingBlockParam,
   AnthropicRedactedThinkingBlockParam,
+  AnthropicServerToolUseBlockParam,
+  AnthropicWebSearchToolResultBlockParam,
+  isAnthropicImageBlockParam,
 } from '@/llm/anthropic/types';
-import { isAnthropicImageBlockParam } from '@/llm/anthropic/types';
 
 function _formatImage(imageUrl: string) {
   const parsed = parseBase64DataUrl({ dataUrl: imageUrl });
@@ -119,7 +121,6 @@ function _ensureMessageContents(
               {
                 type: 'tool_result',
                 // rare case: message.content could be undefined
-                // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
                 ...(message.content != null
                   ? { content: _formatContent(message.content) }
                   : {}),
@@ -347,7 +348,14 @@ const standardContentBlockConverter: StandardContentBlockConverter<{
 };
 
 function _formatContent(content: MessageContent) {
-  const toolTypes = ['tool_use', 'tool_result', 'input_json_delta'];
+  const toolTypes = [
+    'tool_use',
+    'tool_result',
+    'input_json_delta',
+    'server_tool_use',
+    'web_search_tool_result',
+    'web_search_result',
+  ];
   const textTypes = ['text', 'text_delta'];
 
   if (typeof content === 'string') {
@@ -408,6 +416,9 @@ function _formatContent(content: MessageContent) {
           type: 'text' as const, // Explicitly setting the type as "text"
           text: contentPart.text,
           ...(cacheControl ? { cache_control: cacheControl } : {}),
+          ...('citations' in contentPart && contentPart.citations
+            ? { citations: contentPart.citations }
+            : {}),
         };
       } else if (toolTypes.find((t) => t === contentPart.type)) {
         const contentPartCopy = { ...contentPart };
@@ -502,7 +513,8 @@ export function _convertMessagesToAnthropicPayload(
           content.find(
             (contentPart) =>
               (contentPart.type === 'tool_use' ||
-                contentPart.type === 'input_json_delta') &&
+                contentPart.type === 'input_json_delta' ||
+                contentPart.type === 'server_tool_use') &&
               contentPart.id === toolCall.id
           )
         );
@@ -548,6 +560,8 @@ function mergeMessages(messages: AnthropicMessageCreateParams['messages']) {
           | AnthropicDocumentBlockParam
           | AnthropicThinkingBlockParam
           | AnthropicRedactedThinkingBlockParam
+          | AnthropicServerToolUseBlockParam
+          | AnthropicWebSearchToolResultBlockParam
         >
   ): Array<
     | AnthropicTextBlockParam
@@ -557,6 +571,8 @@ function mergeMessages(messages: AnthropicMessageCreateParams['messages']) {
     | AnthropicDocumentBlockParam
     | AnthropicThinkingBlockParam
     | AnthropicRedactedThinkingBlockParam
+    | AnthropicServerToolUseBlockParam
+    | AnthropicWebSearchToolResultBlockParam
   > => {
     if (typeof content === 'string') {
       return [

package/src/llm/anthropic/utils/message_outputs.ts

@@ -77,7 +77,12 @@ export function _makeMessageChunkFromAnthropicEvent(
     };
   } else if (
     data.type === 'content_block_start' &&
-    ['tool_use', 'document'].includes(data.content_block.type)
+    [
+      'tool_use',
+      'document',
+      'server_tool_use',
+      'web_search_tool_result',
+    ].includes(data.content_block.type)
   ) {
     const contentBlock = data.content_block;
     let toolCallChunks: ToolCallChunk[];
@@ -90,6 +95,16 @@ export function _makeMessageChunkFromAnthropicEvent(
           args: '',
         },
       ];
+    } else if (contentBlock.type === 'server_tool_use') {
+      // Handle anthropic built-in server tool use (like web search)
+      toolCallChunks = [
+        {
+          id: contentBlock.id,
+          index: data.index,
+          name: contentBlock.name,
+          args: '',
+        },
+      ];
     } else {
       toolCallChunks = [];
     }
@@ -101,7 +116,11 @@ export function _makeMessageChunkFromAnthropicEvent(
             {
               index: data.index,
               ...data.content_block,
-              input: '',
+              input:
+                  contentBlock.type === 'server_tool_use' ||
+                  contentBlock.type === 'tool_use'
+                    ? ''
+                    : undefined,
             },
           ],
         additional_kwargs: {},

package/src/llm/anthropic/utils/output_parsers.ts

@@ -1,11 +1,14 @@
 /* eslint-disable @typescript-eslint/explicit-function-return-type */
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-import { z } from 'zod';
 import {
   BaseLLMOutputParser,
   OutputParserException,
 } from '@langchain/core/output_parsers';
 import { JsonOutputKeyToolsParserParams } from '@langchain/core/output_parsers/openai_tools';
+import {
+  interopSafeParseAsync,
+  InteropZodType,
+} from '@langchain/core/utils/types';
 import { ChatGeneration } from '@langchain/core/outputs';
 import { ToolCall } from '@langchain/core/messages/tool';
 
@@ -31,7 +34,7 @@ export class AnthropicToolsOutputParser<
   /** Whether to return only the first tool call. */
   returnSingle = false;
 
-  zodSchema?: z.ZodType<T>;
+  zodSchema?: InteropZodType<T>;
 
   constructor(params: AnthropicToolsOutputParserParams<T>) {
     super(params);
@@ -62,7 +65,10 @@ export class AnthropicToolsOutputParser<
     if (this.zodSchema === undefined) {
       return parsedResult as T;
     }
-    const zodParsedResult = await this.zodSchema.safeParseAsync(parsedResult);
+    const zodParsedResult = await interopSafeParseAsync(
+      this.zodSchema,
+      parsedResult
+    );
     if (zodParsedResult.success) {
       return zodParsedResult.data;
     } else {
@@ -71,7 +77,7 @@ export class AnthropicToolsOutputParser<
           result,
           null,
           2
-        )}". Error: ${JSON.stringify(zodParsedResult.error.errors)}`,
+        )}". Error: ${JSON.stringify(zodParsedResult.error.issues)}`,
         JSON.stringify(parsedResult, null, 2)
       );
     }
@@ -100,6 +106,7 @@ export class AnthropicToolsOutputParser<
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export function extractToolCalls(content: Record<string, any>[]) {
   const toolCalls: ToolCall[] = [];
+
   for (const block of content) {
     if (block.type === 'tool_use') {
       toolCalls.push({
@@ -108,7 +115,19 @@ export function extractToolCalls(content: Record<string, any>[]) {
         id: block.id,
         type: 'tool_call',
       });
+    } else if (
+      block.type === 'server_tool_use' &&
+      block.name === 'web_search'
+    ) {
+      // Handle Anthropic built-in web search tool
+      toolCalls.push({
+        name: block.name,
+        args: block.input,
+        id: block.id,
+        type: 'tool_call',
+      });
     }
   }
+
   return toolCalls;
 }

package/src/llm/openai/index.ts

@@ -4,17 +4,150 @@ import { ChatDeepSeek as OriginalChatDeepSeek } from '@langchain/deepseek';
 import {
   getEndpoint,
   OpenAIClient,
+  formatToOpenAITool,
   ChatOpenAI as OriginalChatOpenAI,
   AzureChatOpenAI as OriginalAzureChatOpenAI,
 } from '@langchain/openai';
-import type { OpenAICoreRequestOptions } from 'node_modules/@langchain/deepseek/node_modules/@langchain/openai';
+import { isLangChainTool } from '@langchain/core/utils/function_calling';
+import type { BindToolsInput } from '@langchain/core/language_models/chat_models';
+import type { OpenAIEndpointConfig } from '@langchain/openai/dist/utils/azure';
+import type { AIMessageChunk } from '@langchain/core/messages';
+import type { Runnable } from '@langchain/core/runnables';
 import type * as t from '@langchain/openai';
+import {
+  isOpenAITool,
+  ToolDefinition,
+  BaseLanguageModelInput,
+} from '@langchain/core/language_models/base';
+
+type ResponsesCreateParams = Parameters<OpenAIClient.Responses['create']>[0];
+type ResponsesTool = Exclude<ResponsesCreateParams['tools'], undefined>[number];
+
+type ChatOpenAIToolType =
+  | BindToolsInput
+  | OpenAIClient.ChatCompletionTool
+  | ResponsesTool;
+
+type HeaderValue = string | undefined | null;
+export type HeadersLike =
+  | Headers
+  | readonly HeaderValue[][]
+  | Record<string, HeaderValue | readonly HeaderValue[]>
+  | undefined
+  | null
+  // NullableHeaders
+  | { values: Headers; [key: string]: unknown };
+
+// eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+const iife = <T>(fn: () => T) => fn();
+
+export function isHeaders(headers: unknown): headers is Headers {
+  return (
+    typeof Headers !== 'undefined' &&
+    headers !== null &&
+    typeof headers === 'object' &&
+    Object.prototype.toString.call(headers) === '[object Headers]'
+  );
+}
+
+export function normalizeHeaders(
+  headers: HeadersLike
+): Record<string, HeaderValue | readonly HeaderValue[]> {
+  const output = iife(() => {
+    // If headers is a Headers instance
+    if (isHeaders(headers)) {
+      return headers;
+    }
+    // If headers is an array of [key, value] pairs
+    else if (Array.isArray(headers)) {
+      return new Headers(headers);
+    }
+    // If headers is a NullableHeaders-like object (has 'values' property that is a Headers)
+    else if (
+      typeof headers === 'object' &&
+      headers !== null &&
+      'values' in headers &&
+      isHeaders(headers.values)
+    ) {
+      return headers.values;
+    }
+    // If headers is a plain object
+    else if (typeof headers === 'object' && headers !== null) {
+      const entries: [string, string][] = Object.entries(headers)
+        .filter(([, v]) => typeof v === 'string')
+        .map(([k, v]) => [k, v as string]);
+      return new Headers(entries);
+    }
+    return new Headers();
+  });
+
+  return Object.fromEntries(output.entries());
+}
+
+type OpenAICoreRequestOptions = OpenAIClient.RequestOptions;
 
 function createAbortHandler(controller: AbortController): () => void {
   return function (): void {
     controller.abort();
   };
 }
+/**
+ * Formats a tool in either OpenAI format, or LangChain structured tool format
+ * into an OpenAI tool format. If the tool is already in OpenAI format, return without
+ * any changes. If it is in LangChain structured tool format, convert it to OpenAI tool format
+ * using OpenAI's `zodFunction` util, falling back to `convertToOpenAIFunction` if the parameters
+ * returned from the `zodFunction` util are not defined.
+ *
+ * @param {BindToolsInput} tool The tool to convert to an OpenAI tool.
+ * @param {Object} [fields] Additional fields to add to the OpenAI tool.
+ * @returns {ToolDefinition} The inputted tool in OpenAI tool format.
+ */
+export function _convertToOpenAITool(
+  tool: BindToolsInput,
+  fields?: {
+    /**
+     * If `true`, model output is guaranteed to exactly match the JSON Schema
+     * provided in the function definition.
+     */
+    strict?: boolean;
+  }
+): OpenAIClient.ChatCompletionTool {
+  let toolDef: OpenAIClient.ChatCompletionTool | undefined;
+
+  if (isLangChainTool(tool)) {
+    toolDef = formatToOpenAITool(tool);
+  } else {
+    toolDef = tool as ToolDefinition;
+  }
+
+  if (fields?.strict !== undefined) {
+    toolDef.function.strict = fields.strict;
+  }
+
+  return toolDef;
+}
+
+function _convertChatOpenAIToolTypeToOpenAITool(
+  tool: ChatOpenAIToolType,
+  fields?: {
+    strict?: boolean;
+  }
+): OpenAIClient.ChatCompletionTool {
+  if (isOpenAITool(tool)) {
+    if (fields?.strict !== undefined) {
+      return {
+        ...tool,
+        function: {
+          ...tool.function,
+          strict: fields.strict,
+        },
+      };
+    }
+
+    return tool;
+  }
+  return _convertToOpenAITool(tool, fields);
+}
 
 export class CustomOpenAIClient extends OpenAIClient {
   abortHandler?: () => void;
@@ -87,13 +220,36 @@ export class CustomAzureOpenAIClient extends AzureOpenAIClient {
   }
 }
 
+function isBuiltInTool(tool: ChatOpenAIToolType): tool is ResponsesTool {
+  return 'type' in tool && tool.type !== 'function';
+}
+
 export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;
   }
+  override bindTools(
+    tools: ChatOpenAIToolType[],
+    kwargs?: Partial<t.ChatOpenAICallOptions>
+  ): Runnable<BaseLanguageModelInput, AIMessageChunk, t.ChatOpenAICallOptions> {
+    let strict: boolean | undefined;
+    if (kwargs?.strict !== undefined) {
+      strict = kwargs.strict;
+    } else if (this.supportsStrictToolCalling !== undefined) {
+      strict = this.supportsStrictToolCalling;
+    }
+    return this.withConfig({
+      tools: tools.map((tool) =>
+        isBuiltInTool(tool)
+          ? tool
+          : _convertChatOpenAIToolTypeToOpenAITool(tool, { strict })
+      ),
+      ...kwargs,
+    } as Partial<t.ChatOpenAICallOptions>);
+  }
   protected _getClientOptions(
-    options?: t.OpenAICoreRequestOptions
-  ): t.OpenAICoreRequestOptions {
+    options?: OpenAICoreRequestOptions
+  ): OpenAICoreRequestOptions {
     if (!(this.client as OpenAIClient | undefined)) {
       const openAIEndpointConfig: t.OpenAIEndpointConfig = {
         baseURL: this.clientConfig.baseURL,
@@ -115,7 +271,7 @@ export class ChatOpenAI extends OriginalChatOpenAI<t.ChatOpenAICallOptions> {
     const requestOptions = {
       ...this.clientConfig,
       ...options,
-    } as t.OpenAICoreRequestOptions;
+    } as OpenAICoreRequestOptions;
     return requestOptions;
   }
 }
@@ -125,10 +281,10 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
     return this.client;
   }
   protected _getClientOptions(
-    options: t.OpenAICoreRequestOptions | undefined
-  ): t.OpenAICoreRequestOptions {
-    if (!(this.client as AzureOpenAIClient | undefined)) {
-      const openAIEndpointConfig: t.OpenAIEndpointConfig = {
+    options: OpenAICoreRequestOptions | undefined
+  ): OpenAICoreRequestOptions {
+    if (!(this.client as unknown as AzureOpenAIClient | undefined)) {
+      const openAIEndpointConfig: OpenAIEndpointConfig = {
         azureOpenAIApiDeploymentName: this.azureOpenAIApiDeploymentName,
         azureOpenAIApiInstanceName: this.azureOpenAIApiInstanceName,
         azureOpenAIApiKey: this.azureOpenAIApiKey,
@@ -154,25 +310,26 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
         delete params.baseURL;
       }
 
+      const defaultHeaders = normalizeHeaders(params.defaultHeaders);
       params.defaultHeaders = {
         ...params.defaultHeaders,
         'User-Agent':
-          params.defaultHeaders?.['User-Agent'] != null
-            ? `${params.defaultHeaders['User-Agent']}: langchainjs-azure-openai-v2`
+          defaultHeaders['User-Agent'] != null
+            ? `${defaultHeaders['User-Agent']}: langchainjs-azure-openai-v2`
             : 'langchainjs-azure-openai-v2',
       };
 
       this.client = new CustomAzureOpenAIClient({
         apiVersion: this.azureOpenAIApiVersion,
         azureADTokenProvider: this.azureADTokenProvider,
-        ...params,
-      });
+        ...(params as t.AzureOpenAIInput),
+      }) as unknown as CustomOpenAIClient;
     }
 
     const requestOptions = {
       ...this.clientConfig,
       ...options,
-    } as t.OpenAICoreRequestOptions;
+    } as OpenAICoreRequestOptions;
     if (this.azureOpenAIApiKey != null) {
       requestOptions.headers = {
         'api-key': this.azureOpenAIApiKey,
@@ -186,7 +343,6 @@ export class AzureChatOpenAI extends OriginalAzureChatOpenAI {
     return requestOptions;
   }
 }
-
 export class ChatDeepSeek extends OriginalChatDeepSeek {
   public get exposedClient(): CustomOpenAIClient {
     return this.client;

package/src/scripts/simple.ts

@@ -99,7 +99,7 @@ async function testStandardStreaming(): Promise<void> {
     const openAIConfig = llmConfig as t.OpenAIClientOptions;
     if (openAIConfig.configuration) {
       openAIConfig.configuration.fetch = (
-        url: RequestInfo,
+        url: string | URL | Request,
         init?: RequestInit
       ) => {
         console.log('Fetching:', url);