@librechat/agents 3.0.18 → 3.0.20

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/messages/format.ts

@@ -13,6 +13,8 @@ import type { ToolCall } from '@langchain/core/messages/tool';
 import type {
   ExtendedMessageContent,
   MessageContentComplex,
+  ReasoningContentText,
+  ToolCallContent,
   ToolCallPart,
   TPayload,
   TMessage,
@@ -308,12 +310,12 @@ function formatAssistantMessage(
         }
         // Create a new AIMessage with this text and prepare for tool calls
         lastAIMessage = new AIMessage({
-          content: part.text || '',
+          content: part.text != null ? part.text : '',
         });
         formattedMessages.push(lastAIMessage);
       } else if (part.type === ContentTypes.TOOL_CALL) {
         // Skip malformed tool call entries without tool_call property
-        if (!part.tool_call) {
+        if (part.tool_call == null) {
           continue;
         }
 
@@ -325,7 +327,10 @@ function formatAssistantMessage(
         } = part.tool_call as ToolCallPart;
 
         // Skip invalid tool calls that have no name AND no output
-        if (!_tool_call.name && (output == null || output === '')) {
+        if (
+          _tool_call.name == null ||
+          (_tool_call.name === '' && (output == null || output === ''))
+        ) {
           continue;
         }
 
@@ -358,7 +363,7 @@ function formatAssistantMessage(
           new ToolMessage({
             tool_call_id: tool_call.id ?? '',
             name: tool_call.name,
-            content: output || '',
+            content: output != null ? output : '',
           })
         );
       } else if (part.type === ContentTypes.THINK) {
@@ -395,6 +400,226 @@ function formatAssistantMessage(
   return formattedMessages;
 }
 
+/**
+ * Labels all agent content for parallel patterns (fan-out/fan-in)
+ * Groups consecutive content by agent and wraps with clear labels
+ */
+function labelAllAgentContent(
+  contentParts: MessageContentComplex[],
+  agentIdMap: Record<number, string>,
+  agentNames?: Record<string, string>
+): MessageContentComplex[] {
+  const result: MessageContentComplex[] = [];
+  let currentAgentId: string | undefined;
+  let agentContentBuffer: MessageContentComplex[] = [];
+
+  const flushAgentBuffer = (): void => {
+    if (agentContentBuffer.length === 0) {
+      return;
+    }
+
+    if (currentAgentId != null && currentAgentId !== '') {
+      const agentName = (agentNames?.[currentAgentId] ?? '') || currentAgentId;
+      const formattedParts: string[] = [];
+
+      formattedParts.push(`--- ${agentName} ---`);
+
+      for (const part of agentContentBuffer) {
+        if (part.type === ContentTypes.THINK) {
+          const thinkContent = (part as ReasoningContentText).think || '';
+          if (thinkContent) {
+            formattedParts.push(
+              `${agentName}: ${JSON.stringify({
+                type: 'think',
+                think: thinkContent,
+              })}`
+            );
+          }
+        } else if (part.type === ContentTypes.TEXT) {
+          const textContent: string = part.text ?? '';
+          if (textContent) {
+            formattedParts.push(`${agentName}: ${textContent}`);
+          }
+        } else if (part.type === ContentTypes.TOOL_CALL) {
+          formattedParts.push(
+            `${agentName}: ${JSON.stringify({
+              type: 'tool_call',
+              tool_call: (part as ToolCallContent).tool_call,
+            })}`
+          );
+        }
+      }
+
+      formattedParts.push(`--- End of ${agentName} ---`);
+
+      // Create a single text content part with all agent content
+      result.push({
+        type: ContentTypes.TEXT,
+        text: formattedParts.join('\n\n'),
+      } as MessageContentComplex);
+    } else {
+      // No agent ID, pass through as-is
+      result.push(...agentContentBuffer);
+    }
+
+    agentContentBuffer = [];
+  };
+
+  for (let i = 0; i < contentParts.length; i++) {
+    const part = contentParts[i];
+    const agentId = agentIdMap[i];
+
+    // If agent changed, flush previous buffer
+    if (agentId !== currentAgentId && currentAgentId !== undefined) {
+      flushAgentBuffer();
+    }
+
+    currentAgentId = agentId;
+    agentContentBuffer.push(part);
+  }
+
+  // Flush any remaining content
+  flushAgentBuffer();
+
+  return result;
+}
+
+/**
+ * Groups content parts by agent and formats them with agent labels
+ * This preprocesses multi-agent content to prevent identity confusion
+ *
+ * @param contentParts - The content parts from a run
+ * @param agentIdMap - Map of content part index to agent ID
+ * @param agentNames - Optional map of agent ID to display name
+ * @param options - Configuration options
+ * @param options.labelNonTransferContent - If true, labels all agent transitions (for parallel patterns)
+ * @returns Modified content parts with agent labels where appropriate
+ */
+export const labelContentByAgent = (
+  contentParts: MessageContentComplex[],
+  agentIdMap?: Record<number, string>,
+  agentNames?: Record<string, string>,
+  options?: { labelNonTransferContent?: boolean }
+): MessageContentComplex[] => {
+  if (!agentIdMap || Object.keys(agentIdMap).length === 0) {
+    return contentParts;
+  }
+
+  // If labelNonTransferContent is true, use a different strategy for parallel patterns
+  if (options?.labelNonTransferContent === true) {
+    return labelAllAgentContent(contentParts, agentIdMap, agentNames);
+  }
+
+  const result: MessageContentComplex[] = [];
+  let currentAgentId: string | undefined;
+  let agentContentBuffer: MessageContentComplex[] = [];
+  let transferToolCallIndex: number | undefined;
+  let transferToolCallId: string | undefined;
+
+  const flushAgentBuffer = (): void => {
+    if (agentContentBuffer.length === 0) {
+      return;
+    }
+
+    // If this is content from a transferred agent, format it specially
+    if (
+      currentAgentId != null &&
+      currentAgentId !== '' &&
+      transferToolCallIndex !== undefined
+    ) {
+      const agentName = (agentNames?.[currentAgentId] ?? '') || currentAgentId;
+      const formattedParts: string[] = [];
+
+      formattedParts.push(`--- Transfer to ${agentName} ---`);
+
+      for (const part of agentContentBuffer) {
+        if (part.type === ContentTypes.THINK) {
+          formattedParts.push(
+            `${agentName}: ${JSON.stringify({
+              type: 'think',
+              think: (part as ReasoningContentText).think,
+            })}`
+          );
+        } else if ('text' in part && part.type === ContentTypes.TEXT) {
+          const textContent: string = part.text ?? '';
+          if (textContent) {
+            formattedParts.push(
+              `${agentName}: ${JSON.stringify({
+                type: 'text',
+                text: textContent,
+              })}`
+            );
+          }
+        } else if (part.type === ContentTypes.TOOL_CALL) {
+          formattedParts.push(
+            `${agentName}: ${JSON.stringify({
+              type: 'tool_call',
+              tool_call: (part as ToolCallContent).tool_call,
+            })}`
+          );
+        }
+      }
+
+      formattedParts.push(`--- End of ${agentName} response ---`);
+
+      // Find the tool call that triggered this transfer and update its output
+      if (transferToolCallIndex < result.length) {
+        const transferToolCall = result[transferToolCallIndex];
+        if (
+          transferToolCall.type === ContentTypes.TOOL_CALL &&
+          transferToolCall.tool_call?.id === transferToolCallId
+        ) {
+          transferToolCall.tool_call.output = formattedParts.join('\n\n');
+        }
+      }
+    } else {
+      // Not from a transfer, add as-is
+      result.push(...agentContentBuffer);
+    }
+
+    agentContentBuffer = [];
+    transferToolCallIndex = undefined;
+    transferToolCallId = undefined;
+  };
+
+  for (let i = 0; i < contentParts.length; i++) {
+    const part = contentParts[i];
+    const agentId = agentIdMap[i];
+
+    // Check if this is a transfer tool call
+    const isTransferTool =
+      (part.type === ContentTypes.TOOL_CALL &&
+        (part as ToolCallContent).tool_call?.name?.startsWith(
+          'lc_transfer_to_'
+        )) ??
+      false;
+
+    // If agent changed, flush previous buffer
+    if (agentId !== currentAgentId && currentAgentId !== undefined) {
+      flushAgentBuffer();
+    }
+
+    currentAgentId = agentId;
+
+    if (isTransferTool) {
+      // Flush any existing buffer first
+      flushAgentBuffer();
+      // Add the transfer tool call to result
+      result.push(part);
+      // Mark that the next agent's content should be captured
+      transferToolCallIndex = result.length - 1;
+      transferToolCallId = (part as ToolCallContent).tool_call?.id;
+      currentAgentId = undefined; // Reset to capture the next agent
+    } else {
+      agentContentBuffer.push(part);
+    }
+  }
+
+  flushAgentBuffer();
+
+  return result;
+};
+
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
@@ -463,7 +688,7 @@ export const formatAgentMessages = (
             }
             // Protect against malformed tool call entries
             if (
-              !part.tool_call ||
+              part.tool_call == null ||
               part.tool_call.name == null ||
               part.tool_call.name === ''
             ) {
@@ -495,7 +720,7 @@ export const formatAgentMessages = (
           // Check if this is a continuation of the tool sequence
           let isToolResponse = false;
           const content = payload[j].content;
-          if (content && Array.isArray(content)) {
+          if (content != null && Array.isArray(content)) {
             for (const part of content) {
               if (part.type === ContentTypes.TOOL_CALL) {
                 isToolResponse = true;