@illuma-ai/agents 1.4.0-alpha.5 → 1.5.0

package/dist/cjs/messages/format.cjs

@@ -151,16 +151,69 @@ const formatFromLangChain = (message) => {
         ...additional_kwargs,
     };
 };
+function extractReasoningContent(part) {
+    if (part == null || typeof part !== 'object')
+        return '';
+    if (part.type === _enum.ContentTypes.THINK) {
+        const think = part.think;
+        return typeof think === 'string' ? think : '';
+    }
+    if (part.type === _enum.ContentTypes.THINKING) {
+        const thinking = part.thinking;
+        return typeof thinking === 'string' ? thinking : '';
+    }
+    if (part.type === _enum.ContentTypes.REASONING) {
+        const reasoning = part.reasoning;
+        return typeof reasoning === 'string' ? reasoning : '';
+    }
+    if (part.type === _enum.ContentTypes.REASONING_CONTENT) {
+        /* Bedrock/Google nested shape: { reasoningContent: { text: ... } } */
+        const nested = part
+            .reasoningContent;
+        if (nested && typeof nested.text === 'string')
+            return nested.text;
+    }
+    return '';
+}
 /**
  * Helper function to format an assistant message
  * @param message The message to format
+ * @param options Optional formatting options (e.g. DeepSeek reasoning roundtrip)
  * @returns Array of formatted messages
  */
-function formatAssistantMessage(message) {
+function formatAssistantMessage(message, options) {
     const formattedMessages = [];
     let currentContent = [];
     let lastAIMessage = null;
     let hasReasoning = false;
+    let pendingReasoningContent = '';
+    const shouldPreserveReasoningContent = options?.preserveReasoningContent === true;
+    const takePendingReasoningContent = () => {
+        if (!shouldPreserveReasoningContent || !pendingReasoningContent) {
+            return undefined;
+        }
+        const reasoningContent = pendingReasoningContent;
+        pendingReasoningContent = '';
+        return reasoningContent;
+    };
+    const createAIMessage = (content) => {
+        const reasoningContent = takePendingReasoningContent();
+        return new messages.AIMessage({
+            content,
+            ...(reasoningContent != null && {
+                additional_kwargs: { reasoning_content: reasoningContent },
+            }),
+        });
+    };
+    const attachPendingReasoningContent = (aiMessage) => {
+        const reasoningContent = takePendingReasoningContent();
+        if (reasoningContent == null)
+            return;
+        aiMessage.additional_kwargs.reasoning_content =
+            typeof aiMessage.additional_kwargs.reasoning_content === 'string'
+                ? `${aiMessage.additional_kwargs.reasoning_content}${reasoningContent}`
+                : reasoningContent;
+    };
     if (Array.isArray(message.content)) {
         for (const part of message.content) {
             if (part == null) {
@@ -180,15 +233,13 @@ function formatAssistantMessage(message) {
                     }, '');
                     content =
                         `${content}\n${part[_enum.ContentTypes.TEXT] ?? part.text ?? ''}`.trim();
-                    lastAIMessage = new messages.AIMessage({ content });
+                    lastAIMessage = createAIMessage(content);
                     formattedMessages.push(lastAIMessage);
                     currentContent = [];
                     continue;
                 }
                 // Create a new AIMessage with this text and prepare for tool calls
-                lastAIMessage = new messages.AIMessage({
-                    content: part.text != null ? part.text : '',
-                });
+                lastAIMessage = createAIMessage(part.text != null ? part.text : '');
                 formattedMessages.push(lastAIMessage);
             }
             else if (part.type === _enum.ContentTypes.TOOL_CALL) {
@@ -205,9 +256,12 @@ function formatAssistantMessage(message) {
                 }
                 if (!lastAIMessage) {
                     // "Heal" the payload by creating an AIMessage to precede the tool call
-                    lastAIMessage = new messages.AIMessage({ content: '' });
+                    lastAIMessage = createAIMessage('');
                     formattedMessages.push(lastAIMessage);
                 }
+                else {
+                    attachPendingReasoningContent(lastAIMessage);
+                }
                 const tool_call = _tool_call;
                 // TODO: investigate; args as dictionary may need to be providers-or-tool-specific
                 let args = _args;
@@ -243,9 +297,11 @@ function formatAssistantMessage(message) {
             }
             else if (part.type === _enum.ContentTypes.THINK ||
                 part.type === _enum.ContentTypes.THINKING ||
+                part.type === _enum.ContentTypes.REASONING ||
                 part.type === _enum.ContentTypes.REASONING_CONTENT ||
                 part.type === 'redacted_thinking') {
                 hasReasoning = true;
+                pendingReasoningContent += extractReasoningContent(part);
                 continue;
             }
             else if (part.type === _enum.ContentTypes.ERROR ||
@@ -271,11 +327,11 @@ function formatAssistantMessage(message) {
         }, '')
             .trim();
         if (content) {
-            formattedMessages.push(new messages.AIMessage({ content }));
+            formattedMessages.push(createAIMessage(content));
         }
     }
     else if (currentContent.length > 0) {
-        formattedMessages.push(new messages.AIMessage({ content: currentContent }));
+        formattedMessages.push(createAIMessage(currentContent));
     }
     return formattedMessages;
 }
@@ -483,16 +539,38 @@ function extractToolNamesFromSearchOutput(output) {
     }
     return [];
 }
