@librechat/agents 3.0.79 → 3.0.81

package/src/messages/cache.ts

@@ -7,13 +7,57 @@ type MessageWithContent = {
   content?: string | MessageContentComplex[];
 };
 
+/**
+ * Deep clones a message's content to prevent mutation of the original.
+ * Handles both string and array content types.
+ */
+function deepCloneContent<T extends string | MessageContentComplex[]>(
+  content: T
+): T {
+  if (typeof content === 'string') {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return content.map((block) => ({ ...block })) as T;
+  }
+  return content;
+}
+
+/**
+ * Creates a shallow clone of a message with deep-cloned content.
+ * This ensures modifications to content don't affect the original message.
+ */
+function cloneMessageWithContent<T extends MessageWithContent>(message: T): T {
+  if (message.content === undefined) {
+    return { ...message };
+  }
+  return {
+    ...message,
+    content: deepCloneContent(message.content),
+  };
+}
+
+/**
+ * Checks if a message's content needs cache control stripping.
+ * Returns true if content has cachePoint blocks or cache_control fields.
+ */
+function needsCacheStripping(content: MessageContentComplex[]): boolean {
+  for (let i = 0; i < content.length; i++) {
+    const block = content[i];
+    if (isCachePoint(block)) return true;
+    if ('cache_control' in block) return true;
+  }
+  return false;
+}
+
 /**
  * Anthropic API: Adds cache control to the appropriate user messages in the payload.
  * Strips ALL existing cache control (both Anthropic and Bedrock formats) from all messages,
  * then adds fresh cache control to the last 2 user messages in a single backward pass.
  * This ensures we don't accumulate stale cache points across multiple turns.
+ * Returns a new array - only clones messages that require modification.
  * @param messages - The array of message objects.
- * @returns - The updated array of message objects with cache control added.
+ * @returns - A new array of message objects with cache control added.
  */
 export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
   messages: T[]
@@ -22,22 +66,47 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
     return messages;
   }
 
