@librechat/agents 3.0.19 → 3.0.21

package/src/messages/cache.ts

@@ -9,6 +9,9 @@ type MessageWithContent = {
 
 /**
  * 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.
  * @param messages - The array of message objects.
  * @returns - The updated array of message objects with cache control added.
  */
@@ -22,15 +25,26 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
   const updatedMessages = [...messages];
   let userMessagesModified = 0;
 
-  for (
-    let i = updatedMessages.length - 1;
-    i >= 0 && userMessagesModified < 2;
-    i--
-  ) {
+  for (let i = updatedMessages.length - 1; i >= 0; i--) {
     const message = updatedMessages[i];
-    if ('getType' in message && message.getType() !== 'human') {
-      continue;
-    } else if ('role' in message && message.role !== 'user') {
+    const isUserMessage =
+      ('getType' in message && message.getType() === 'human') ||
+      ('role' in message && message.role === 'user');
+
+    if (Array.isArray(message.content)) {
+      message.content = message.content.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>;
+        if ('cache_control' in block) {
+          delete block.cache_control;
+        }
+      }
+    }
+
+    if (userMessagesModified >= 2 || !isUserMessage) {
       continue;
     }
 
@@ -60,10 +74,77 @@ export function addCacheControl<T extends AnthropicMessage | BaseMessage>(
   return updatedMessages;
 }
 
+/**
+ * Checks if a content block is a cache point
+ */
+function isCachePoint(block: MessageContentComplex): boolean {
+  return 'cachePoint' in block && !('type' in block);
+}
+
+/**
+ * Removes all Anthropic cache_control fields from messages
+ * Used when switching from Anthropic to Bedrock provider
+ */
+export function stripAnthropicCacheControl<T extends MessageWithContent>(
+  messages: T[]
+): T[] {
+  if (!Array.isArray(messages)) {
+    return messages;
+  }
+
+  const updatedMessages = [...messages];
+
+  for (let i = 0; i < updatedMessages.length; i++) {
+    const message = updatedMessages[i];
+    const content = message.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;
+        }
+      }
+    }
+  }
+
+  return updatedMessages;
+}
+
+/**
+ * Removes all Bedrock cachePoint blocks from messages
+ * Used when switching from Bedrock to Anthropic provider
+ */
+export function stripBedrockCacheControl<T extends MessageWithContent>(
+  messages: T[]
+): T[] {
+  if (!Array.isArray(messages)) {
+    return messages;
+  }
+
+  const updatedMessages = [...messages];
+
+  for (let i = 0; i < updatedMessages.length; i++) {
+    const message = updatedMessages[i];
+    const content = message.content;
+
+    if (Array.isArray(content)) {
+      message.content = content.filter(
+        (block) => !isCachePoint(block as MessageContentComplex)
+      ) as typeof content;
+    }
+  }
+
+  return updatedMessages;
+}
+
 /**
  * Adds Bedrock Converse API cache points to the last two messages.
  * Inserts `{ cachePoint: { type: 'default' } }` as a separate content block
  * immediately after the last text block in each targeted message.
+ * 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.
  * @param messages - The array of message objects.
  * @returns - The updated array of message objects with cache points added.
  */
@@ -77,23 +158,32 @@ export function addBedrockCacheControl<
   const updatedMessages: T[] = messages.slice();
   let messagesModified = 0;
 
-  for (
-    let i = updatedMessages.length - 1;
-    i >= 0 && messagesModified < 2;
-    i--
-  ) {
+  for (let i = updatedMessages.length - 1; i >= 0; i--) {
     const message = updatedMessages[i];
-
-    if (
+    const isToolMessage =
       'getType' in message &&
       typeof message.getType === 'function' &&
-      message.getType() === 'tool'
-    ) {
-      continue;
-    }
+      message.getType() === 'tool';
 
     const content = message.content;
 
+    if (Array.isArray(content)) {
+      message.content = content.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>;
+        if ('cache_control' in block) {
+          delete block.cache_control;
+        }
+      }
+    }
+
+    if (messagesModified >= 2 || isToolMessage) {
+      continue;
+    }
+
     if (typeof content === 'string' && content === '') {
       continue;
     }
@@ -107,9 +197,9 @@ export function addBedrockCacheControl<
       continue;
     }
 
-    if (Array.isArray(content)) {
+    if (Array.isArray(message.content)) {
       let hasCacheableContent = false;
-      for (const block of content) {
+      for (const block of message.content) {
         if (block.type === ContentTypes.TEXT) {
           if (typeof block.text === 'string' && block.text !== '') {
             hasCacheableContent = true;
@@ -123,15 +213,15 @@ export function addBedrockCacheControl<
       }
 
       let inserted = false;
-      for (let j = content.length - 1; j >= 0; j--) {
-        const block = content[j] as MessageContentComplex;
+      for (let j = message.content.length - 1; j >= 0; j--) {
+        const block = message.content[j] as MessageContentComplex;
         const type = (block as { type?: string }).type;
         if (type === ContentTypes.TEXT || type === 'text') {
           const text = (block as { text?: string }).text;
           if (text === '' || text === undefined) {
             continue;
           }
-          content.splice(j + 1, 0, {
+          message.content.splice(j + 1, 0, {
             cachePoint: { type: 'default' },
           } as MessageContentComplex);
           inserted = true;
@@ -139,7 +229,7 @@ export function addBedrockCacheControl<
         }
       }
       if (!inserted) {
-        content.push({
+        message.content.push({
           cachePoint: { type: 'default' },
         } as MessageContentComplex);
       }

package/src/types/stream.ts

@@ -116,7 +116,7 @@ export type ToolErrorData = {
 export type ToolEndCallback = (
   data: ToolEndData,
   metadata?: Record<string, unknown>
-) => void;
+) => Promise<void>;
 
 export type ProcessedToolCall = {
   name: string;