@librechat/agents 3.0.79 → 3.0.81

package/src/llm/bedrock/index.ts

@@ -21,17 +21,6 @@ import { ChatGenerationChunk, ChatResult } from '@langchain/core/outputs';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 import type { ChatBedrockConverseInput } from '@langchain/aws';
 import type { BaseMessage } from '@langchain/core/messages';
-import {
-  ConverseCommand,
-  ConverseStreamCommand,
-} from '@aws-sdk/client-bedrock-runtime';
-import {
-  convertToConverseMessages,
-  convertConverseMessageToLangChainMessage,
-  handleConverseStreamContentBlockStart,
-  handleConverseStreamContentBlockDelta,
-  handleConverseStreamMetadata,
-} from './utils';
 
 /**
  * Service tier type for Bedrock invocations.
@@ -119,7 +108,7 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
   } {
     const baseParams = super.invocationParams(options);
 
-    // Get serviceTier from options or fall back to class-level setting
+    /** Service tier from options or fall back to class-level setting */
     const serviceTierType = options?.serviceTier ?? this.serviceTier;
 
     return {
@@ -130,110 +119,67 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
 
   /**
    * Override _generateNonStreaming to use applicationInferenceProfile as modelId.
+   * Uses the same model-swapping pattern as streaming for consistency.
    */
   override async _generateNonStreaming(
     messages: BaseMessage[],
     options: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions,
-    _runManager?: CallbackManagerForLLMRun
+    runManager?: CallbackManagerForLLMRun
   ): Promise<ChatResult> {
-    const { converseMessages, converseSystem } =
-      convertToConverseMessages(messages);
-    const params = this.invocationParams(options);
-
-    const command = new ConverseCommand({
-      modelId: this.getModelId(),
-      messages: converseMessages,
-      system: converseSystem,
-      requestMetadata: options.requestMetadata,
-      ...params,
-    });
-
-    const response = await this.client.send(command, {
-      abortSignal: options.signal,
-    });
-
-    const { output, ...responseMetadata } = response;
-    if (!output?.message) {
-      throw new Error('No message found in Bedrock response.');
+    // Temporarily swap model for applicationInferenceProfile support
+    const originalModel = this.model;
+    if (
+      this.applicationInferenceProfile != null &&
+      this.applicationInferenceProfile !== ''
+    ) {
+      this.model = this.applicationInferenceProfile;
     }
 
-    const message = convertConverseMessageToLangChainMessage(
-      output.message,
-      responseMetadata
-    );
-
-    return {
-      generations: [
-        {
-          text: typeof message.content === 'string' ? message.content : '',
-          message,
-        },
-      ],
-    };
+    try {
+      return await super._generateNonStreaming(messages, options, runManager);
+    } finally {
+      // Restore original model
+      this.model = originalModel;
+    }
   }
 
   /**
    * Override _streamResponseChunks to:
-   * 1. Use applicationInferenceProfile as modelId
-   * 2. Include serviceTier in request
-   * 3. Strip contentBlockIndex from response_metadata to prevent merge conflicts
+   * 1. Use applicationInferenceProfile as modelId (by temporarily swapping this.model)
+   * 2. Strip contentBlockIndex from response_metadata to prevent merge conflicts
+   *
+   * Note: We delegate to super._streamResponseChunks() to preserve @langchain/aws's
+   * internal chunk handling which correctly preserves array content for reasoning blocks.
    */
   override async *_streamResponseChunks(
     messages: BaseMessage[],
     options: this['ParsedCallOptions'] & CustomChatBedrockConverseCallOptions,
     runManager?: CallbackManagerForLLMRun
   ): AsyncGenerator<ChatGenerationChunk> {
-    const { converseMessages, converseSystem } =
-      convertToConverseMessages(messages);
-    const params = this.invocationParams(options);
-
-    let { streamUsage } = this;
-    if (options.streamUsage !== undefined) {
-      streamUsage = options.streamUsage;
+    // Temporarily swap model for applicationInferenceProfile support
+    const originalModel = this.model;
+    if (
+      this.applicationInferenceProfile != null &&
+      this.applicationInferenceProfile !== ''
+    ) {
+      this.model = this.applicationInferenceProfile;
     }
 
-    const command = new ConverseStreamCommand({
-      modelId: this.getModelId(),
-      messages: converseMessages,
-      system: converseSystem,
-      requestMetadata: options.requestMetadata,
-      ...params,
-    });
-
-    const response = await this.client.send(command, {
-      abortSignal: options.signal,
-    });
-
-    if (response.stream) {
-      for await (const event of response.stream) {
-        if (event.contentBlockStart != null) {
-          const chunk = handleConverseStreamContentBlockStart(
-            event.contentBlockStart
-          ) as ChatGenerationChunk | undefined;
-          if (chunk !== undefined) {
-            const cleanedChunk = this.cleanChunk(chunk);
-            yield cleanedChunk;
-            await runManager?.handleLLMNewToken(cleanedChunk.text || '');
-          }
-        } else if (event.contentBlockDelta != null) {
-          const chunk = handleConverseStreamContentBlockDelta(
-            event.contentBlockDelta
-          ) as ChatGenerationChunk | undefined;
-          if (chunk !== undefined) {
-            const cleanedChunk = this.cleanChunk(chunk);
-            yield cleanedChunk;
-            await runManager?.handleLLMNewToken(cleanedChunk.text || '');
-          }
-        } else if (event.metadata != null) {
-          const chunk = handleConverseStreamMetadata(event.metadata, {
-            streamUsage,
-          }) as ChatGenerationChunk | undefined;
-          if (chunk !== undefined) {
-            const cleanedChunk = this.cleanChunk(chunk);
-            yield cleanedChunk;
-          }
-        }
+    try {
+      // Use parent's streaming logic which correctly handles reasoning content
+      const baseStream = super._streamResponseChunks(
+        messages,
+        options,
+        runManager
+      );
+
+      for await (const chunk of baseStream) {
+        // Clean contentBlockIndex from response_metadata to prevent merge conflicts
+        yield this.cleanChunk(chunk);
       }
+    } finally {
+      // Restore original model
+      this.model = originalModel;
     }
   }
 

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

@@ -38,13 +38,13 @@ export function bedrockReasoningDeltaToLangchainPartialReasoningBlock(
       reasoningText: { text },
     };
   }
-  if (signature) {
+  if (signature != null) {
     return {
       type: 'reasoning_content',
       reasoningText: { signature },
     };
   }
-  if (redactedContent) {
+  if (redactedContent != null) {
     return {
       type: 'reasoning_content',
       redactedContent: Buffer.from(redactedContent).toString('base64'),
@@ -65,13 +65,13 @@ export function bedrockReasoningBlockToLangchainReasoningBlock(
       redactedContent?: Uint8Array;
     };
 
-  if (reasoningText) {
+  if (reasoningText != null) {
     return {
       type: 'reasoning_content',
       reasoningText: reasoningText,
     };
   }
-  if (redactedContent) {
+  if (redactedContent != null) {
     return {
       type: 'reasoning_content',
       redactedContent: Buffer.from(redactedContent).toString('base64'),
@@ -87,7 +87,7 @@ export function convertConverseMessageToLangChainMessage(
   message: BedrockMessage,
   responseMetadata: Omit<ConverseResponse, 'output'>
 ): AIMessage {
-  if (!message.content) {
+  if (message.content == null) {
     throw new Error('No message content found in response.');
   }
   if (message.role !== 'assistant') {
@@ -99,7 +99,7 @@ export function convertConverseMessageToLangChainMessage(
   let requestId: string | undefined;
   if (
     '$metadata' in responseMetadata &&
-    responseMetadata.$metadata &&
+    responseMetadata.$metadata != null &&
     typeof responseMetadata.$metadata === 'object' &&
     'requestId' in responseMetadata.$metadata
   ) {
@@ -109,7 +109,7 @@ export function convertConverseMessageToLangChainMessage(
   let tokenUsage:
     | { input_tokens: number; output_tokens: number; total_tokens: number }
     | undefined;
-  if (responseMetadata.usage) {
+  if (responseMetadata.usage != null) {
     const input_tokens = responseMetadata.usage.inputTokens ?? 0;
     const output_tokens = responseMetadata.usage.outputTokens ?? 0;
     tokenUsage = {
@@ -144,9 +144,10 @@ export function convertConverseMessageToLangChainMessage(
     message.content.forEach((c) => {
       if (
         'toolUse' in c &&
-        c.toolUse &&
-        c.toolUse.name &&
-        c.toolUse.input &&
+        c.toolUse != null &&
+        c.toolUse.name != null &&
+        c.toolUse.name !== '' &&
+        c.toolUse.input != null &&
         typeof c.toolUse.input === 'object'
       ) {
         toolCalls.push({
@@ -157,7 +158,7 @@ export function convertConverseMessageToLangChainMessage(
         });
       } else if ('text' in c && typeof c.text === 'string') {
         content.push({ type: 'text', text: c.text });
-      } else if ('reasoningContent' in c && c.reasoningContent) {
+      } else if ('reasoningContent' in c && c.reasoningContent != null) {
         content.push(
           bedrockReasoningBlockToLangchainReasoningBlock(c.reasoningContent)
         );
@@ -182,7 +183,7 @@ export function convertConverseMessageToLangChainMessage(
 export function handleConverseStreamContentBlockDelta(
   contentBlockDelta: ContentBlockDeltaEvent
 ): ChatGenerationChunk {
-  if (!contentBlockDelta.delta) {
+  if (contentBlockDelta.delta == null) {
     throw new Error('No delta found in content block.');
   }
 
@@ -196,7 +197,7 @@ export function handleConverseStreamContentBlockDelta(
         },
       }),
     });
-  } else if (contentBlockDelta.delta.toolUse) {
+  } else if (contentBlockDelta.delta.toolUse != null) {
     const index = contentBlockDelta.contentBlockIndex;
     return new ChatGenerationChunk({
       text: '',
@@ -214,15 +215,28 @@ export function handleConverseStreamContentBlockDelta(
         },
       }),
     });
-  } else if (contentBlockDelta.delta.reasoningContent) {
+  } else if (contentBlockDelta.delta.reasoningContent != null) {
+    const reasoningBlock =
+      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
+            : ''))
+        : '';
     return new ChatGenerationChunk({
       text: '',
       message: new AIMessageChunk({
-        content: [
-          bedrockReasoningDeltaToLangchainPartialReasoningBlock(
-            contentBlockDelta.delta.reasoningContent
-          ),
-        ],
+        content: [reasoningBlock],
+        additional_kwargs: {
+          // Set reasoning_content for stream handler to detect reasoning mode
+          reasoning_content: reasoningText,
+        },
         response_metadata: {
           contentBlockIndex: contentBlockDelta.contentBlockIndex,
         },
@@ -243,7 +257,7 @@ export function handleConverseStreamContentBlockStart(
 ): ChatGenerationChunk | null {
   const index = contentBlockStart.contentBlockIndex;
 
-  if (contentBlockStart.start?.toolUse) {
+  if (contentBlockStart.start?.toolUse != null) {
     return new ChatGenerationChunk({
       text: '',
       message: new AIMessageChunk({

package/src/messages/cache.test.ts

@@ -835,6 +835,221 @@ describe('Multi-agent provider interoperability', () => {
   });
 });
 
+describe('Immutability - addCacheControl does not mutate original messages', () => {
+  it('should not mutate original messages when adding cache control to string content', () => {
+    const originalMessages: TestMsg[] = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+      { role: 'user', content: 'How are you?' },
+    ];
+
+    const originalFirstContent = originalMessages[0].content;
+    const originalThirdContent = originalMessages[2].content;
+
+    const result = addCacheControl(originalMessages as never);
+
+    expect(originalMessages[0].content).toBe(originalFirstContent);
+    expect(originalMessages[2].content).toBe(originalThirdContent);
+    expect(typeof originalMessages[0].content).toBe('string');
+    expect(typeof originalMessages[2].content).toBe('string');
+
+    expect(Array.isArray(result[0].content)).toBe(true);
+    expect(Array.isArray(result[2].content)).toBe(true);
+  });
+
+  it('should not mutate original messages when adding cache control to array content', () => {
+    const originalMessages: TestMsg[] = [
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
+      },
+      { role: 'assistant', content: 'Hi there' },
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'How are you?' }],
+      },
+    ];
+
+    const originalFirstBlock = {
+      ...(originalMessages[0].content as MessageContentComplex[])[0],
+    };
+    const originalThirdBlock = {
+      ...(originalMessages[2].content as MessageContentComplex[])[0],
+    };
+
+    const result = addCacheControl(originalMessages as never);
+
+    const firstContent = originalMessages[0].content as MessageContentComplex[];
+    const thirdContent = originalMessages[2].content as MessageContentComplex[];
+
+    expect('cache_control' in firstContent[0]).toBe(false);
+    expect('cache_control' in thirdContent[0]).toBe(false);
+    expect(firstContent[0]).toEqual(originalFirstBlock);
+    expect(thirdContent[0]).toEqual(originalThirdBlock);
+
+    const resultFirstContent = result[0].content as MessageContentComplex[];
+    const resultThirdContent = result[2].content as MessageContentComplex[];
+    expect('cache_control' in resultFirstContent[0]).toBe(true);
+    expect('cache_control' in resultThirdContent[0]).toBe(true);
+  });
+
+  it('should not mutate original messages when stripping existing cache control', () => {
+    const originalMessages: TestMsg[] = [
+      {
+        role: 'user',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            text: 'Hello',
+            cache_control: { type: 'ephemeral' },
+          } as MessageContentComplex,
+        ],
+      },
+      { role: 'assistant', content: 'Hi there' },
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'How are you?' }],
+      },
+    ];
+
+    const originalFirstBlock = (
+      originalMessages[0].content as MessageContentComplex[]
+    )[0];
+
+    addCacheControl(originalMessages as never);
+
+    expect('cache_control' in originalFirstBlock).toBe(true);
+  });
+});
+
+describe('Immutability - addBedrockCacheControl does not mutate original messages', () => {
+  it('should not mutate original messages when adding cache points to string content', () => {
+    const originalMessages: TestMsg[] = [
+      { role: 'user', content: 'Hello' },
+      { role: 'assistant', content: 'Hi there' },
+    ];
+
+    const originalFirstContent = originalMessages[0].content;
+    const originalSecondContent = originalMessages[1].content;
+
+    const result = addBedrockCacheControl(originalMessages);
+
+    expect(originalMessages[0].content).toBe(originalFirstContent);
+    expect(originalMessages[1].content).toBe(originalSecondContent);
+    expect(typeof originalMessages[0].content).toBe('string');
+    expect(typeof originalMessages[1].content).toBe('string');
+
+    expect(Array.isArray(result[0].content)).toBe(true);
+    expect(Array.isArray(result[1].content)).toBe(true);
+  });
+
+  it('should not mutate original messages when adding cache points to array content', () => {
+    const originalMessages: TestMsg[] = [
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'Hello' }],
+      },
+      {
+        role: 'assistant',
+        content: [{ type: ContentTypes.TEXT, text: 'Hi there' }],
+      },
+    ];
+
+    const originalFirstContentLength = (
+      originalMessages[0].content as MessageContentComplex[]
+    ).length;
+    const originalSecondContentLength = (
+      originalMessages[1].content as MessageContentComplex[]
+    ).length;
+
+    const result = addBedrockCacheControl(originalMessages);
+
+    const firstContent = originalMessages[0].content as MessageContentComplex[];
+    const secondContent = originalMessages[1]
+      .content as MessageContentComplex[];
+
+    expect(firstContent.length).toBe(originalFirstContentLength);
+    expect(secondContent.length).toBe(originalSecondContentLength);
+    expect(firstContent.some((b) => 'cachePoint' in b)).toBe(false);
+    expect(secondContent.some((b) => 'cachePoint' in b)).toBe(false);
+
+    const resultFirstContent = result[0].content as MessageContentComplex[];
+    const resultSecondContent = result[1].content as MessageContentComplex[];
+    expect(resultFirstContent.length).toBe(originalFirstContentLength + 1);
+    expect(resultSecondContent.length).toBe(originalSecondContentLength + 1);
+    expect(resultFirstContent.some((b) => 'cachePoint' in b)).toBe(true);
+    expect(resultSecondContent.some((b) => 'cachePoint' in b)).toBe(true);
+  });
+
+  it('should not mutate original messages when stripping existing cache control', () => {
+    const originalMessages: TestMsg[] = [
+      {
+        role: 'user',
+        content: [
+          {
+            type: ContentTypes.TEXT,
+            text: 'Hello',
+            cache_control: { type: 'ephemeral' },
+          } as MessageContentComplex,
+        ],
+      },
+      {
+        role: 'assistant',
+        content: [
+          { type: ContentTypes.TEXT, text: 'Hi there' },
+          { cachePoint: { type: 'default' } },
+        ],
+      },
+    ];
+
+    const originalFirstBlock = (
+      originalMessages[0].content as MessageContentComplex[]
+    )[0];
+    const originalSecondContentLength = (
+      originalMessages[1].content as MessageContentComplex[]
+    ).length;
+
+    addBedrockCacheControl(originalMessages);
+
+    expect('cache_control' in originalFirstBlock).toBe(true);
+    expect(
+      (originalMessages[1].content as MessageContentComplex[]).length
+    ).toBe(originalSecondContentLength);
+  });
+
+  it('should allow different providers to process same messages without cross-contamination', () => {
+    const sharedMessages: TestMsg[] = [
+      {
+        role: 'user',
+        content: [{ type: ContentTypes.TEXT, text: 'Shared message 1' }],
+      },
+      {
+        role: 'assistant',
+        content: [{ type: ContentTypes.TEXT, text: 'Shared response 1' }],
+      },
+    ];
+
+    const bedrockResult = addBedrockCacheControl(sharedMessages);
+
+    const anthropicResult = addCacheControl(sharedMessages as never);
+
+    const originalFirstContent = sharedMessages[0]
+      .content as MessageContentComplex[];
+    expect(originalFirstContent.some((b) => 'cachePoint' in b)).toBe(false);
+    expect('cache_control' in originalFirstContent[0]).toBe(false);
+
+    const bedrockFirstContent = bedrockResult[0]
+      .content as MessageContentComplex[];
+    expect(bedrockFirstContent.some((b) => 'cachePoint' in b)).toBe(true);
+    expect('cache_control' in bedrockFirstContent[0]).toBe(false);
+
+    const anthropicFirstContent = anthropicResult[0]
+      .content as MessageContentComplex[];
+    expect(anthropicFirstContent.some((b) => 'cachePoint' in b)).toBe(false);
+    expect('cache_control' in anthropicFirstContent[0]).toBe(true);
+  });
+});
+
 describe('Multi-turn cache cleanup', () => {
   it('strips stale Bedrock cache points from previous turns before applying new ones', () => {
     const messages: TestMsg[] = [