-  const updatedMessages = [...messages];
+  const updatedMessages: T[] = [...messages];
   let userMessagesModified = 0;
 
   for (let i = updatedMessages.length - 1; i >= 0; i--) {
-    const message = updatedMessages[i];
+    const originalMessage = updatedMessages[i];
     const isUserMessage =
-      ('getType' in message && message.getType() === 'human') ||
-      ('role' in message && message.role === 'user');
+      ('getType' in originalMessage && originalMessage.getType() === 'human') ||
+      ('role' in originalMessage && originalMessage.role === 'user');
+
+    const hasArrayContent = Array.isArray(originalMessage.content);
+    const needsStripping =
+      hasArrayContent &&
+      needsCacheStripping(originalMessage.content as MessageContentComplex[]);
+    const needsCacheAdd =
+      userMessagesModified < 2 &&
+      isUserMessage &&
+      (typeof originalMessage.content === 'string' || hasArrayContent);
+
+    if (!needsStripping && !needsCacheAdd) {
+      continue;
+    }
 
-    if (Array.isArray(message.content)) {
-      message.content = message.content.filter(
+    const message = cloneMessageWithContent(
+      originalMessage as MessageWithContent
+    ) as T;
+    updatedMessages[i] = message;
+
+    if (hasArrayContent) {
+      message.content = (message.content as MessageContentComplex[]).filter(
         (block) => !isCachePoint(block as MessageContentComplex)
       ) as typeof message.content;
 
-      for (let j = 0; j < message.content.length; j++) {
-        const block = message.content[j] as Record<string, unknown>;
+      for (
+        let j = 0;
+        j < (message.content as MessageContentComplex[]).length;
+        j++
+      ) {
+        const block = (message.content as MessageContentComplex[])[j] as Record<
+          string,
+          unknown
+        >;
         if ('cache_control' in block) {
           delete block.cache_control;
         }
@@ -81,9 +150,20 @@ function isCachePoint(block: MessageContentComplex): boolean {
   return 'cachePoint' in block && !('type' in block);
 }
 
+/**
+ * Checks if a message's content has Anthropic cache_control fields.
+ */
+function hasAnthropicCacheControl(content: MessageContentComplex[]): boolean {
+  for (let i = 0; i < content.length; i++) {
+    if ('cache_control' in content[i]) return true;
+  }
+  return false;
+}
+
 /**
  * Removes all Anthropic cache_control fields from messages
  * Used when switching from Anthropic to Bedrock provider
+ * Returns a new array - only clones messages that require modification.
  */
 export function stripAnthropicCacheControl<T extends MessageWithContent>(
   messages: T[]
@@ -92,18 +172,30 @@ export function stripAnthropicCacheControl<T extends MessageWithContent>(
     return messages;
   }
 
-  const updatedMessages = [...messages];
+  const updatedMessages: T[] = [...messages];
 
   for (let i = 0; i < updatedMessages.length; i++) {
-    const message = updatedMessages[i];
-    const content = message.content;
+    const originalMessage = updatedMessages[i];
+    const content = originalMessage.content;
 
-    if (Array.isArray(content)) {
-      for (let j = 0; j < content.length; j++) {
-        const block = content[j] as Record<string, unknown>;
-        if ('cache_control' in block) {
-          delete block.cache_control;
-        }
+    if (!Array.isArray(content) || !hasAnthropicCacheControl(content)) {
+      continue;
+    }
+
+    const message = cloneMessageWithContent(originalMessage);
+    updatedMessages[i] = message;
+
+    for (
+      let j = 0;
+      j < (message.content as MessageContentComplex[]).length;
+      j++
+    ) {
+      const block = (message.content as MessageContentComplex[])[j] as Record<
+        string,
+        unknown
+      >;
+      if ('cache_control' in block) {
+        delete block.cache_control;
       }
     }
   }
@@ -111,9 +203,20 @@ export function stripAnthropicCacheControl<T extends MessageWithContent>(
   return updatedMessages;
 }
 
+/**
+ * Checks if a message's content has Bedrock cachePoint blocks.
+ */
+function hasBedrockCachePoint(content: MessageContentComplex[]): boolean {
+  for (let i = 0; i < content.length; i++) {
+    if (isCachePoint(content[i])) return true;
+  }
+  return false;
+}
+
 /**
  * Removes all Bedrock cachePoint blocks from messages
  * Used when switching from Bedrock to Anthropic provider
+ * Returns a new array - only clones messages that require modification.
  */
 export function stripBedrockCacheControl<T extends MessageWithContent>(
   messages: T[]
@@ -122,17 +225,22 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
     return messages;
   }
 
-  const updatedMessages = [...messages];
+  const updatedMessages: T[] = [...messages];
 
   for (let i = 0; i < updatedMessages.length; i++) {
-    const message = updatedMessages[i];
-    const content = message.content;
+    const originalMessage = updatedMessages[i];
+    const content = originalMessage.content;
 
-    if (Array.isArray(content)) {
-      message.content = content.filter(
-        (block) => !isCachePoint(block as MessageContentComplex)
-      ) as typeof content;
+    if (!Array.isArray(content) || !hasBedrockCachePoint(content)) {
+      continue;
     }
+
+    const message = cloneMessageWithContent(originalMessage);
+    updatedMessages[i] = message;
+
+    message.content = (message.content as MessageContentComplex[]).filter(
+      (block) => !isCachePoint(block as MessageContentComplex)
+    ) as typeof content;
   }
 
   return updatedMessages;
@@ -145,8 +253,9 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
  * Strips ALL existing cache control (both Bedrock and Anthropic formats) from all messages,
  * then adds fresh cache points to the last 2 messages in a single backward pass.
  * This ensures we don't accumulate stale cache points across multiple turns.
+ * Returns a new array - only clones messages that require modification.
  * @param messages - The array of message objects.
- * @returns - The updated array of message objects with cache points added.
+ * @returns - A new array of message objects with cache points added.
  */
 export function addBedrockCacheControl<
   T extends Partial<BaseMessage> & MessageWithContent,
@@ -155,42 +264,62 @@ export function addBedrockCacheControl<
     return messages;
   }
 
-  const updatedMessages: T[] = messages.slice();
+  const updatedMessages: T[] = [...messages];
   let messagesModified = 0;
 
   for (let i = updatedMessages.length - 1; i >= 0; i--) {
-    const message = updatedMessages[i];
+    const originalMessage = updatedMessages[i];
     const isToolMessage =
-      'getType' in message &&
-      typeof message.getType === 'function' &&
-      message.getType() === 'tool';
+      'getType' in originalMessage &&
+      typeof originalMessage.getType === 'function' &&
+      originalMessage.getType() === 'tool';
+
+    const content = originalMessage.content;
+    const hasArrayContent = Array.isArray(content);
+    const needsStripping =
+      hasArrayContent &&
+      needsCacheStripping(content as MessageContentComplex[]);
+    const isEmptyString = typeof content === 'string' && content === '';
+    const needsCacheAdd =
+      messagesModified < 2 &&
+      !isToolMessage &&
+      !isEmptyString &&
+      (typeof content === 'string' || hasArrayContent);
+
+    if (!needsStripping && !needsCacheAdd) {
+      continue;
+    }
 
-    const content = message.content;
+    const message = cloneMessageWithContent(originalMessage);
+    updatedMessages[i] = message;
 
-    if (Array.isArray(content)) {
-      message.content = content.filter(
+    if (hasArrayContent) {
+      message.content = (message.content as MessageContentComplex[]).filter(
         (block) => !isCachePoint(block)
       ) as typeof content;
 
-      for (let j = 0; j < message.content.length; j++) {
-        const block = message.content[j] as Record<string, unknown>;
+      for (
+        let j = 0;
+        j < (message.content as MessageContentComplex[]).length;
+        j++
+      ) {
+        const block = (message.content as MessageContentComplex[])[j] as Record<
+          string,
+          unknown
+        >;
         if ('cache_control' in block) {
           delete block.cache_control;
         }
       }
     }
 
-    if (messagesModified >= 2 || isToolMessage) {
+    if (messagesModified >= 2 || isToolMessage || isEmptyString) {
       continue;
     }
 
-    if (typeof content === 'string' && content === '') {
-      continue;
-    }
-
-    if (typeof content === 'string') {
+    if (typeof message.content === 'string') {
       message.content = [
-        { type: ContentTypes.TEXT, text: content },
+        { type: ContentTypes.TEXT, text: message.content },
         { cachePoint: { type: 'default' } },
       ] as MessageContentComplex[];
       messagesModified++;

package/src/scripts/thinking-bedrock.ts

@@ -0,0 +1,159 @@
+// src/scripts/thinking-bedrock.ts
+import { config } from 'dotenv';
+config();
+import { HumanMessage, BaseMessage } from '@langchain/core/messages';
+import type { UsageMetadata } from '@langchain/core/messages';
+import * as t from '@/types';
+import { ChatModelStreamHandler, createContentAggregator } from '@/stream';
+import { createCodeExecutionTool } from '@/tools/CodeExecutor';
+import { ToolEndHandler, ModelEndHandler } from '@/events';
+import { GraphEvents, Providers } from '@/common';
+import { getLLMConfig } from '@/utils/llmConfig';
+import { getArgs } from '@/scripts/args';
+import { Run } from '@/run';
+
+const conversationHistory: BaseMessage[] = [];
+let _contentParts: t.MessageContentComplex[] = [];
+const collectedUsage: UsageMetadata[] = [];
+
+async function testBedrockThinking(): Promise<void> {
+  const { userName } = await getArgs();
+  const instructions = `You are a helpful AI assistant for ${userName}. When answering questions, be thorough in your reasoning.`;
+  const { contentParts, aggregateContent } = createContentAggregator();
+  _contentParts = contentParts as t.MessageContentComplex[];
+
+  // Set up event handlers
+  const customHandlers = {
+    [GraphEvents.TOOL_END]: new ToolEndHandler(),
+    [GraphEvents.CHAT_MODEL_END]: new ModelEndHandler(collectedUsage),
+    [GraphEvents.CHAT_MODEL_STREAM]: new ChatModelStreamHandler(),
+    [GraphEvents.ON_RUN_STEP_COMPLETED]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_COMPLETED,
+        data: t.StreamEventData
+      ): void => {
+        console.log('====== ON_RUN_STEP_COMPLETED ======');
+        aggregateContent({
+          event,
+          data: data as unknown as { result: t.ToolEndEvent },
+        });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP]: {
+      handle: (event: GraphEvents.ON_RUN_STEP, data: t.RunStep) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_RUN_STEP_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_RUN_STEP_DELTA,
+        data: t.RunStepDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_MESSAGE_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_MESSAGE_DELTA,
+        data: t.MessageDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+    [GraphEvents.ON_REASONING_DELTA]: {
+      handle: (
+        event: GraphEvents.ON_REASONING_DELTA,
+        data: t.ReasoningDeltaEvent
+      ) => {
+        aggregateContent({ event, data });
+      },
+    },
+  };
+
+  const baseLlmConfig = getLLMConfig(Providers.BEDROCK);
+
+  // Enable thinking with token budget for Bedrock
+  const llmConfig = {
+    ...baseLlmConfig,
+    model: 'us.anthropic.claude-3-7-sonnet-20250219-v1:0',
+    maxTokens: 5000,
+    additionalModelRequestFields: {
+      thinking: { type: 'enabled', budget_tokens: 2000 },
+    },
+  };
+
+  const run = await Run.create<t.IState>({
+    runId: 'test-bedrock-thinking-id',
+    graphConfig: {
+      instructions,
+      type: 'standard',
+      tools: [createCodeExecutionTool()],
+      llmConfig,
+    },
+    returnContent: true,
+    customHandlers: customHandlers as t.RunConfig['customHandlers'],
+  });
+
+  const config = {
+    configurable: {
+      thread_id: 'bedrock-thinking-test-thread',
+    },
+    streamMode: 'values',
+    version: 'v2' as const,
+  };
+
+  // Test 1: Regular thinking mode
+  console.log('\n\nTest 1: Bedrock Regular thinking mode');
+  const userMessage1 = `Please print 'hello world' in python`;
+  conversationHistory.push(new HumanMessage(userMessage1));
+
+  console.log('Running first query with Bedrock thinking enabled...');
+  const firstInputs = { messages: [...conversationHistory] };
+  await run.processStream(firstInputs, config);
+
+  // Extract and display thinking blocks
+  const finalMessages = run.getRunMessages();
+  console.log('\n\nFinal messages after Test 1:');
+  console.dir(finalMessages, { depth: null });
+
+  // Test 2: Try multi-turn conversation
+  console.log(
+    '\n\nTest 2: Multi-turn conversation with Bedrock thinking enabled'
+  );
+  const userMessage2 = `Given your previous analysis, what would be the most significant technical challenges in making this transition?`;
+  conversationHistory.push(new HumanMessage(userMessage2));
+
+  console.log('Running second query with Bedrock thinking enabled...');
+  const secondInputs = { messages: [...conversationHistory] };
+  await run.processStream(secondInputs, config);
+
+  // Display thinking blocks for second response
+  const finalMessages2 = run.getRunMessages();
+  console.log('\n\nBedrock thinking feature test completed!');
+  console.dir(finalMessages2, { depth: null });
+
+  console.log('\n\nContent parts:');
+  console.dir(_contentParts, { depth: null });
+}
+
+process.on('unhandledRejection', (reason, promise) => {
+  console.error('Unhandled Rejection at:', promise, 'reason:', reason);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});
+
+process.on('uncaughtException', (err) => {
+  console.error('Uncaught Exception:', err);
+});
+
+testBedrockThinking().catch((err) => {
+  console.error(err);
+  console.log('Conversation history:');
+  console.dir(conversationHistory, { depth: null });
+  console.log('Content parts:');
+  console.dir(_contentParts, { depth: null });
+  process.exit(1);
+});