@librechat/agents 3.1.52 → 3.1.53

package/src/llm/openrouter/reasoning.test.ts

@@ -0,0 +1,207 @@
+import { ChatOpenRouter } from './index';
+import type { OpenRouterReasoning, ChatOpenRouterCallOptions } from './index';
+import type { OpenAIChatInput } from '@langchain/openai';
+
+type CreateRouterOptions = Partial<
+  ChatOpenRouterCallOptions & Pick<OpenAIChatInput, 'model' | 'apiKey'>
+>;
+
+function createRouter(overrides: CreateRouterOptions = {}): ChatOpenRouter {
+  return new ChatOpenRouter({
+    model: 'openrouter/test-model',
+    apiKey: 'test-key',
+    ...overrides,
+  });
+}
+
+describe('ChatOpenRouter reasoning handling', () => {
+  // ---------------------------------------------------------------
+  // 1. Constructor reasoning config
+  // ---------------------------------------------------------------
+  describe('constructor reasoning config', () => {
+    it('stores reasoning when passed directly', () => {
+      const router = createRouter({ reasoning: { effort: 'high' } });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high' });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 2. modelKwargs reasoning extraction
+  // ---------------------------------------------------------------
+  describe('modelKwargs reasoning extraction', () => {
+    it('extracts reasoning from modelKwargs and places it into params.reasoning', () => {
+      const router = createRouter({
+        modelKwargs: { reasoning: { effort: 'medium' } },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'medium' });
+    });
+
+    it('does not leak reasoning into modelKwargs that reach the parent', () => {
+      const router = createRouter({
+        modelKwargs: {
+          reasoning: { effort: 'medium' },
+        },
+      });
+      const params = router.invocationParams();
+      // reasoning should be the structured OpenRouter object, not buried in modelKwargs
+      expect(params.reasoning).toEqual({ effort: 'medium' });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 3. Reasoning merge precedence
+  // ---------------------------------------------------------------
+  describe('reasoning merge precedence', () => {
+    it('constructor reasoning overrides modelKwargs.reasoning', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high' },
+        modelKwargs: { reasoning: { effort: 'low' } },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high' });
+    });
+
+    it('merges non-overlapping keys from modelKwargs.reasoning and constructor reasoning', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high' },
+        modelKwargs: { reasoning: { max_tokens: 5000 } },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high', max_tokens: 5000 });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 4. invocationParams output
+  // ---------------------------------------------------------------
+  describe('invocationParams output', () => {
+    it('includes reasoning object in params', () => {
+      const router = createRouter({ reasoning: { effort: 'high' } });
+      const params = router.invocationParams();
+      expect(params.reasoning).toBeDefined();
+      expect(params.reasoning).toEqual({ effort: 'high' });
+    });
+
+    it('does NOT include reasoning_effort in params', () => {
+      const router = createRouter({ reasoning: { effort: 'high' } });
+      const params = router.invocationParams();
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+
+    it('does not include reasoning when none is configured', () => {
+      const router = createRouter();
+      const params = router.invocationParams();
+      expect(params.reasoning).toBeUndefined();
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 5. Legacy include_reasoning
+  // ---------------------------------------------------------------
+  describe('legacy include_reasoning', () => {
+    it('produces { enabled: true } when only include_reasoning is true', () => {
+      const router = createRouter({ include_reasoning: true });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ enabled: true });
+    });
+
+    it('does not produce reasoning when include_reasoning is false', () => {
+      const router = createRouter({ include_reasoning: false });
+      const params = router.invocationParams();
+      expect(params.reasoning).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 6. Legacy include_reasoning ignored when reasoning is provided
+  // ---------------------------------------------------------------
+  describe('legacy include_reasoning ignored when reasoning provided', () => {
+    it('reasoning wins over include_reasoning', () => {
+      const router = createRouter({
+        reasoning: { effort: 'medium' },
+        include_reasoning: true,
+      });
+      const params = router.invocationParams();
+      // Should use the structured reasoning, NOT fall back to { enabled: true }
+      expect(params.reasoning).toEqual({ effort: 'medium' });
+    });
+
+    it('reasoning from modelKwargs also wins over include_reasoning', () => {
+      const router = createRouter({
+        modelKwargs: { reasoning: { effort: 'low' } },
+        include_reasoning: true,
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'low' });
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 7. Various effort levels (OpenRouter-specific)
+  // ---------------------------------------------------------------
+  describe('various effort levels', () => {
+    const efforts: Array<{
+      effort: OpenRouterReasoning['effort'];
+    }> = [
+      { effort: 'xhigh' },
+      { effort: 'none' },
+      { effort: 'minimal' },
+      { effort: 'high' },
+      { effort: 'medium' },
+      { effort: 'low' },
+    ];
+
+    it.each(efforts)('supports effort level "$effort"', ({ effort }) => {
+      const router = createRouter({ reasoning: { effort } });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort });
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 8. max_tokens reasoning
+  // ---------------------------------------------------------------
+  describe('max_tokens reasoning', () => {
+    it('passes max_tokens in reasoning object', () => {
+      const router = createRouter({
+        reasoning: { max_tokens: 8000 },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ max_tokens: 8000 });
+    });
+
+    it('combines max_tokens with effort', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high', max_tokens: 8000 },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high', max_tokens: 8000 });
+      expect(params.reasoning_effort).toBeUndefined();
+    });
+  });
+
+  // ---------------------------------------------------------------
+  // 9. exclude reasoning
+  // ---------------------------------------------------------------
+  describe('exclude reasoning', () => {
+    it('passes exclude flag in reasoning object', () => {
+      const router = createRouter({
+        reasoning: { effort: 'high', exclude: true },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ effort: 'high', exclude: true });
+    });
+
+    it('supports exclude without effort', () => {
+      const router = createRouter({
+        reasoning: { exclude: true },
+      });
+      const params = router.invocationParams();
+      expect(params.reasoning).toEqual({ exclude: true });
+    });
+  });
+});

package/src/llm/vertexai/index.ts

@@ -6,9 +6,11 @@ import type {
   GoogleAbstractedClient,
 } from '@langchain/google-common';
 import type { BaseMessage } from '@langchain/core/messages';
-import type { VertexAIClientOptions } from '@/types';
+import type { GoogleThinkingConfig, VertexAIClientOptions } from '@/types';
 
 class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
+  thinkingConfig?: GoogleThinkingConfig;
+
   async formatData(
     input: BaseMessage[],
     parameters: GoogleAIModelRequestParams
@@ -26,6 +28,15 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
       }
       delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
     }
+    if (this.thinkingConfig?.thinkingLevel) {
+      formattedData.generationConfig ??= {};
+      (
+        formattedData.generationConfig as Record<string, unknown>
+      ).thinkingConfig = {
+        ...formattedData.generationConfig.thinkingConfig,
+        thinkingLevel: this.thinkingConfig.thinkingLevel,
+      };
+    }
     return formattedData;
   }
 }
@@ -315,6 +326,7 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
 export class ChatVertexAI extends ChatGoogle {
   lc_namespace = ['langchain', 'chat_models', 'vertexai'];
   dynamicThinkingBudget = false;
+  thinkingConfig?: GoogleThinkingConfig;
 
   static lc_name(): 'LibreChatVertexAI' {
     return 'LibreChatVertexAI';
@@ -327,6 +339,7 @@ export class ChatVertexAI extends ChatGoogle {
       platformType: 'gcp',
     });
     this.dynamicThinkingBudget = dynamicThinkingBudget;
+    this.thinkingConfig = fields?.thinkingConfig;
   }
   invocationParams(
     options?: this['ParsedCallOptions'] | undefined
@@ -342,18 +355,22 @@ export class ChatVertexAI extends ChatGoogle {
     fields: VertexAIClientOptions,
     client: GoogleAbstractedClient
   ): void {
-    this.connection = new CustomChatConnection(
+    const connection = new CustomChatConnection(
       { ...fields, ...this },
       this.caller,
       client,
       false
     );
+    connection.thinkingConfig = this.thinkingConfig;
+    this.connection = connection;
 
-    this.streamedConnection = new CustomChatConnection(
+    const streamedConnection = new CustomChatConnection(
       { ...fields, ...this },
       this.caller,
       client,
       true
     );
+    streamedConnection.thinkingConfig = this.thinkingConfig;
+    this.streamedConnection = streamedConnection;
   }
 }

package/src/specs/openrouter.simple.test.ts

@@ -7,6 +7,7 @@ import {
   UsageMetadata,
 } from '@langchain/core/messages';
 import type * as t from '@/types';
+import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
 import { ToolEndHandler, ModelEndHandler } from '@/events';
 import { ContentTypes, GraphEvents, Providers, TitleMethod } from '@/common';
 import { capitalizeFirstLetter } from './spec.utils';
@@ -33,6 +34,8 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     version: 'v2' as const,
   };
 
+  const baseLLMConfig = getLLMConfig(provider);
+
   beforeEach(async () => {
     conversationHistory = [];
     collectedUsage = [];
@@ -56,16 +59,81 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
   });
 
+  /**
+   * Helper: run a reasoning test against a specific model with the given reasoning config.
+   * Asserts that reasoning tokens are reported and content is produced.
+   */
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  async function runReasoningTest(opts: {
+    model: string;
+    reasoning?: ChatOpenRouterCallOptions['reasoning'];
+    threadId: string;
+    runId: string;
+  }) {
+    const { reasoning: _baseReasoning, ...baseWithoutReasoning } =
+      baseLLMConfig as unknown as Record<string, unknown>;
+    const llmConfig = {
+      ...baseWithoutReasoning,
+      model: opts.model,
+      ...(opts.reasoning != null ? { reasoning: opts.reasoning } : {}),
+    } as t.LLMConfig;
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: opts.runId,
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        instructions: 'You are a helpful AI assistant. Think step by step.',
+      },
+      returnContent: true,
+      skipCleanup: true,
+      customHandlers,
+    });
+
+    const userMessage = 'What is 15 * 37 + 128 / 4? Show your work.';
+    conversationHistory.push(new HumanMessage(userMessage));
+
+    const finalContentParts = await run.processStream(
+      { messages: conversationHistory },
+      { ...configV2, configurable: { thread_id: opts.threadId } }
+    );
+
+    expect(finalContentParts).toBeDefined();
+    expect(finalContentParts?.length).toBeGreaterThan(0);
+
+    // Verify usage metadata was collected
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    const usage = collectedUsage[0];
+    expect(usage.input_tokens).toBeGreaterThan(0);
+    expect(usage.output_tokens).toBeGreaterThan(0);
+
+    // Verify reasoning tokens are reported in output_token_details
+    const reasoningTokens =
+      (usage.output_token_details as Record<string, number> | undefined)
+        ?.reasoning ?? 0;
+    expect(reasoningTokens).toBeGreaterThan(0);
+
+    // Verify the final message has content
+    const finalMessages = run.getRunMessages();
+    expect(finalMessages).toBeDefined();
+    expect(finalMessages?.length).toBeGreaterThan(0);
+    const assistantMsg = finalMessages?.[0];
+    expect(typeof assistantMsg?.content).toBe('string');
+    expect((assistantMsg?.content as string).length).toBeGreaterThan(0);
+
+    return { usage, reasoningTokens, finalMessages };
+  }
+
   test(`${capitalizeFirstLetter(provider)}: simple stream + title`, async () => {
     const { userName, location } = await getArgs();
-    const llmConfig = getLLMConfig(provider);
     const customHandlers = setupCustomHandlers();
 
     run = await Run.create<t.IState>({
       runId: 'or-run-1',
       graphConfig: {
         type: 'standard',
-        llmConfig,
+        llmConfig: baseLLMConfig,
         tools: [new Calculator()],
         instructions: 'You are a friendly AI assistant.',
         additional_instructions: `The user's name is ${userName} and they are located in ${location}.`,
@@ -104,4 +172,97 @@ describeIf(`${capitalizeFirstLetter(provider)} Streaming Tests`, () => {
     });
     expect(titleRes.title).toBeDefined();
   });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic does NOT reason by default (no config)`, async () => {
+    const { reasoning: _baseReasoning, ...baseWithoutReasoning } =
+      baseLLMConfig as unknown as Record<string, unknown>;
+    const llmConfig = {
+      ...baseWithoutReasoning,
+      model: 'anthropic/claude-sonnet-4',
+    } as t.LLMConfig;
+    const customHandlers = setupCustomHandlers();
+
+    run = await Run.create<t.IState>({
+      runId: 'or-anthropic-default-1',
+      graphConfig: {
+        type: 'standard',
+        llmConfig,
+        instructions: 'You are a helpful AI assistant.',
+      },
+      returnContent: true,
+      skipCleanup: true,
+      customHandlers,
+    });
+
+    conversationHistory.push(
+      new HumanMessage('What is 15 * 37 + 128 / 4? Show your work.')
+    );
+
+    await run.processStream(
+      { messages: conversationHistory },
+      { ...configV2, configurable: { thread_id: 'or-anthropic-default-1' } }
+    );
+
+    expect(collectedUsage.length).toBeGreaterThan(0);
+    const usage = collectedUsage[0];
+    // Anthropic requires explicit reasoning config — no reasoning tokens by default
+    const reasoningTokens =
+      (usage.output_token_details as Record<string, number> | undefined)
+        ?.reasoning ?? 0;
+    expect(reasoningTokens).toBe(0);
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Gemini 3 reasons by default (no config)`, async () => {
+    await runReasoningTest({
+      model: 'google/gemini-3-pro-preview',
+      reasoning: undefined,
+      threadId: 'or-gemini-default-1',
+      runId: 'or-gemini-default-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Gemini reasoning with max_tokens`, async () => {
+    await runReasoningTest({
+      model: 'google/gemini-3-pro-preview',
+      reasoning: { max_tokens: 4000 },
+      threadId: 'or-gemini-reasoning-1',
+      runId: 'or-gemini-reasoning-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Gemini reasoning with effort`, async () => {
+    await runReasoningTest({
+      model: 'google/gemini-3-flash-preview',
+      reasoning: { effort: 'low' },
+      threadId: 'or-gemini-effort-1',
+      runId: 'or-gemini-effort-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic reasoning with max_tokens`, async () => {
+    await runReasoningTest({
+      model: 'anthropic/claude-sonnet-4',
+      reasoning: { max_tokens: 4000 },
+      threadId: 'or-anthropic-reasoning-1',
+      runId: 'or-anthropic-reasoning-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic sonnet-4 reasoning with effort`, async () => {
+    await runReasoningTest({
+      model: 'anthropic/claude-sonnet-4',
+      reasoning: { effort: 'medium' },
+      threadId: 'or-anthropic-effort-s4-1',
+      runId: 'or-anthropic-effort-s4-1',
+    });
+  });
+
+  test(`${capitalizeFirstLetter(provider)}: Anthropic sonnet-4-6 reasoning with effort`, async () => {
+    await runReasoningTest({
+      model: 'anthropic/claude-sonnet-4-6',
+      reasoning: { effort: 'medium' },
+      threadId: 'or-anthropic-effort-s46-1',
+      runId: 'or-anthropic-effort-s46-1',
+    });
+  });
 });

package/src/types/llm.ts

@@ -11,7 +11,6 @@ import type {
   ClientOptions as OAIClientOptions,
 } from '@langchain/openai';
 import type { GoogleGenerativeAIChatInput } from '@langchain/google-genai';
-import type { GeminiGenerationConfig } from '@langchain/google-common';
 import type { ChatVertexAIInput } from '@langchain/google-vertexai';
 import type { ChatDeepSeekCallOptions } from '@langchain/deepseek';
 import type { ChatOpenRouterCallOptions } from '@/llm/openrouter';
@@ -55,6 +54,11 @@ export type AnthropicReasoning = {
   thinking?: ThinkingConfig | boolean;
   thinkingBudget?: number;
 };
+export type GoogleThinkingConfig = {
+  thinkingBudget?: number;
+  includeThoughts?: boolean;
+  thinkingLevel?: string;
+};
 export type OpenAIClientOptions = ChatOpenAIFields;
 export type AnthropicClientOptions = AnthropicInput & {
   promptCache?: boolean;
@@ -62,6 +66,7 @@ export type AnthropicClientOptions = AnthropicInput & {
 export type MistralAIClientOptions = ChatMistralAIInput;
 export type VertexAIClientOptions = ChatVertexAIInput & {
   includeThoughts?: boolean;
+  thinkingConfig?: GoogleThinkingConfig;
 };
 export type BedrockAnthropicInput = ChatBedrockConverseInput & {
   additionalModelRequestFields?: ChatBedrockConverseInput['additionalModelRequestFields'] &
@@ -72,7 +77,7 @@ export type BedrockConverseClientOptions = ChatBedrockConverseInput;
 export type BedrockAnthropicClientOptions = BedrockAnthropicInput;
 export type GoogleClientOptions = GoogleGenerativeAIChatInput & {
   customHeaders?: RequestOptions['customHeaders'];
-  thinkingConfig?: GeminiGenerationConfig['thinkingConfig'];
+  thinkingConfig?: GoogleThinkingConfig;
 };
 export type DeepSeekClientOptions = ChatDeepSeekCallOptions;
 export type XAIClientOptions = ChatXAIInput;

package/src/utils/llmConfig.ts

@@ -67,11 +67,10 @@ export const llmConfigs: Record<string, t.LLMConfig | undefined> = {
         'X-Title': 'LibreChat',
       },
     },
-    include_reasoning: true,
+    reasoning: {
+      max_tokens: 8000,
+    },
     modelKwargs: {
-      reasoning: {
-        max_tokens: 8000,
-      },
       max_tokens: 10000,
     },
   } as or.ChatOpenRouterCallOptions & t.LLMConfig,