@illuma-ai/agents 1.1.21 → 1.1.23

package/dist/cjs/graphs/MultiAgentGraph.cjs

@@ -536,7 +536,7 @@ class MultiAgentGraph extends Graph.StandardGraph {
                         'This is a bug: createWorkflow() should have populated the subgraph registry.');
                 }
                 const state = langgraph.getCurrentTaskInput();
-                let childMessages = [...state.messages];
+                let childMessages = MultiAgentGraph.prepareHandoffMessages([...state.messages]);
                 /** Inject instructions as HumanMessage if provided by the parent LLM */
                 if (hasPromptInput &&
                     promptKey in input &&
@@ -684,6 +684,110 @@ class MultiAgentGraph extends Graph.StandardGraph {
      * @param agentId - The agent ID to check for handoff reception
      * @returns Object with filtered messages, extracted instructions, source agent, and parallel siblings
      */
+    /**
+     * Prepare messages for a handoff child agent.
+     *
+     * Handles two problems:
+     * 1. **Orphaned tool_use**: The parent's AI message contains a `tool_use` block
+     *    for the handoff tool itself, with no matching `tool_result`. Providers
+     *    (Bedrock/Anthropic) reject this.
+     * 2. **Paired tool_use/tool_result in history**: The child may not have the same
+     *    tools as the parent. Bedrock requires `toolConfig` when tool_use/tool_result
+     *    blocks exist in the message history. Compacting these into text summaries
+     *    avoids the requirement and reduces context bloat.
+     *
+     * Strategy:
+     * - Remove orphaned tool_use blocks (no matching tool_result)
+     * - Compact paired tool_use/tool_result interactions into text summaries
+     */
+    static prepareHandoffMessages(messages$1) {
+        if (messages$1.length === 0)
+            return messages$1;
+        /** Collect all tool_result IDs so we know which tool_use blocks are paired */
+        const pairedToolCallIds = new Set();
+        for (const msg of messages$1) {
+            if (msg.getType() === 'tool') {
+                const tm = msg;
+                if (tm.tool_call_id) {
+                    pairedToolCallIds.add(tm.tool_call_id);
+                }
+            }
+        }
+        /**
+         * Pass 1: Remove orphaned tool_use blocks (no matching tool_result).
+         * Also skip ToolMessages since we'll compact paired ones in pass 2.
+         */
+        const cleaned = [];
+        for (const msg of messages$1) {
+            /** Skip all ToolMessages — paired ones will be compacted in pass 2 */
+            if (msg.getType() === 'tool') {
+                continue;
+            }
+            if (msg.getType() !== 'ai') {
+                cleaned.push(msg);
+                continue;
+            }
+            const aiMsg = msg;
+            const toolCalls = aiMsg.tool_calls ?? [];
+            if (toolCalls.length === 0) {
+                cleaned.push(msg);
+                continue;
+            }
+            /** Extract text content from the AI message */
+            const textContent = typeof aiMsg.content === 'string'
+                ? aiMsg.content
+                : Array.isArray(aiMsg.content)
+                    ? aiMsg.content
+                        .filter((b) => b.type === 'text' && 'text' in b)
+                        .map((b) => b.text ?? '')
+                        .join('\n')
+                    : '';
+            /** Build text summaries of paired tool calls */
+            const toolSummaries = [];
+            for (const tc of toolCalls) {
+                if (tc.id != null && pairedToolCallIds.has(tc.id)) {
+                    /** Find the matching ToolMessage result */
+                    const toolResult = messages$1.find((m) => m.getType() === 'tool' && m.tool_call_id === tc.id);
+                    const resultContent = toolResult
+                        ? typeof toolResult.content === 'string'
+                            ? toolResult.content.slice(0, 500)
+                            : '[complex result]'
+                        : '[no result]';
+                    toolSummaries.push(`[Tool "${tc.name}": ${resultContent}]`);
+                }
+                // Orphaned tool_use blocks (no matching result) are silently dropped
+            }
+            /** Reconstruct as plain text AI message (no tool_calls) */
+            const parts = [textContent, ...toolSummaries].filter(Boolean);
+            if (parts.length > 0) {
+                cleaned.push(new messages.AIMessage({
+                    content: parts.join('\n\n'),
+                    id: aiMsg.id,
+                }));
+            }
+        }
+        /**
+         * Ensure messages end with a HumanMessage.
+         * After stripping tool artifacts, the last message may be an AIMessage
+         * (orchestrator's reasoning before the handoff). Some providers (Bedrock,
+         * Google/VertexAI) reject conversations ending with an assistant message.
+         * Convert the trailing AIMessage to a HumanMessage to preserve any useful
+         * context (e.g., compacted tool summaries) while satisfying the API requirement.
+         */
+        if (cleaned.length > 0 && cleaned[cleaned.length - 1].getType() === 'ai') {
+            const lastAI = cleaned[cleaned.length - 1];
+            const content = typeof lastAI.content === 'string'
+                ? lastAI.content
+                : '';
+            if (content.trim()) {
+                cleaned[cleaned.length - 1] = new messages.HumanMessage(`[Context from orchestrator]: ${content}`);
+            }
+            else {
+                cleaned.pop();
+            }
+        }
+        return cleaned;
+    }
     processTransferReception(messages$1, agentId) {
         if (messages$1.length === 0)
             return null;