@illuma-ai/agents 1.0.90 → 1.0.94

package/src/messages/cache.ts

@@ -1,4 +1,11 @@
-import { BaseMessage, MessageContentComplex } from '@langchain/core/messages';
+import {
+  AIMessage,
+  BaseMessage,
+  ToolMessage,
+  HumanMessage,
+  SystemMessage,
+  MessageContentComplex,
+} from '@langchain/core/messages';
 import type { AnthropicMessage } from '@/types/messages';
 import type Anthropic from '@anthropic-ai/sdk';
 import { ContentTypes } from '@/common/enum';
@@ -34,14 +41,45 @@ function deepCloneContent<T extends string | MessageContentComplex[]>(
 }
 
 /**
- * Clones a message with deep-cloned content, explicitly excluding LangChain
- * serialization metadata to prevent coercion issues.
- * Keeps lc_kwargs in sync with content to prevent LangChain serialization issues.
+ * Clones a message with new content. For LangChain BaseMessage instances,
+ * constructs a proper class instance so that `instanceof` checks are preserved
+ * in downstream code (e.g., ensureThinkingBlockInMessages).
+ * For plain objects (AnthropicMessage), uses object spread.
  */
 function cloneMessage<T extends MessageWithContent>(
   message: T,
   content: string | MessageContentComplex[]
 ): T {
+  if (message instanceof BaseMessage) {
+    const baseParams = {
+      content,
+      additional_kwargs: { ...message.additional_kwargs },
+      response_metadata: { ...message.response_metadata },
+      id: message.id,
+      name: message.name,
+    };
+
+    const msgType = message.getType();
+    switch (msgType) {
+    case 'ai':
+      return new AIMessage({
+        ...baseParams,
+        tool_calls: (message as unknown as AIMessage).tool_calls,
+      }) as unknown as T;
+    case 'human':
+      return new HumanMessage(baseParams) as unknown as T;
+    case 'system':
+      return new SystemMessage(baseParams) as unknown as T;
+    case 'tool':
+      return new ToolMessage({
+        ...baseParams,
+        tool_call_id: (message as unknown as ToolMessage).tool_call_id,
+      }) as unknown as T;
+    default:
+      break;
+    }
+  }
+
   const {
     lc_kwargs: _lc_kwargs,
     lc_serializable: _lc_serializable,
@@ -288,7 +326,7 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
  *
  * Why this works:
  * - System message has its own cachePoint (added in AgentContext)
- * - Tools have their own cachePoint (added in CustomChatBedrockConverse)
+ * - Tools have their own cachePoint (added in IllumaBedrockConverse)
  * - Conversation history grows, but the PREFIX stays the same
  * - Only the NEW user message is uncached (it's always different)
  *
@@ -321,26 +359,27 @@ export function addBedrockCacheControl<
     }
   );
 
-  const updatedMessages: T[] = messages.slice();
-
-  // First pass: Remove ALL existing cache points to ensure clean state
-  // This prevents accumulation of stale cache points
-  for (const message of updatedMessages) {
-    const content = message.content;
+  // Clone messages to avoid mutating originals
+  const updatedMessages: T[] = messages.map((msg) => {
+    const content = msg.content;
     if (Array.isArray(content)) {
-      message.content = content.filter(
-        (block) => !isCachePoint(block)
-      ) as typeof content;
-
-      // Also remove Anthropic-style cache_control
-      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;
-        }
+      // Strip existing cachePoint blocks and Anthropic-style cache_control
+      const stripped = content
+        .filter((block) => !isCachePoint(block))
+        .map((block) => {
+          const rec = block as Record<string, unknown>;
+          if ('cache_control' in rec) {
+            const { cache_control: _, ...rest } = rec;
+            return rest as MessageContentComplex;
+          }
+          return block;
+        });
+      if (needsCacheStripping(content) || hasAnthropicCacheControl(content)) {
+        return cloneMessage(msg, stripped) as T;
       }
     }
-  }
+    return cloneMessage(msg, content as string | MessageContentComplex[]) as T;
+  });
 
   // Helper function to check if a message contains reasoning/thinking blocks
   const hasReasoningBlock = (message: T): boolean => {
@@ -350,11 +389,6 @@ export function addBedrockCacheControl<
     }
     for (const block of content) {
       const type = (block as { type?: string }).type;
-      // Check for all reasoning/thinking block types:
-      // - reasoning_content: Bedrock Anthropic extended thinking
-      // - reasoning: Generic reasoning format
-      // - thinking: Anthropic direct API thinking
-      // - redacted_thinking: Anthropic redacted thinking blocks
       if (
         type === 'reasoning_content' ||
         type === 'reasoning' ||
@@ -367,141 +401,112 @@ export function addBedrockCacheControl<
     return false;
   };
 
-  // Second pass: Find the LAST assistant message WITHOUT reasoning blocks and add a cache point there
-  // Messages with reasoning/thinking blocks cannot have cache points after them (Bedrock limitation)
-  let lastAssistantIndex = -1;
-  let skippedWithReasoning = 0;
-
-  // Count message types for logging
-  const messageTypes: Record<string, number> = {};
-  for (const message of updatedMessages) {
-    const msgType =
-      'getType' in message && typeof message.getType === 'function'
-        ? message.getType()
-        : 'unknown';
-    messageTypes[msgType] = (messageTypes[msgType] || 0) + 1;
-  }
-
-  for (let i = updatedMessages.length - 1; i >= 0; i--) {
-    const message = updatedMessages[i];
-    const messageType =
-      'getType' in message && typeof message.getType === 'function'
-        ? message.getType()
-        : 'unknown';
+  /**
+   * Helper to add a cachePoint to a message's content.
+   * For strings: wraps into [{type: 'text', text}, {cachePoint}]
+   * For arrays: inserts cachePoint after the last non-whitespace text block
+   * Returns the new message or null if no suitable insertion point.
+   */
+  const addCachePointToMessage = (message: T): T | null => {
+    const msgContent = message.content;
+
+    if (typeof msgContent === 'string' && msgContent !== '') {
+      const newContent = [
+        { type: ContentTypes.TEXT, text: msgContent },
+        { cachePoint: { type: 'default' } },
+      ] as MessageContentComplex[];
+      return cloneMessage(message, newContent) as T;
+    }
 
-    if (messageType === 'ai') {
-      // Skip assistant messages with reasoning blocks - cache points not allowed after them
+    if (Array.isArray(msgContent) && msgContent.length > 0) {
       if (hasReasoningBlock(message)) {
-        skippedWithReasoning++;
-        debugCache(
-          'addBedrockCacheControl: Skipping assistant message with reasoning block',
-          { index: i }
-        );
-        continue;
+        return null;
+      }
+      // Find the last text block and insert cache point after it
+      for (let j = msgContent.length - 1; j >= 0; j--) {
+        const type = (msgContent[j] as { type?: string }).type;
+        if (type === ContentTypes.TEXT || type === 'text') {
+          const text = (msgContent[j] as { text?: string }).text;
+          if (text != null && text.trim() !== '') {
+            const newContent = [
+              ...msgContent.slice(0, j + 1),
+              { cachePoint: { type: 'default' } } as MessageContentComplex,
+              ...msgContent.slice(j + 1),
+            ];
+            return cloneMessage(message, newContent) as T;
+          }
+        }
       }
-      lastAssistantIndex = i;
-      break;
     }
-  }
 
-  // Log message summary
-  debugCache(
-    `📨 Messages | total=${updatedMessages.length} | ${Object.entries(
-      messageTypes
-    )
-      .map(([k, v]) => `${k}:${v}`)
-      .join(' ')} | skippedReasoning=${skippedWithReasoning}`
-  );
+    return null;
+  };
 
-  // If no suitable assistant message found, skip conversation caching
-  // (System and Tools caching are still handled separately)
-  if (lastAssistantIndex === -1) {
-    debugCache(
-      '📨 Messages | No suitable assistant message for cachePoint (first turn or all have reasoning)'
-    );
-    return updatedMessages;
-  }
+  // Add cache points to the last 2 messages (from the end) that have eligible content.
+  // This mirrors Anthropic's two-breakpoint strategy for Bedrock's cache API.
+  // Skip messages with only whitespace, empty content, or reasoning blocks.
+  const MAX_CACHE_POINTS = 2;
+  let applied = 0;
 
-  // Add cache point to the last assistant message (without reasoning blocks)
-  const assistantMessage = updatedMessages[lastAssistantIndex];
-  const content = assistantMessage.content;
-
-  if (typeof content === 'string' && content !== '') {
-    assistantMessage.content = [
-      { type: ContentTypes.TEXT, text: content },
-      { cachePoint: { type: 'default' } },
-    ] as MessageContentComplex[];
-    debugCache(
-      `📍 Message cachePoint at index ${lastAssistantIndex} (string, ${content.length} chars)`
-    );
-    debugCache(
-      'addBedrockCacheControl: Added cachePoint to assistant message (string content)',
-      {
-        index: lastAssistantIndex,
-        contentLength: content.length,
-      }
-    );
-  } else if (
-    Array.isArray(assistantMessage.content) &&
-    assistantMessage.content.length > 0
+  for (
+    let i = updatedMessages.length - 1;
+    i >= 0 && applied < MAX_CACHE_POINTS;
+    i--
   ) {
-    // Double-check: If this message has reasoning blocks, skip adding cache point entirely
-    // This handles edge cases where the initial skip check might have missed it
-    if (hasReasoningBlock(assistantMessage)) {
-      debugCache(
-        `⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (has reasoning blocks)`
-      );
-      debugCache(
-        'addBedrockCacheControl: Skipping - assistant message has reasoning blocks (safety check)',
-        {
-          index: lastAssistantIndex,
-        }
-      );
-      return updatedMessages;
-    }
+    const message = updatedMessages[i];
+    const msgContent = message.content;
 
-    // Find the last text block and insert cache point after it
-    let inserted = false;
-    for (let j = assistantMessage.content.length - 1; j >= 0; j--) {
-      const block = assistantMessage.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 != null && text !== '') {
-          assistantMessage.content.splice(j + 1, 0, {
-            cachePoint: { type: 'default' },
-          } as MessageContentComplex);
-          inserted = true;
-          debugCache(
-            `📍 Message cachePoint at index ${lastAssistantIndex} (array, block ${j}, ${text.length} chars)`
-          );
+    // Skip empty/whitespace-only content
+    if (msgContent == null) continue;
+    if (typeof msgContent === 'string' && msgContent.trim() === '') continue;
+    if (Array.isArray(msgContent) && msgContent.length === 0) continue;
+
+    // Skip non-string, non-array content (e.g., number, object without type)
+    if (typeof msgContent !== 'string' && !Array.isArray(msgContent)) continue;
+
+    // Skip AI messages with only whitespace text and reasoning blocks (tool-call scenario)
+    const messageType =
+      'getType' in message && typeof message.getType === 'function'
+        ? message.getType()
+        : 'unknown';
+    const role = (message as Record<string, unknown>).role as
+      | string
+      | undefined;
+    const isAi = messageType === 'ai' || role === 'assistant';
+    if (isAi && hasReasoningBlock(message)) {
+      // Check if all text blocks are whitespace-only
+      if (Array.isArray(msgContent)) {
+        const hasNonWhitespaceText = msgContent.some((block) => {
+          const type = (block as { type?: string }).type;
+          if (type === ContentTypes.TEXT || type === 'text') {
+            const text = (block as { text?: string }).text;
+            return text != null && text.trim() !== '';
+          }
+          return false;
+        });
+        if (!hasNonWhitespaceText) {
           debugCache(
-            'addBedrockCacheControl: Added cachePoint after text block in assistant message',
-            {
-              index: lastAssistantIndex,
-              textBlockIndex: j,
-              contentLength: text.length,
-            }
+            `⚠️ Message cachePoint SKIPPED at index ${i} (AI with whitespace-only text + reasoning)`
           );
-          break;
+          continue;
         }
       }
     }
 
-    // If no text block found, don't append cache point as the message structure is unexpected
-    if (!inserted) {
-      const contentTypes = assistantMessage.content.map(
-        (b) => (b as { type?: string }).type
-      );
-      debugCache(
-        `⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (no text block, types: ${contentTypes.join(',')})`
-      );
+    // Skip messages that already have cache points (multi-agent scenarios)
+    if (
+      Array.isArray(msgContent) &&
+      msgContent.some((b) => isCachePoint(b as MessageContentComplex))
+    ) {
+      continue;
+    }
+
+    const updated = addCachePointToMessage(message);
+    if (updated != null) {
+      updatedMessages[i] = updated;
+      applied++;
       debugCache(
-        'addBedrockCacheControl: No suitable text block found, skipping cache point',
-        {
-          index: lastAssistantIndex,
-          contentTypes,
-        }
+        `📍 Message cachePoint at index ${i} (${typeof message.content === 'string' ? 'string' : 'array'})`
       );
     }
   }
@@ -509,7 +514,7 @@ export function addBedrockCacheControl<
   debugCache(
     'addBedrockCacheControl: Complete - stable prefix caching applied',
     {
-      lastAssistantIndex,
+      appliedCachePoints: applied,
       totalMessages: updatedMessages.length,
     }
   );

package/src/messages/content.js

@@ -0,0 +1,48 @@
+import { ContentTypes } from '@/common';
+/**
+ * Formats an array of messages for LangChain, making sure all content fields are strings
+ * @param {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} payload - The array of messages to format.
+ * @returns {Array<HumanMessage | AIMessage | SystemMessage | ToolMessage>} - The array of formatted LangChain messages, including ToolMessages for tool calls.
+ */
+export const formatContentStrings = (payload) => {
+    // Create a new array to store the processed messages
+    const result = [];
+    for (const message of payload) {
+        const messageType = message.getType();
+        const isValidMessage = messageType === 'human' ||
+            messageType === 'ai' ||
+            messageType === 'system';
+        if (!isValidMessage) {
+            result.push(message);
+            continue;
+        }
+        // If content is already a string, add as-is
+        if (typeof message.content === 'string') {
+            result.push(message);
+            continue;
+        }
+        // If content is not an array, add as-is
+        if (!Array.isArray(message.content)) {
+            result.push(message);
+            continue;
+        }
+        // Check if all content blocks are text type
+        const allTextBlocks = message.content.every((block) => block.type === ContentTypes.TEXT);
+        // Only convert to string if all blocks are text type
+        if (!allTextBlocks) {
+            result.push(message);
+            continue;
+        }
+        // Reduce text types to a single string
+        const content = message.content.reduce((acc, curr) => {
+            if (curr.type === ContentTypes.TEXT) {
+                return `${acc}${curr[ContentTypes.TEXT] || ''}\n`;
+            }
+            return acc;
+        }, '');
+        message.content = content.trim();
+        result.push(message);
+    }
+    return result;
+};
+//# sourceMappingURL=content.js.map

package/src/messages/content.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"content.js","sourceRoot":"","sources":["content.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAGxC;;;;GAIG;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAClC,OAA2B,EACP,EAAE;IACtB,qDAAqD;IACrD,MAAM,MAAM,GAAuB,EAAE,CAAC;IAEtC,KAAK,MAAM,OAAO,IAAI,OAAO,EAAE,CAAC;QAC9B,MAAM,WAAW,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC;QACtC,MAAM,cAAc,GAClB,WAAW,KAAK,OAAO;YACvB,WAAW,KAAK,IAAI;YACpB,WAAW,KAAK,QAAQ,CAAC;QAE3B,IAAI,CAAC,cAAc,EAAE,CAAC;YACpB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QAED,4CAA4C;QAC5C,IAAI,OAAO,OAAO,CAAC,OAAO,KAAK,QAAQ,EAAE,CAAC;YACxC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QAED,wCAAwC;QACxC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;YACpC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QAED,4CAA4C;QAC5C,MAAM,aAAa,GAAG,OAAO,CAAC,OAAO,CAAC,KAAK,CACzC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,CAC5C,CAAC;QAEF,qDAAqD;QACrD,IAAI,CAAC,aAAa,EAAE,CAAC;YACnB,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;YACrB,SAAS;QACX,CAAC;QAED,uCAAuC;QACvC,MAAM,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,IAAI,EAAE,EAAE;YACnD,IAAI,IAAI,CAAC,IAAI,KAAK,YAAY,CAAC,IAAI,EAAE,CAAC;gBACpC,OAAO,GAAG,GAAG,GAAG,IAAI,CAAC,YAAY,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,CAAC;YACpD,CAAC;YACD,OAAO,GAAG,CAAC;QACb,CAAC,EAAE,EAAE,CAAC,CAAC;QAEP,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC,IAAI,EAAE,CAAC;QACjC,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;IACvB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}