@librechat/agents 3.1.52 → 3.1.54

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/scripts/bedrock-cache-debug.ts

@@ -0,0 +1,250 @@
+/**
+ * Debug script to investigate cache token omission in Bedrock responses.
+ *
+ * This script:
+ * 1. Makes a streaming call to Bedrock and logs the raw metadata event
+ * 2. Shows exactly what fields the AWS SDK returns in usage (including cache tokens)
+ * 3. Shows what our handleConverseStreamMetadata produces vs what it should produce
+ * 4. Makes a multi-turn call to trigger caching and verify cache tokens appear
+ */
+import { config } from 'dotenv';
+config();
+import { HumanMessage } from '@langchain/core/messages';
+import type { AIMessageChunk } from '@langchain/core/messages';
+import { concat } from '@langchain/core/utils/stream';
+import {
+  ConverseStreamCommand,
+  BedrockRuntimeClient,
+} from '@aws-sdk/client-bedrock-runtime';
+import { CustomChatBedrockConverse } from '@/llm/bedrock';
+
+const region = process.env.BEDROCK_AWS_REGION ?? 'us-east-1';
+const credentials = {
+  accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+  secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+};
+
+const MODEL_ID = 'us.anthropic.claude-sonnet-4-5-20250929-v1:0';
+
+// A long system prompt to increase likelihood of cache usage
+// Bedrock requires minimum 1024 tokens for prompt caching to activate
+const SYSTEM_PROMPT = `You are an expert assistant. Here is a large context block to help trigger cache behavior:
+
+${Array(200).fill('This is padding content to make the prompt large enough to trigger Bedrock prompt caching. The minimum requirement for Anthropic models on Bedrock is 1024 tokens in the cached prefix. We need to ensure this prompt is well above that threshold. ').join('')}
+
+When answering, be brief and direct.`;
+
+async function rawSdkCall(): Promise<void> {
+  console.log('='.repeat(60));
+  console.log('TEST 1: Raw AWS SDK call - inspect metadata.usage directly');
+  console.log('='.repeat(60));
+
+  const client = new BedrockRuntimeClient({ region, credentials });
+
+  // First call - should create cache
+  // Use cachePoint block to explicitly enable prompt caching
+  console.log('\n--- Call 1 (cache write expected) ---');
+  const command1 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [{ role: 'user', content: [{ text: 'What is 2+2?' }] }],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response1 = await client.send(command1);
+  if (response1.stream) {
+    for await (const event of response1.stream) {
+      if (event.metadata != null) {
+        console.log('\nRAW metadata event (Call 1):');
+        console.dir(event.metadata, { depth: null });
+        console.log('\nRAW metadata.usage:');
+        console.dir(event.metadata.usage, { depth: null });
+        console.log('\nSpecific cache fields:');
+        console.log(
+          '  cacheReadInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheReadInputTokens
+        );
+        console.log(
+          '  cacheWriteInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheWriteInputTokens
+        );
+      }
+    }
+  }
+
+  // Second call - should read from cache
+  console.log('\n--- Call 2 (cache read expected) ---');
+  const command2 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [
+      { role: 'user', content: [{ text: 'What is 2+2?' }] },
+      { role: 'assistant', content: [{ text: '4' }] },
+      { role: 'user', content: [{ text: 'And what is 3+3?' }] },
+    ],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response2 = await client.send(command2);
+  if (response2.stream) {
+    for await (const event of response2.stream) {
+      if (event.metadata != null) {
+        console.log('\nRAW metadata event (Call 2):');
+        console.dir(event.metadata, { depth: null });
+        console.log('\nRAW metadata.usage:');
+        console.dir(event.metadata.usage, { depth: null });
+        console.log('\nSpecific cache fields:');
+        console.log(
+          '  cacheReadInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheReadInputTokens
+        );
+        console.log(
+          '  cacheWriteInputTokens:',
+          (event.metadata.usage as Record<string, unknown>)
+            ?.cacheWriteInputTokens
+        );
+      }
+    }
+  }
+}
+
+async function wrapperStreamCallNoCachePoint(): Promise<void> {
+  console.log('\n' + '='.repeat(60));
+  console.log(
+    'TEST 2: CustomChatBedrockConverse stream (NO cachePoint) - check usage_metadata'
+  );
+  console.log('='.repeat(60));
+  console.log('(Without cachePoint, Bedrock does NOT return cache tokens)');
+
+  const model = new CustomChatBedrockConverse({
+    model: MODEL_ID,
+    region,
+    credentials,
+    maxTokens: 100,
+    streaming: true,
+    streamUsage: true,
+  });
+
+  console.log('\n--- Wrapper Call (no cachePoint) ---');
+  const messages1 = [new HumanMessage(SYSTEM_PROMPT + '\n\nWhat is 2+2?')];
+  let finalChunk1: AIMessageChunk | undefined;
+
+  for await (const chunk of await model.stream(messages1)) {
+    finalChunk1 = finalChunk1 ? concat(finalChunk1, chunk) : chunk;
+  }
+
+  console.log(
+    '\nFinal usage_metadata:',
+    JSON.stringify(finalChunk1!.usage_metadata)
+  );
+  console.log('(No cache tokens expected since no cachePoint block was sent)');
+}
+
+async function wrapperStreamCallWithCachePoint(): Promise<void> {
+  console.log('\n' + '='.repeat(60));
+  console.log(
+    'TEST 3: Raw SDK with cachePoint -> verify handleConverseStreamMetadata extracts cache tokens'
+  );
+  console.log('='.repeat(60));
+
+  // We use the raw SDK with cachePoint to trigger caching, then verify
+  // that our handleConverseStreamMetadata function properly extracts cache fields
+  const { handleConverseStreamMetadata } = await import(
+    '@/llm/bedrock/utils/message_outputs'
+  );
+
+  const client = new BedrockRuntimeClient({ region, credentials });
+
+  // Call 1 - establish cache
+  console.log('\n--- Call 1 (cache write) ---');
+  const command1 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [{ role: 'user', content: [{ text: 'What is 2+2?' }] }],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response1 = await client.send(command1);
+  if (response1.stream) {
+    for await (const event of response1.stream) {
+      if (event.metadata != null) {
+        console.log('Raw usage:', JSON.stringify(event.metadata.usage));
+
+        // Test our handler
+        const chunk = handleConverseStreamMetadata(event.metadata, {
+          streamUsage: true,
+        });
+        console.log(
+          'handleConverseStreamMetadata output usage_metadata:',
+          JSON.stringify(chunk.message.usage_metadata)
+        );
+
+        const hasDetails =
+          chunk.message.usage_metadata?.input_token_details != null;
+        console.log(
+          `Has input_token_details: ${hasDetails}`,
+          hasDetails
+            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            : '(MISSING - BUG!)'
+        );
+      }
+    }
+  }
+
+  // Call 2 - read from cache
+  console.log('\n--- Call 2 (cache read) ---');
+  const command2 = new ConverseStreamCommand({
+    modelId: MODEL_ID,
+    system: [{ text: SYSTEM_PROMPT }, { cachePoint: { type: 'default' } }],
+    messages: [
+      { role: 'user', content: [{ text: 'What is 2+2?' }] },
+      { role: 'assistant', content: [{ text: '4' }] },
+      { role: 'user', content: [{ text: 'What is 3+3?' }] },
+    ],
+    inferenceConfig: { maxTokens: 100 },
+  });
+
+  const response2 = await client.send(command2);
+  if (response2.stream) {
+    for await (const event of response2.stream) {
+      if (event.metadata != null) {
+        console.log('Raw usage:', JSON.stringify(event.metadata.usage));
+
+        const chunk = handleConverseStreamMetadata(event.metadata, {
+          streamUsage: true,
+        });
+        console.log(
+          'handleConverseStreamMetadata output usage_metadata:',
+          JSON.stringify(chunk.message.usage_metadata)
+        );
+
+        const hasDetails =
+          chunk.message.usage_metadata?.input_token_details != null;
+        console.log(
+          `Has input_token_details: ${hasDetails}`,
+          hasDetails
+            ? JSON.stringify(chunk.message.usage_metadata!.input_token_details)
+            : '(MISSING - BUG!)'
+        );
+      }
+    }
+  }
+}
+
+async function main(): Promise<void> {
+  console.log('Bedrock Cache Token Debug Script');
+  console.log(`Model: ${MODEL_ID}`);
+  console.log(`Region: ${region}\n`);
+
+  await rawSdkCall();
+  await wrapperStreamCallNoCachePoint();
+  await wrapperStreamCallWithCachePoint();
+}
+
+main().catch((err) => {
+  console.error('Fatal error:', err);
+  process.exit(1);
+});