@illuma-ai/agents 1.1.22 → 1.1.24

package/src/graphs/Graph.ts

@@ -2031,6 +2031,7 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         );
       }
 
+
       // Get model info for analytics
       const bedrockOpts = agentContext.clientOptions as
         | t.BedrockAnthropicClientOptions

package/src/graphs/MultiAgentGraph.ts

@@ -678,6 +678,7 @@ export class MultiAgentGraph extends StandardGraph {
               ];
             }
 
+
             const childState: t.BaseGraphState = {
               messages: childMessages,
             };
@@ -688,6 +689,25 @@ export class MultiAgentGraph extends StandardGraph {
             );
 
             try {
+              /**
+               * Dispatch transition BEFORE invoking the child subgraph so that
+               * callbacks.js sets multiAgentTrace.isMultiAgent = true before the
+               * child's ON_RUN_STEP events fire.  This ensures child tool calls
+               * are attributed to the correct agent in admin traces.
+               */
+              await safeDispatchCustomEvent(
+                GraphEvents.ON_AGENT_TRANSITION,
+                {
+                  sourceAgentId: sourceAgentId,
+                  sourceAgentName: this.agentContexts.get(sourceAgentId)?.name ?? sourceAgentId,
+                  destinationAgentId: destination,
+                  destinationAgentName: destContext?.name ?? destination,
+                  edgeType: EdgeType.HANDOFF,
+                  timestamp: Date.now(),
+                },
+                config
+              );
+
               /**
                * Invoke the child subgraph with config propagation.
                * Config carries callbacks (for SSE streaming), abort signal,
@@ -710,19 +730,6 @@ export class MultiAgentGraph extends StandardGraph {
                   `${truncatedResult.length < resultText.length ? `, truncated to ${truncatedResult.length}` : ''})`
               );
 
-              await safeDispatchCustomEvent(
-                GraphEvents.ON_AGENT_TRANSITION,
-                {
-                  sourceAgentId: sourceAgentId,
-                  sourceAgentName: this.agentContexts.get(sourceAgentId)?.name ?? sourceAgentId,
-                  destinationAgentId: destination,
-                  destinationAgentName: destContext?.name ?? destination,
-                  edgeType: EdgeType.HANDOFF,
-                  timestamp: Date.now(),
-                },
-                config
-              );
-
               return truncatedResult;
             } catch (err) {
               const errorMessage =
@@ -970,6 +977,28 @@ export class MultiAgentGraph extends StandardGraph {
       }
     }
 
+    /**
+     * 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 HumanMessage(
+          `[Context from orchestrator]: ${content}`
+        );
+      } else {
+        cleaned.pop();
+      }
+    }
+
     return cleaned;
   }
 

package/src/graphs/__tests__/multi-agent-delegate.test.ts

@@ -215,20 +215,35 @@ describe('prepareHandoffMessages', () => {
     expect(MultiAgentGraph.prepareHandoffMessages([])).toEqual([]);
   });
 
-  it('passes through plain HumanMessage and text-only AIMessage unchanged', () => {
+  it('converts trailing AIMessage to HumanMessage context', () => {
     const messages: BaseMessage[] = [
       new HumanMessage('Hello'),
       new AIMessage('Hi there'),
     ];
     const result = MultiAgentGraph.prepareHandoffMessages(messages);
+    // Trailing AI converted to HumanMessage so conversation ends with user message
     expect(result).toHaveLength(2);
     expect(result[0].getType()).toBe('human');
     expect(result[0].content).toBe('Hello');
+    expect(result[1].getType()).toBe('human');
+    expect(result[1].content).toContain('Hi there');
+  });
+
+  it('preserves AI messages that are not trailing', () => {
+    const messages: BaseMessage[] = [
+      new HumanMessage('Hello'),
+      new AIMessage('Hi there'),
+      new HumanMessage('Follow up'),
+    ];
+    const result = MultiAgentGraph.prepareHandoffMessages(messages);
+    expect(result).toHaveLength(3);
+    expect(result[0].content).toBe('Hello');
     expect(result[1].getType()).toBe('ai');
     expect(result[1].content).toBe('Hi there');
+    expect(result[2].content).toBe('Follow up');
   });
 
-  it('strips orphaned tool_use blocks (no matching tool_result)', () => {
+  it('strips orphaned tool_use, converts trailing AI to context', () => {
     const messages: BaseMessage[] = [
       new HumanMessage('Do something'),
       new AIMessage({
@@ -242,12 +257,9 @@ describe('prepareHandoffMessages', () => {
     const result = MultiAgentGraph.prepareHandoffMessages(messages);
     expect(result).toHaveLength(2);
     expect(result[0].content).toBe('Do something');
-    // AI message should be converted to text-only (no tool_calls)
-    expect(result[1].getType()).toBe('ai');
+    // Trailing AI converted to HumanMessage context
+    expect(result[1].getType()).toBe('human');
     expect(result[1].content).toContain('Let me call a tool');
-    // Should NOT contain tool_calls
-    const aiMsg = result[1] as AIMessage;
-    expect(aiMsg.tool_calls ?? []).toHaveLength(0);
   });
 
   it('compacts paired tool_use/tool_result into text summaries', () => {
@@ -264,17 +276,20 @@ describe('prepareHandoffMessages', () => {
     ];
     const result = MultiAgentGraph.prepareHandoffMessages(messages);
 
-    // Should have: HumanMessage, compacted AIMessage (with tool summary), final AIMessage
+    // HumanMessage + compacted AI + trailing AI converted to HumanMessage
     expect(result).toHaveLength(3);
 
     // ToolMessage should be removed
     expect(result.every((m) => m.getType() !== 'tool')).toBe(true);
 
     // Compacted AI message should contain tool summary
-    const compactedAI = result[1];
-    expect(compactedAI.content).toContain('I will search for you');
-    expect(compactedAI.content).toContain('web_search');
-    expect(compactedAI.content).toContain('Found 3 results');
+    expect(result[1].content).toContain('I will search for you');
+    expect(result[1].content).toContain('web_search');
+    expect(result[1].content).toContain('Found 3 results');
+
+    // Trailing AI converted to HumanMessage
+    expect(result[2].getType()).toBe('human');
+    expect(result[2].content).toContain('Based on the search');
   });
 
   it('removes ALL ToolMessages from output', () => {
@@ -326,25 +341,20 @@ describe('prepareHandoffMessages', () => {
     // No ToolMessages
     expect(result.filter((m) => m.getType() === 'tool')).toHaveLength(0);
 
-    // No tool_calls on any AI message
-    for (const msg of result) {
-      if (msg.getType() === 'ai') {
-        expect((msg as AIMessage).tool_calls ?? []).toHaveLength(0);
-      }
-    }
-
-    // Should have: HumanMessage + 2 compacted/cleaned AI messages
+    // Should have: HumanMessage + compacted AI (with tool summary) + trailing AI converted to HumanMessage
     expect(result).toHaveLength(3);
 
     // First AI message should have researcher tool summary (paired)
+    expect(result[1].getType()).toBe('ai');
     expect(result[1].content).toContain('lc_handoff_to_researcher');
     expect(result[1].content).toContain('AI adoption');
 
-    // Second AI message should be text-only (orphaned tool_use stripped)
+    // Trailing AI converted to HumanMessage context
+    expect(result[2].getType()).toBe('human');
     expect(result[2].content).toContain('Now I will delegate to the writer');
   });
 
-  it('preserves message order', () => {
+  it('preserves message order, converts only trailing AI', () => {
     const messages: BaseMessage[] = [
       new HumanMessage('Step 1'),
       new AIMessage('Response 1'),
@@ -355,8 +365,10 @@ describe('prepareHandoffMessages', () => {
     expect(result).toHaveLength(4);
     expect(result[0].content).toBe('Step 1');
     expect(result[1].content).toBe('Response 1');
+    expect(result[1].getType()).toBe('ai'); // Not trailing — preserved as AI
     expect(result[2].content).toBe('Step 2');
-    expect(result[3].content).toBe('Response 2');
+    expect(result[3].getType()).toBe('human'); // Trailing — converted
+    expect(result[3].content).toContain('Response 2');
   });
 
   it('drops AI messages that have only tool_calls and no text content', () => {
@@ -390,10 +402,12 @@ describe('prepareHandoffMessages', () => {
       new ToolMessage({ content: 'tool output', tool_call_id: 'tc1', name: 'some_tool' }),
     ];
     const result = MultiAgentGraph.prepareHandoffMessages(messages);
+    // Compacted AI is trailing → converted to HumanMessage
     expect(result).toHaveLength(2);
-    const aiContent = result[1].content as string;
-    expect(aiContent).toContain('Part one.');
-    expect(aiContent).toContain('Part two.');
-    expect(aiContent).toContain('some_tool');
+    expect(result[1].getType()).toBe('human');
+    const content = result[1].content as string;
+    expect(content).toContain('Part one.');
+    expect(content).toContain('Part two.');
+    expect(content).toContain('some_tool');
   });
 });

package/src/utils/llm.ts

@@ -24,3 +24,4 @@ export function isGoogleLike(provider?: string | Providers): boolean {
     provider
   );
 }
+