illuma-agents 1.0.4 → 1.0.6

package/dist/types/messages/format.d.ts

@@ -1,4 +1,4 @@
-import { AIMessage, ToolMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
+import { AIMessage, ToolMessage, BaseMessage, HumanMessage, SystemMessage } from '@langchain/core/messages';
 import type { MessageContentImageUrl } from '@langchain/core/messages';
 import type { MessageContentComplex, TPayload } from '@/types';
 import { Providers } from '@/common';
@@ -83,6 +83,20 @@ interface LangChainMessage {
  * @returns - The formatted LangChain message.
  */
 export declare const formatFromLangChain: (message: LangChainMessage) => Record<string, any>;
+/**
+ * Groups content parts by agent and formats them with agent labels
+ * This preprocesses multi-agent content to prevent identity confusion
+ *
+ * @param contentParts - The content parts from a run
+ * @param agentIdMap - Map of content part index to agent ID
+ * @param agentNames - Optional map of agent ID to display name
+ * @param options - Configuration options
+ * @param options.labelNonTransferContent - If true, labels all agent transitions (for parallel patterns)
+ * @returns Modified content parts with agent labels where appropriate
+ */
+export declare const labelContentByAgent: (contentParts: MessageContentComplex[], agentIdMap?: Record<number, string>, agentNames?: Record<string, string>, options?: {
+    labelNonTransferContent?: boolean;
+}) => MessageContentComplex[];
 /**
  * Formats an array of messages for LangChain, handling tool calls and creating ToolMessage instances.
  *
@@ -104,4 +118,14 @@ export declare const formatAgentMessages: (payload: TPayload, indexTokenCountMap
  * @returns A new map with the system message at index 0 and all other indices shifted by 1
  */
 export declare function shiftIndexTokenCountMap(indexTokenCountMap: Record<number, number>, instructionsTokenCount: number): Record<number, number>;
+/**
+ * Ensures compatibility when switching from a non-thinking agent to a thinking-enabled agent.
+ * Converts AI messages with tool calls (that lack thinking blocks) into buffer strings,
+ * avoiding the thinking block signature requirement.
+ *
+ * @param messages - Array of messages to process
+ * @param provider - The provider being used (unused but kept for future compatibility)
+ * @returns The messages array with tool sequences converted to buffer strings if necessary
+ */
+export declare function ensureThinkingBlockInMessages(messages: BaseMessage[], _provider: Providers): BaseMessage[];
 export {};

package/dist/types/tools/handlers.d.ts

@@ -2,10 +2,11 @@ import type { ToolCall, ToolCallChunk } from '@langchain/core/messages/tool';
 import type { MultiAgentGraph, StandardGraph } from '@/graphs';
 import type { AgentContext } from '@/agents/AgentContext';
 import type * as t from '@/types';
-export declare function handleToolCallChunks({ graph, stepKey, toolCallChunks, }: {
+export declare function handleToolCallChunks({ graph, stepKey, toolCallChunks, metadata, }: {
     graph: StandardGraph | MultiAgentGraph;
     stepKey: string;
     toolCallChunks: ToolCallChunk[];
+    metadata?: Record<string, unknown>;
 }): Promise<void>;
 export declare const handleToolCalls: (toolCalls?: ToolCall[], metadata?: Record<string, unknown>, graph?: StandardGraph | MultiAgentGraph) => Promise<void>;
 export declare const toolResultTypes: Set<string>;

package/dist/types/types/stream.d.ts

@@ -37,6 +37,7 @@ export type RunStep = {
     type: StepTypes;
     id: string;
     runId?: string;
+    agentId?: string;
     index: number;
     stepIndex?: number;
     stepDetails: StepDetails;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "illuma-agents",
-  "version": "1.0.4",
+  "version": "1.0.6",
   "main": "./dist/cjs/main.cjs",
   "module": "./dist/esm/main.mjs",
   "types": "./dist/types/index.d.ts",
@@ -58,6 +58,9 @@
     "multi-agent-conditional": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-conditional.ts",
     "multi-agent-supervisor": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-supervisor.ts",
     "multi-agent-list-handoff": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-multi-agent-list-handoff.ts",
+    "test-parallel-agent-labeling": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-parallel-agent-labeling.ts",
+    "test-thinking-handoff": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-handoff.ts",
+    "test-thinking-handoff-bedrock": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-thinking-handoff-bedrock.ts",
     "multi-agent-hybrid-flow": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/multi-agent-hybrid-flow.ts",
     "test-handoff-input": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-handoff-input.ts",
     "test-custom-prompt-key": "node -r dotenv/config --loader ./tsconfig-paths-bootstrap.mjs --experimental-specifier-resolution=node ./src/scripts/test-custom-prompt-key.ts",

package/src/graphs/Graph.ts

@@ -38,6 +38,7 @@ import {
 } from '@/common';
 import {
   formatAnthropicArtifactContent,
+  ensureThinkingBlockInMessages,
   convertMessagesToContent,
   addBedrockCacheControl,
   modifyDeltaProperties,
@@ -96,7 +97,8 @@ export abstract class Graph<
   abstract getRunStep(stepId: string): t.RunStep | undefined;
   abstract dispatchRunStep(
     stepKey: string,
-    stepDetails: t.StepDetails
+    stepDetails: t.StepDetails,
+    metadata?: Record<string, unknown>
   ): Promise<string>;
   abstract dispatchRunStepDelta(
     id: string,
@@ -327,6 +329,66 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
     return convertMessagesToContent(this.messages.slice(this.startIndex));
   }
 
+  /**
+   * Get all run steps, optionally filtered by agent ID
+   */
+  getRunSteps(agentId?: string): t.RunStep[] {
+    if (agentId == null || agentId === '') {
+      return [...this.contentData];
+    }
+    return this.contentData.filter((step) => step.agentId === agentId);
+  }
+
+  /**
+   * Get run steps grouped by agent ID
+   */
+  getRunStepsByAgent(): Map<string, t.RunStep[]> {
+    const stepsByAgent = new Map<string, t.RunStep[]>();
+
+    for (const step of this.contentData) {
+      if (step.agentId == null || step.agentId === '') continue;
+
+      const steps = stepsByAgent.get(step.agentId) ?? [];
+      steps.push(step);
+      stepsByAgent.set(step.agentId, steps);
+    }
+
+    return stepsByAgent;
+  }
+
+  /**
+   * Get agent IDs that participated in this run
+   */
+  getActiveAgentIds(): string[] {
+    const agentIds = new Set<string>();
+    for (const step of this.contentData) {
+      if (step.agentId != null && step.agentId !== '') {
+        agentIds.add(step.agentId);
+      }
+    }
+    return Array.from(agentIds);
+  }
+
+  /**
+   * Maps contentPart indices to agent IDs for post-run analysis
+   * Returns a map where key is the contentPart index and value is the agentId
+   */
+  getContentPartAgentMap(): Map<number, string> {
+    const contentPartAgentMap = new Map<number, string>();
+
+    for (const step of this.contentData) {
+      if (
+        step.agentId != null &&
+        step.agentId !== '' &&
+        Number.isFinite(step.index)
+      ) {
+        contentPartAgentMap.set(step.index, step.agentId);
+      }
+    }
+
+    return contentPartAgentMap;
+  }
+
   /* Graph */
 
   createSystemRunnable({
@@ -672,6 +734,26 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
         }
       }
 
+      /**
+       * Handle edge case: when switching from a non-thinking agent to a thinking-enabled agent,
+       * convert AI messages with tool calls to HumanMessages to avoid thinking block requirements.
+       * This is required by Anthropic/Bedrock when thinking is enabled.
+       */
+      const isAnthropicWithThinking =
+        (agentContext.provider === Providers.ANTHROPIC &&
+          (agentContext.clientOptions as t.AnthropicClientOptions).thinking !=
+            null) ||
+        (agentContext.provider === Providers.BEDROCK &&
+          (agentContext.clientOptions as t.BedrockAnthropicInput)
+            .additionalModelRequestFields?.['thinking'] != null);
+
+      if (isAnthropicWithThinking) {
+        finalMessages = ensureThinkingBlockInMessages(
+          finalMessages,
+          agentContext.provider
+        );
+      }
+
       if (
         agentContext.lastStreamCall != null &&
         agentContext.streamBuffer != null
@@ -837,7 +919,8 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
    */
   async dispatchRunStep(
     stepKey: string,
-    stepDetails: t.StepDetails
+    stepDetails: t.StepDetails,
+    metadata?: Record<string, unknown>
   ): Promise<string> {
     if (!this.config) {
       throw new Error('No config provided');
@@ -868,6 +951,20 @@ export class StandardGraph extends Graph<t.BaseGraphState, t.GraphNode> {
       runStep.runId = runId;
     }
 
+    /**
+     * Extract and store agentId from metadata
+     */
+    if (metadata) {
+      try {
+        const agentContext = this.getAgentContext(metadata);
+        if (agentContext.agentId) {
+          runStep.agentId = agentContext.agentId;
+        }
+      } catch (_e) {
+        /** If we can't get agent context, that's okay - agentId remains undefined */
+      }
+    }
+
     this.contentData.push(runStep);
     this.contentIndexMap.set(stepId, runStep.index);
     await safeDispatchCustomEvent(