+/** Extracts the skillName from a skill tool_call's args (string or object). */
+function extractSkillName(args) {
+    let parsed;
+    if (typeof args === 'string') {
+        try {
+            parsed = JSON.parse(args);
+        }
+        catch {
+            /* malformed args — skip */
+        }
+    }
+    else {
+        parsed = args;
+    }
+    const name = parsed?.skillName;
+    return typeof name === 'string' && name !== '' ? name : undefined;
+}
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
  * @param payload - The array of messages to format.
  * @param indexTokenCountMap - Optional map of message indices to token counts.
  * @param tools - Optional set of tool names that are allowed in the request.
+ * @param skills - Optional map of skill name to body for reconstructing skill HumanMessages.
+ *   When SkillTool is invoked, the body is injected as a HumanMessage into LangGraph state
+ *   but NOT persisted to conversation history. On follow-up runs the skill body is lost.
+ *   Pass `skills` to reconstruct the HumanMessage at the right position after each skill
+ *   ToolMessage. Upstream PRs #96 / #97.
  * @returns - Object containing formatted messages and updated indexTokenCountMap if provided.
  */
-const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
-    const messages = [];
+const formatAgentMessages = (payload, indexTokenCountMap, tools, skills, options) => {
+    const messages$1 = [];
     // If indexTokenCountMap is provided, create a new map to track the updated indices
     const updatedIndexTokenCountMap = {};
     // Keep track of the mapping from original payload indices to result indices
@@ -514,16 +592,16 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
             ];
         }
         if (message.role !== 'assistant') {
-            messages.push(formatMessage({
+            messages$1.push(formatMessage({
                 message: message,
                 langChain: true,
             }));
             // Update the index mapping for this message
-            indexMapping[i] = [messages.length - 1];
+            indexMapping[i] = [messages$1.length - 1];
             continue;
         }
         // For assistant messages, track the starting index before processing
-        const startMessageIndex = messages.length;
+        const startMessageIndex = messages$1.length;
         /**
          * If tools set is provided, process tool_calls:
          * - Keep valid tool_calls (tools in the set or dynamically discovered)
@@ -531,6 +609,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
          * - Dynamically expand the set when tool_search results are encountered
          */
         let processedMessage = message;
+        let pendingSkillNames;
         if (discoveredTools) {
             const content = message.content;
             if (content && Array.isArray(content)) {
@@ -568,6 +647,16 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
                     if (discoveredTools.has(toolName)) {
                         /** Valid tool - keep it */
                         filteredContent.push(part);
+                        // Skill body reconstruction (upstream PRs #96/#97): when a
+                        // SkillTool tool_call is present in this assistant turn, mark
+                        // the skill name so we can reconstruct the body HumanMessage
+                        // after the assistant turn has been pushed.
+                        if (toolName === _enum.Constants.SKILL_TOOL && skills?.size) {
+                            const skillName = extractSkillName(part.tool_call.args);
+                            if (skillName) {
+                                (pendingSkillNames ??= new Set()).add(skillName);
+                            }
+                        }
                     }
                     else {
                         /** Invalid tool - convert to string for context preservation */
@@ -627,12 +716,47 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
                 }
             }
         }
+        // When tools filtering is off, still detect skill tool_calls for body reconstruction.
+        if (!discoveredTools && skills?.size) {
+            const content = processedMessage.content;
+            if (Array.isArray(content)) {
+                for (const part of content) {
+                    if (part.type !== _enum.ContentTypes.TOOL_CALL ||
+                        part.tool_call?.name !== _enum.Constants.SKILL_TOOL) {
+                        continue;
+                    }
+                    const skillName = extractSkillName(part.tool_call.args);
+                    if (skillName) {
+                        (pendingSkillNames ??= new Set()).add(skillName);
+                    }
+                }
+            }
+        }
         // Process the assistant message using the helper function
-        const formattedMessages = formatAssistantMessage(processedMessage);
-        messages.push(...formattedMessages);
-        // Update the index mapping for this assistant message
-        // Store all indices that were created from this original message
-        const endMessageIndex = messages.length;
+        const formattedMessages = formatAssistantMessage(processedMessage, {
+            preserveReasoningContent: options?.provider === _enum.Providers.DEEPSEEK,
+        });
+        messages$1.push(...formattedMessages);
+        // Capture index range BEFORE skill body injection so injected
+        // HumanMessages are excluded from the assistant's token distribution
+        // (upstream PR #97 fix).
+        const endMessageIndex = messages$1.length;
+        if (pendingSkillNames?.size) {
+            for (const skillName of pendingSkillNames) {
+                const body = skills?.get(skillName);
+                if (body) {
+                    messages$1.push(new messages.HumanMessage({
+                        content: body,
+                        additional_kwargs: {
+                            role: 'user',
+                            isMeta: true,
+                            source: 'skill',
+                            skillName,
+                        },
+                    }));
+                }
+            }
+        }
         const resultIndices = [];
         for (let j = startMessageIndex; j < endMessageIndex; j++) {
             resultIndices.push(j);
@@ -658,7 +782,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
             const lastIdx = msgCount - 1;
             const lengths = new Array(msgCount);
             for (let k = 0; k < msgCount; k++) {
-                const msg = messages[resultIndices[k]];
+                const msg = messages$1[resultIndices[k]];
                 const { content } = msg;
                 let len = 0;
                 if (typeof content === 'string') {
@@ -716,7 +840,7 @@ const formatAgentMessages = (payload, indexTokenCountMap, tools) => {
         }
     }
     return {
-        messages,
+        messages: messages$1,
         indexTokenCountMap: indexTokenCountMap
             ? updatedIndexTokenCountMap
             : undefined,