@librechat/agents 2.4.37 → 2.4.40

package/src/llm/google/index.ts

@@ -0,0 +1,97 @@
+import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
+import { getEnvironmentVariable } from '@langchain/core/utils/env';
+import { GoogleGenerativeAI as GenerativeAI } from '@google/generative-ai';
+import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
+import type { RequestOptions, SafetySetting } from '@google/generative-ai';
+
+export class CustomChatGoogleGenerativeAI extends ChatGoogleGenerativeAI {
+  constructor(
+    fields: GoogleGenerativeAIChatInput & {
+      customHeaders?: RequestOptions['customHeaders'];
+    }
+  ) {
+    super(fields);
+
+    this.model = fields.model.replace(/^models\//, '');
+
+    this.maxOutputTokens = fields.maxOutputTokens ?? this.maxOutputTokens;
+
+    if (this.maxOutputTokens != null && this.maxOutputTokens < 0) {
+      throw new Error('`maxOutputTokens` must be a positive integer');
+    }
+
+    this.temperature = fields.temperature ?? this.temperature;
+    if (
+      this.temperature != null &&
+      (this.temperature < 0 || this.temperature > 2)
+    ) {
+      throw new Error('`temperature` must be in the range of [0.0,2.0]');
+    }
+
+    this.topP = fields.topP ?? this.topP;
+    if (this.topP != null && this.topP < 0) {
+      throw new Error('`topP` must be a positive integer');
+    }
+
+    if (this.topP != null && this.topP > 1) {
+      throw new Error('`topP` must be below 1.');
+    }
+
+    this.topK = fields.topK ?? this.topK;
+    if (this.topK != null && this.topK < 0) {
+      throw new Error('`topK` must be a positive integer');
+    }
+
+    this.stopSequences = fields.stopSequences ?? this.stopSequences;
+
+    this.apiKey = fields.apiKey ?? getEnvironmentVariable('GOOGLE_API_KEY');
+    if (this.apiKey == null || this.apiKey === '') {
+      throw new Error(
+        'Please set an API key for Google GenerativeAI ' +
+          'in the environment variable GOOGLE_API_KEY ' +
+          'or in the `apiKey` field of the ' +
+          'ChatGoogleGenerativeAI constructor'
+      );
+    }
+
+    this.safetySettings = fields.safetySettings ?? this.safetySettings;
+    if (this.safetySettings && this.safetySettings.length > 0) {
+      const safetySettingsSet = new Set(
+        this.safetySettings.map((s) => s.category)
+      );
+      if (safetySettingsSet.size !== this.safetySettings.length) {
+        throw new Error(
+          'The categories in `safetySettings` array must be unique'
+        );
+      }
+    }
+
+    this.streaming = fields.streaming ?? this.streaming;
+    this.json = fields.json;
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-ignore - Accessing private property from parent class
+    this.client = new GenerativeAI(this.apiKey).getGenerativeModel(
+      {
+        model: this.model,
+        safetySettings: this.safetySettings as SafetySetting[],
+        generationConfig: {
+          stopSequences: this.stopSequences,
+          maxOutputTokens: this.maxOutputTokens,
+          temperature: this.temperature,
+          topP: this.topP,
+          topK: this.topK,
+          ...(this.json != null
+            ? { responseMimeType: 'application/json' }
+            : {}),
+        },
+      },
+      {
+        apiVersion: fields.apiVersion,
+        baseUrl: fields.baseUrl,
+        customHeaders: fields.customHeaders,
+      }
+    );
+    this.streamUsage = fields.streamUsage ?? this.streamUsage;
+  }
+}

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/llm/providers.ts

@@ -4,13 +4,13 @@ import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 // import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatVertexAI } from '@langchain/google-vertexai';
-import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type {
   ChatModelConstructorMap,
   ProviderOptionsMap,
   ChatModelMap,
 } from '@/types';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
 import { CustomAnthropic } from '@/llm/anthropic';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import {
@@ -35,7 +35,7 @@ export const llmProviders: Partial<ChatModelConstructorMap> = {
   [Providers.BEDROCK_LEGACY]: BedrockChat,
   [Providers.BEDROCK]: ChatBedrockConverse,
   // [Providers.ANTHROPIC]: ChatAnthropic,
-  [Providers.GOOGLE]: ChatGoogleGenerativeAI,
+  [Providers.GOOGLE]: CustomChatGoogleGenerativeAI,
 };
 
 export const manualToolStreamProviders = new Set<Providers | string>([

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);

package/src/types/llm.ts

@@ -4,7 +4,6 @@ import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatMistralAI } from '@langchain/mistralai';
 import { ChatBedrockConverse } from '@langchain/aws';
 import { ChatVertexAI } from '@langchain/google-vertexai';
-import { ChatGoogleGenerativeAI } from '@langchain/google-genai';
 import { BedrockChat } from '@langchain/community/chat_models/bedrock/web';
 import type {
   BindToolsInput,
@@ -23,6 +22,7 @@ import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { ChatMistralAIInput } from '@langchain/mistralai';
+import type { RequestOptions } from '@google/generative-ai';
 import type { StructuredTool } from '@langchain/core/tools';
 import type { AnthropicInput } from '@langchain/anthropic';
 import type { Runnable } from '@langchain/core/runnables';
@@ -35,6 +35,7 @@ import {
   ChatDeepSeek,
   AzureChatOpenAI,
 } from '@/llm/openai';
+import { CustomChatGoogleGenerativeAI } from '@/llm/google';
 import { ChatOpenRouter } from '@/llm/openrouter';
 import { Providers } from '@/common';
 
@@ -67,7 +68,9 @@ export type BedrockAnthropicInput = ChatBedrockConverseInput & {
     AnthropicReasoning;
 };
 export type BedrockConverseClientOptions = ChatBedrockConverseInput;
-export type GoogleClientOptions = GoogleGenerativeAIChatInput;
+export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
+  customHeaders?: RequestOptions['customHeaders'];
+};
 export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
 export type XAIClientOptions = ChatXAIInput;
 
@@ -117,7 +120,7 @@ export type ChatModelMap = {
   [Providers.OPENROUTER]: ChatOpenRouter;
   [Providers.BEDROCK_LEGACY]: BedrockChat;
   [Providers.BEDROCK]: ChatBedrockConverse;
-  [Providers.GOOGLE]: ChatGoogleGenerativeAI;
+  [Providers.GOOGLE]: CustomChatGoogleGenerativeAI;
 };
 
 export type ChatModelConstructorMap = {

package/src/utils/llmConfig.ts

@@ -100,7 +100,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
   } as t.VertexAIClientOptions & t.LLMConfig,
   [Providers.GOOGLE]: {
     provider: Providers.GOOGLE,
-    model: 'gemini-2.5-pro-exp-03-25',
+    model: 'gemini-2.5-flash-preview-04-17',
     streaming: true,
     streamUsage: true,
   },
@@ -108,6 +108,7 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
     provider: Providers.BEDROCK,
     // model: 'anthropic.claude-3-sonnet-20240229-v1:0',
     // model: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    // model: 'us.amazon.nova-pro-v1:0',
     model: 'us.anthropic.claude-sonnet-4-20250514-v1:0',
     // additionalModelRequestFields: { thinking: { type: 'enabled', budget_tokens: 2000 } },
     region: process.env.BEDROCK_AWS_REGION,