@librechat/agents 3.1.34 → 3.1.36

package/src/llm/bedrock/llm.spec.ts

@@ -212,47 +212,6 @@ describe('CustomChatBedrockConverse', () => {
       return model as any;
     }
 
-    test('should detect contentBlockIndex at top level', () => {
-      const model = getModelWithCleanMethods();
-      const objWithIndex = { contentBlockIndex: 0, text: 'hello' };
-      const objWithoutIndex = { text: 'hello' };
-
-      expect(model.hasContentBlockIndex(objWithIndex)).toBe(true);
-      expect(model.hasContentBlockIndex(objWithoutIndex)).toBe(false);
-    });
-
-    test('should detect contentBlockIndex in nested objects', () => {
-      const model = getModelWithCleanMethods();
-      const nestedWithIndex = {
-        outer: {
-          inner: {
-            contentBlockIndex: 1,
-            data: 'test',
-          },
-        },
-      };
-      const nestedWithoutIndex = {
-        outer: {
-          inner: {
-            data: 'test',
-          },
-        },
-      };
-
-      expect(model.hasContentBlockIndex(nestedWithIndex)).toBe(true);
-      expect(model.hasContentBlockIndex(nestedWithoutIndex)).toBe(false);
-    });
-
-    test('should return false for null, undefined, and primitives', () => {
-      const model = getModelWithCleanMethods();
-
-      expect(model.hasContentBlockIndex(null)).toBe(false);
-      expect(model.hasContentBlockIndex(undefined)).toBe(false);
-      expect(model.hasContentBlockIndex('string')).toBe(false);
-      expect(model.hasContentBlockIndex(123)).toBe(false);
-      expect(model.hasContentBlockIndex(true)).toBe(false);
-    });
-
     test('should remove contentBlockIndex from top level', () => {
       const model = getModelWithCleanMethods();
       const obj = {
@@ -315,7 +274,7 @@ describe('CustomChatBedrockConverse', () => {
       expect(model.removeContentBlockIndex(undefined)).toBeUndefined();
     });
 
-    test('cleanChunk should remove contentBlockIndex from AIMessageChunk response_metadata', () => {
+    test('enrichChunk should strip contentBlockIndex from response_metadata', () => {
       const model = getModelWithCleanMethods();
 
       const chunkWithIndex = new ChatGenerationChunk({
@@ -329,18 +288,18 @@ describe('CustomChatBedrockConverse', () => {
         }),
       });
 
-      const cleaned = model.cleanChunk(chunkWithIndex);
+      const enriched = model.enrichChunk(chunkWithIndex, new Set([0]));
 
-      expect(cleaned.message.response_metadata).toEqual({
+      expect(enriched.message.response_metadata).toEqual({
         stopReason: null,
       });
       expect(
-        (cleaned.message.response_metadata as any).contentBlockIndex
+        (enriched.message.response_metadata as any).contentBlockIndex
       ).toBeUndefined();
-      expect(cleaned.text).toBe('Hello');
+      expect(enriched.text).toBe('Hello');
     });
 
-    test('cleanChunk should pass through chunks without contentBlockIndex unchanged', () => {
+    test('enrichChunk should pass through chunks without contentBlockIndex unchanged', () => {
       const model = getModelWithCleanMethods();
 
       const chunkWithoutIndex = new ChatGenerationChunk({
@@ -354,15 +313,89 @@ describe('CustomChatBedrockConverse', () => {
         }),
       });
 
-      const cleaned = model.cleanChunk(chunkWithoutIndex);
+      const enriched = model.enrichChunk(chunkWithoutIndex, new Set());
 
-      expect(cleaned.message.response_metadata).toEqual({
+      expect(enriched.message.response_metadata).toEqual({
         stopReason: 'end_turn',
         usage: { inputTokens: 10, outputTokens: 5 },
       });
     });
 
-    test('cleanChunk should handle deeply nested contentBlockIndex in response_metadata', () => {
+    test('enrichChunk should inject index on array content blocks', () => {
+      const model = getModelWithCleanMethods();
+
+      const chunkWithArrayContent = new ChatGenerationChunk({
+        text: '',
+        message: new AIMessageChunk({
+          content: [
+            {
+              type: 'reasoning_content',
+              reasoningText: { text: 'thinking...' },
+            },
+          ],
+          response_metadata: {
+            contentBlockIndex: 0,
+          },
+        }),
+      });
+
+      const enriched = model.enrichChunk(chunkWithArrayContent, new Set([0]));
+
+      expect(Array.isArray(enriched.message.content)).toBe(true);
+      const blocks = enriched.message.content as any[];
+      expect(blocks[0].index).toBe(0);
+      expect(blocks[0].type).toBe('reasoning_content');
+      expect(
+        (enriched.message.response_metadata as any).contentBlockIndex
+      ).toBeUndefined();
+    });
+
+    test('enrichChunk should promote text to array when multiple block indices seen', () => {
+      const model = getModelWithCleanMethods();
+
+      const textChunk = new ChatGenerationChunk({
+        text: 'Hello world',
+        message: new AIMessageChunk({
+          content: 'Hello world',
+          response_metadata: {
+            contentBlockIndex: 1,
+          },
+        }),
+      });
+
+      const enriched = model.enrichChunk(textChunk, new Set([0, 1]));
+
+      expect(Array.isArray(enriched.message.content)).toBe(true);
+      const blocks = enriched.message.content as any[];
+      expect(blocks).toHaveLength(1);
+      expect(blocks[0]).toEqual({
+        type: 'text',
+        text: 'Hello world',
+        index: 1,
+      });
+    });
+
+    test('enrichChunk should keep text as string when only one block index seen', () => {
+      const model = getModelWithCleanMethods();
+
+      const textChunk = new ChatGenerationChunk({
+        text: 'Hello',
+        message: new AIMessageChunk({
+          content: 'Hello',
+          response_metadata: {
+            contentBlockIndex: 0,
+            stopReason: null,
+          },
+        }),
+      });
+
+      const enriched = model.enrichChunk(textChunk, new Set([0]));
+
+      expect(typeof enriched.message.content).toBe('string');
+      expect(enriched.message.content).toBe('Hello');
+    });
+
+    test('enrichChunk should strip deeply nested contentBlockIndex from response_metadata', () => {
       const model = getModelWithCleanMethods();
 
       const chunkWithNestedIndex = new ChatGenerationChunk({
@@ -370,6 +403,7 @@ describe('CustomChatBedrockConverse', () => {
         message: new AIMessageChunk({
           content: 'Test',
           response_metadata: {
+            contentBlockIndex: 0,
             amazon: {
               bedrock: {
                 contentBlockIndex: 0,
@@ -381,9 +415,9 @@ describe('CustomChatBedrockConverse', () => {
         }),
       });
 
-      const cleaned = model.cleanChunk(chunkWithNestedIndex);
+      const enriched = model.enrichChunk(chunkWithNestedIndex, new Set([0]));
 
-      expect(cleaned.message.response_metadata).toEqual({
+      expect(enriched.message.response_metadata).toEqual({
         amazon: {
           bedrock: {
             trace: { something: 'value' },

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

@@ -220,15 +220,12 @@ export function handleConverseStreamContentBlockDelta(
       bedrockReasoningDeltaToLangchainPartialReasoningBlock(
         contentBlockDelta.delta.reasoningContent
       );
-    // Extract the text for additional_kwargs.reasoning_content (for stream handler compatibility)
-    const reasoningText =
-      'reasoningText' in reasoningBlock
-        ? (reasoningBlock.reasoningText.text ??
-          reasoningBlock.reasoningText.signature ??
-          ('redactedContent' in reasoningBlock
-            ? reasoningBlock.redactedContent
-            : ''))
-        : '';
+    let reasoningText = '';
+    if ('reasoningText' in reasoningBlock) {
+      reasoningText = reasoningBlock.reasoningText.text ?? '';
+    } else if ('redactedContent' in reasoningBlock) {
+      reasoningText = reasoningBlock.redactedContent;
+    }
     return new ChatGenerationChunk({
       text: '',
       message: new AIMessageChunk({

package/src/messages/core.ts

@@ -159,6 +159,11 @@ export function modifyDeltaProperties(
     (obj as Partial<AIMessageChunk>).lc_kwargs &&
     Array.isArray(obj.lc_kwargs.content)
   ) {
+    if (provider === Providers.BEDROCK) {
+      obj.lc_kwargs.content = reduceBlocks(
+        obj.lc_kwargs.content as ContentBlock[]
+      );
+    }
     obj.lc_kwargs.content = modifyContent({
       provider,
       messageType,

package/src/scripts/bedrock-merge-test.ts

@@ -0,0 +1,107 @@
+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 { CustomChatBedrockConverse } from '@/llm/bedrock';
+import { modifyDeltaProperties } from '@/messages/core';
+import { Providers } from '@/common';
+
+async function testBedrockMerge(): Promise<void> {
+  const model = new CustomChatBedrockConverse({
+    model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    region: process.env.BEDROCK_AWS_REGION,
+    credentials: {
+      accessKeyId: process.env.BEDROCK_AWS_ACCESS_KEY_ID!,
+      secretAccessKey: process.env.BEDROCK_AWS_SECRET_ACCESS_KEY!,
+    },
+    maxTokens: 4000,
+    streaming: true,
+    streamUsage: true,
+    additionalModelRequestFields: {
+      thinking: { type: 'enabled', budget_tokens: 2000 },
+    },
+  });
+
+  const messages = [new HumanMessage('What is 25 * 37? Think step by step.')];
+
+  console.log('Streaming from Bedrock with thinking enabled...\n');
+
+  const stream = await model.stream(messages);
+  let finalChunk: AIMessageChunk | undefined;
+  let chunkCount = 0;
+  let firstTextLogged = false;
+
+  for await (const chunk of stream) {
+    chunkCount++;
+    const isArr = Array.isArray(chunk.content);
+    const isStr = typeof chunk.content === 'string';
+    const isTextStr = isStr && (chunk.content as string).length > 0;
+
+    if (!firstTextLogged && isTextStr) {
+      console.log(
+        `chunk ${chunkCount} (first text): contentType=string, value="${chunk.content}"`
+      );
+      console.log(
+        '  response_metadata:',
+        JSON.stringify(chunk.response_metadata)
+      );
+      firstTextLogged = true;
+    }
+
+    if (isArr) {
+      const blocks = chunk.content as Array<Record<string, unknown>>;
+      const info = blocks.map((b) => ({
+        type: b.type,
+        hasIndex: 'index' in b,
+        index: b.index,
+      }));
+      console.log(`chunk ${chunkCount}: array content, blocks:`, info);
+    }
+
+    finalChunk = finalChunk ? concat(finalChunk, chunk) : chunk;
+  }
+
+  console.log(`Total chunks received: ${chunkCount}\n`);
+
+  console.log('=== RAW concat result (before modifyDeltaProperties) ===');
+  console.log('content type:', typeof finalChunk!.content);
+  if (Array.isArray(finalChunk!.content)) {
+    console.log('content array length:', finalChunk!.content.length);
+    const types = finalChunk!.content.map((b) =>
+      typeof b === 'object' && 'type' in b ? b.type : typeof b
+    );
+    const typeCounts = types.reduce(
+      (acc, t) => {
+        acc[t ?? ''] = (acc[t ?? ''] || 0) + 1;
+        return acc;
+      },
+      {} as Record<string, number>
+    );
+    console.log('content block type counts:', typeCounts);
+  }
+
+  console.log('\ncontent:');
+  console.dir(finalChunk!.content, { depth: null });
+
+  console.log('\n=== lc_kwargs.content ===');
+  if (Array.isArray(finalChunk!.lc_kwargs.content)) {
+    console.log(
+      'lc_kwargs.content length:',
+      finalChunk!.lc_kwargs.content.length
+    );
+  }
+  console.dir(finalChunk!.lc_kwargs.content, { depth: null });
+
+  const modified = modifyDeltaProperties(Providers.BEDROCK, finalChunk);
+  console.log('\n=== After modifyDeltaProperties ===');
+  console.log('content:');
+  console.dir(modified!.content, { depth: null });
+  console.log('\nlc_kwargs.content:');
+  console.dir(modified!.lc_kwargs.content, { depth: null });
+}
+
+testBedrockMerge().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});