@illuma-ai/agents 1.0.89 → 1.0.93

package/dist/cjs/messages/format.cjs

@@ -162,6 +162,9 @@ function formatAssistantMessage(message) {
     let hasReasoning = false;
     if (Array.isArray(message.content)) {
         for (const part of message.content) {
+            if (part == null) {
+                continue;
+            }
             if (part.type === _enum.ContentTypes.TEXT && part.tool_call_ids) {
                 /*
                 If there's pending content, it needs to be aggregated as a single string to prepare for tool calls.
@@ -237,7 +240,10 @@ function formatAssistantMessage(message) {
                     content: processedOutput,
                 }));
             }
-            else if (part.type === _enum.ContentTypes.THINK) {
+            else if (part.type === _enum.ContentTypes.THINK ||
+                part.type === _enum.ContentTypes.THINKING ||
+                part.type === _enum.ContentTypes.REASONING_CONTENT ||
+                part.type === 'redacted_thinking') {
                 hasReasoning = true;
                 continue;
             }
@@ -246,6 +252,10 @@ function formatAssistantMessage(message) {
                 continue;
             }
             else {
+                if (part.type === _enum.ContentTypes.TEXT &&
+                    !String(part.text ?? '').trim()) {
+                    continue;
+                }
                 currentContent.push(part);
             }
         }
@@ -628,31 +638,79 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
         }
         indexMapping[i] = resultIndices;
     }
-    // Update the token count map if it was provided
     if (indexTokenCountMap) {
         for (let originalIndex = 0; originalIndex < payload.length; originalIndex++) {
             const resultIndices = indexMapping[originalIndex] || [];
             const tokenCount = indexTokenCountMap[originalIndex];
-            if (tokenCount !== undefined) {
-                if (resultIndices.length === 1) {
-                    // Simple 1:1 mapping
-                    updatedIndexTokenCountMap[resultIndices[0]] = tokenCount;
+            if (tokenCount === undefined) {
+                continue;
+            }
+            const msgCount = resultIndices.length;
+            if (msgCount === 1) {
+                updatedIndexTokenCountMap[resultIndices[0]] = tokenCount;
+                continue;
+            }
+            if (msgCount < 2) {
+                continue;
+            }
+            let totalLength = 0;
+            const lastIdx = msgCount - 1;
+            const lengths = new Array(msgCount);
+            for (let k = 0; k < msgCount; k++) {
+                const msg = messages[resultIndices[k]];
+                const { content } = msg;
+                let len = 0;
+                if (typeof content === 'string') {
+                    len = content.length;
                 }
-                else if (resultIndices.length > 1) {
-                    // If one message was split into multiple, distribute the token count
-                    // This is a simplification - in reality, you might want a more sophisticated distribution
-                    const countPerMessage = Math.floor(tokenCount / resultIndices.length);
-                    resultIndices.forEach((resultIndex, idx) => {
-                        if (idx === resultIndices.length - 1) {
-                            // Give any remainder to the last message
-                            updatedIndexTokenCountMap[resultIndex] =
-                                tokenCount - countPerMessage * (resultIndices.length - 1);
+                else if (Array.isArray(content)) {
+                    for (const part of content) {
+                        if (typeof part === 'string') {
+                            len += part.length;
                         }
-                        else {
-                            updatedIndexTokenCountMap[resultIndex] = countPerMessage;
+                        else if (part != null && typeof part === 'object') {
+                            const val = part.text ?? part.content;
+                            if (typeof val === 'string') {
+                                len += val.length;
+                            }
                         }
-                    });
+                    }
                 }
+                const toolCalls = msg.tool_calls;
+                if (Array.isArray(toolCalls)) {
+                    for (const tc of toolCalls) {
+                        if (typeof tc.name === 'string') {
+                            len += tc.name.length;
+                        }
+                        const { args } = tc;
+                        if (typeof args === 'string') {
+                            len += args.length;
+                        }
+                        else if (args != null) {
+                            len += JSON.stringify(args).length;
+                        }
+                    }
+                }
+                lengths[k] = len;
+                totalLength += len;
+            }
+            if (totalLength === 0) {
+                const countPerMessage = Math.floor(tokenCount / msgCount);
+                for (let k = 0; k < lastIdx; k++) {
+                    updatedIndexTokenCountMap[resultIndices[k]] = countPerMessage;
+                }
+                updatedIndexTokenCountMap[resultIndices[lastIdx]] =
+                    tokenCount - countPerMessage * lastIdx;
+            }
+            else {
+                let distributed = 0;
+                for (let k = 0; k < lastIdx; k++) {
+                    const share = Math.floor((lengths[k] / totalLength) * tokenCount);
+                    updatedIndexTokenCountMap[resultIndices[k]] = share;
+                    distributed += share;
+                }
+                updatedIndexTokenCountMap[resultIndices[lastIdx]] =
+                    tokenCount - distributed;
             }
         }
     }
@@ -682,6 +740,85 @@ function shiftIndexTokenCountMap(indexTokenCountMap, instructionsTokenCount) {
     }
     return shiftedMap;
 }
+/** Block types that contain binary image data and must be preserved structurally. */
+const IMAGE_BLOCK_TYPES = new Set(['image_url', 'image']);
+/** Checks whether a BaseMessage is a tool-role message. */
+const isToolMessage = (m) => m instanceof messages.ToolMessage || ('role' in m && m.role === 'tool');
+/** Flushes accumulated text chunks into `parts` as a single text block. */
+function flushTextChunks(textChunks, parts) {
+    if (textChunks.length === 0) {
+        return;
+    }
+    parts.push({
+        type: _enum.ContentTypes.TEXT,
+        text: textChunks.join('\n'),
+    });
+    textChunks.length = 0;
+}
+/**
+ * Appends a single message's content to the running `textChunks` / `parts`
+ * accumulators.  Image blocks are shallow-copied into `parts` as-is so that
+ * binary data (base64 images) never becomes text tokens.  All other block
+ * types are serialized to text — unrecognized types are JSON-serialized
+ * rather than silently dropped.
+ *
+ * When `content` is an array containing tool_use blocks, `tool_calls` is NOT
+ * additionally serialized (avoiding double output).  `tool_calls` is used as
+ * a fallback when `content` is a plain string or an array with no tool_use.
+ */
+function appendMessageContent(msg, role, textChunks, parts) {
+    const { content } = msg;
+    if (typeof content === 'string') {
+        if (content) {
+            textChunks.push(`${role}: ${content}`);
+        }
+        appendToolCalls(msg, role, textChunks);
+        return;
+    }
+    if (!Array.isArray(content)) {
+        appendToolCalls(msg, role, textChunks);
+        return;
+    }
+    let hasToolUseBlock = false;
+    for (const block of content) {
+        if (IMAGE_BLOCK_TYPES.has(block.type ?? '')) {
+            flushTextChunks(textChunks, parts);
+            parts.push({ ...block });
+            continue;
+        }
+        if (block.type === 'tool_use') {
+            hasToolUseBlock = true;
+            textChunks.push(`${role}: [tool_use] ${String(block.name ?? '')} ${JSON.stringify(block.input ?? {})}`);
+            continue;
+        }
+        const text = block.text ?? block.input;
+        if (typeof text === 'string' && text) {
+            textChunks.push(`${role}: ${text}`);
+            continue;
+        }
+        // Fallback: serialize unrecognized block types to preserve context
+        if (block.type != null && block.type !== '') {
+            textChunks.push(`${role}: [${block.type}] ${JSON.stringify(block)}`);
+        }
+    }
+    // If content array had no tool_use blocks, fall back to tool_calls metadata
+    // (handles edge case: empty content array with tool_calls populated)
+    if (!hasToolUseBlock) {
+        appendToolCalls(msg, role, textChunks);
+    }
+}
+function appendToolCalls(msg, role, textChunks) {
+    if (role !== 'AI') {
+        return;
+    }
+    const aiMsg = msg;
+    if (!aiMsg.tool_calls || aiMsg.tool_calls.length === 0) {
+        return;
+    }
+    for (const tc of aiMsg.tool_calls) {
+        textChunks.push(`AI: [tool_call] ${tc.name}(${JSON.stringify(tc.args)})`);
+    }
+}
 /**
  * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
  * Converts AI messages with tool calls (that lack thinking/reasoning blocks) into buffer strings,
@@ -698,11 +835,27 @@ function shiftIndexTokenCountMap(indexTokenCountMap, instructionsTokenCount) {
  * @returns The messages array with tool sequences converted to buffer strings if necessary
  */
 function ensureThinkingBlockInMessages(messages$1, _provider) {
+    if (messages$1.length === 0) {
+        return messages$1;
+    }
+    // If the last message is already a HumanMessage, there is no trailing tool
+    // sequence to convert — return early to preserve prompt caching and avoid
+    // redundant token overhead from re-processing the entire history.
+    const lastMsg = messages$1[messages$1.length - 1];
+    const lastIsHuman = lastMsg instanceof messages.HumanMessage ||
+        ('role' in lastMsg && lastMsg.role === 'user');
+    if (lastIsHuman) {
+        return messages$1;
+    }
     const result = [];
     let i = 0;
     while (i < messages$1.length) {
         const msg = messages$1[i];
-        const isAI = msg instanceof messages.AIMessage || msg instanceof messages.AIMessageChunk;
+        /** Detect AI messages by instanceof OR by role, in case cache-control cloning
+         produced a plain object that lost the LangChain prototype. */
+        const isAI = msg instanceof messages.AIMessage ||
+            msg instanceof messages.AIMessageChunk ||
+            ('role' in msg && msg.role === 'assistant');
         if (!isAI) {
             result.push(msg);
             i++;
@@ -713,38 +866,59 @@ function ensureThinkingBlockInMessages(messages$1, _provider) {
         const contentIsArray = Array.isArray(aiMsg.content);
         // Check if the message has tool calls or tool_use content
         let hasToolUse = hasToolCalls ?? false;
-        let firstContentType;
+        let hasThinkingBlock = false;
         if (contentIsArray && aiMsg.content.length > 0) {
-            const content = aiMsg.content;
-            firstContentType = content[0]?.type;
-            hasToolUse =
-                hasToolUse ||
-                    content.some((c) => typeof c === 'object' && c.type === 'tool_use');
-        }
-        // If message has tool use but no thinking block, convert to buffer string
-        if (hasToolUse &&
-            firstContentType !== _enum.ContentTypes.THINKING &&
-            firstContentType !== _enum.ContentTypes.REASONING_CONTENT &&
-            firstContentType !== _enum.ContentTypes.REASONING &&
-            firstContentType !== 'redacted_thinking') {
-            // Collect the AI message and any following tool messages
-            const toolSequence = [msg];
+            for (const c of aiMsg.content) {
+                if (typeof c !== 'object') {
+                    continue;
+                }
+                if (c.type === 'tool_use') {
+                    hasToolUse = true;
+                }
+                else if (c.type === _enum.ContentTypes.THINKING ||
+                    c.type === _enum.ContentTypes.REASONING_CONTENT ||
+                    c.type === _enum.ContentTypes.REASONING ||
+                    c.type === 'redacted_thinking') {
+                    hasThinkingBlock = true;
+                }
+                if (hasToolUse && hasThinkingBlock) {
+                    break;
+                }
+            }
+        }
+        // Bedrock also stores reasoning in additional_kwargs (may not be in content array)
+        if (!hasThinkingBlock &&
+            aiMsg.additional_kwargs.reasoning_content != null) {
+            hasThinkingBlock = true;
+        }
+        // If message has tool use but no thinking block, check whether this is a
+        // continuation of a thinking-enabled agent's chain before converting.
+        // Bedrock reasoning models can produce multiple AI→Tool rounds after an
+        // initial reasoning response: the first AI message has reasoning_content,
+        // but follow-ups have content: "" with only tool_calls. These are the
+        // same agent's turn and must NOT be converted to HumanMessages.
+        if (hasToolUse && !hasThinkingBlock) {
+            // Walk backwards — if an earlier AI message in the same chain (before
+            // the nearest HumanMessage) has a thinking/reasoning block, this is a
+            // continuation of a thinking-enabled turn, not a non-thinking handoff.
+            if (chainHasThinkingBlock(messages$1, i)) {
+                result.push(msg);
+                i++;
+                continue;
+            }
+            // Build structured content in a single pass over the AI + following
+            // ToolMessages — preserves image blocks as-is to avoid serializing
+            // binary data as text (which caused 174× token amplification).
+            const parts = [];
+            const textChunks = ['[Previous agent context]'];
+            appendMessageContent(msg, 'AI', textChunks, parts);
             let j = i + 1;
-            // Look ahead for tool messages that belong to this AI message
-            // Use getType() instead of instanceof to avoid module mismatch issues
-            // where different copies of ToolMessage class might be loaded
-            while (j < messages$1.length &&
-                messages$1[j].getType() === _enum.MessageTypes.TOOL) {
-                toolSequence.push(messages$1[j]);
+            while (j < messages$1.length && isToolMessage(messages$1[j])) {
+                appendMessageContent(messages$1[j], 'Tool', textChunks, parts);
                 j++;
             }
-            // Convert the sequence to a buffer string and wrap in a HumanMessage
-            // This avoids the thinking block requirement which only applies to AI messages
-            const bufferString = messages.getBufferString(toolSequence);
-            result.push(new messages.HumanMessage({
-                content: `[Previous agent context]\n${bufferString}`,
-            }));
-            // Skip the messages we've processed
+            flushTextChunks(textChunks, parts);
+            result.push(new messages.HumanMessage({ content: parts }));
             i = j;
         }
         else {
@@ -755,6 +929,50 @@ function ensureThinkingBlockInMessages(messages$1, _provider) {
     }
     return result;
 }
+/**
+ * Walks backwards from `currentIndex` through the message array to check
+ * whether an earlier AI message in the same "chain" (no HumanMessage boundary)
+ * contains a thinking/reasoning block.
+ *
+ * A "chain" is a contiguous sequence of AI + Tool messages with no intervening
+ * HumanMessage. Bedrock reasoning models produce reasoning on the first AI
+ * response, then issue follow-up tool calls with `content: ""` and no
+ * reasoning block. These follow-ups are part of the same thinking-enabled
+ * turn and should not be converted.
+ */
+function chainHasThinkingBlock(messages$1, currentIndex) {
+    for (let k = currentIndex - 1; k >= 0; k--) {
+        const prev = messages$1[k];
+        // HumanMessage = turn boundary — stop searching
+        if (prev instanceof messages.HumanMessage ||
+            ('role' in prev && prev.role === 'user')) {
+            return false;
+        }
+        // Check AI messages for thinking/reasoning blocks
+        const isPrevAI = prev instanceof messages.AIMessage ||
+            prev instanceof messages.AIMessageChunk ||
+            ('role' in prev && prev.role === 'assistant');
+        if (isPrevAI) {
+            const prevAiMsg = prev;
+            if (Array.isArray(prevAiMsg.content) && prevAiMsg.content.length > 0) {
+                const content = prevAiMsg.content;
+                if (content.some((c) => typeof c === 'object' &&
+                    (c.type === _enum.ContentTypes.THINKING ||
+                        c.type === _enum.ContentTypes.REASONING_CONTENT ||
+                        c.type === _enum.ContentTypes.REASONING ||
+                        c.type === 'redacted_thinking'))) {
+                    return true;
+                }
+            }
+            // Bedrock also stores reasoning in additional_kwargs
+            if (prevAiMsg.additional_kwargs.reasoning_content != null) {
+                return true;
+            }
+        }
+        // ToolMessages are part of the chain — keep walking back
+    }
+    return false;
+}
 
 exports.ensureThinkingBlockInMessages = ensureThinkingBlockInMessages;
 exports.formatAgentMessages = formatAgentMessages;