illuma-agents 1.0.7 → 1.0.9

package/src/tools/ToolNode.ts

@@ -1,10 +1,17 @@
+import { ToolCall } from '@langchain/core/messages/tool';
+import {
+  ToolMessage,
+  isAIMessage,
+  isBaseMessage,
+} from '@langchain/core/messages';
 import {
   END,
-  MessagesAnnotation,
+  Send,
+  Command,
   isCommand,
   isGraphInterrupt,
+  MessagesAnnotation,
 } from '@langchain/langgraph';
-import { ToolMessage, isBaseMessage } from '@langchain/core/messages';
 import type {
   RunnableConfig,
   RunnableToolLike,
@@ -14,12 +21,20 @@ import type { StructuredToolInterface } from '@langchain/core/tools';
 import type * as t from '@/types';
 import { RunnableCallable } from '@/utils';
 
+/**
+ * Helper to check if a value is a Send object
+ */
+function isSend(value: unknown): value is Send {
+  return value instanceof Send;
+}
+
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export class ToolNode<T = any> extends RunnableCallable<T, T> {
   tools: t.GenericTool[];
   private toolMap: Map<string, StructuredToolInterface | RunnableToolLike>;
   private loadRuntimeTools?: t.ToolRefGenerator;
   handleToolErrors = true;
+  trace = false;
   toolCallStepIds?: Map<string, string>;
   errorHandler?: t.ToolNodeConstructorParams['errorHandler'];
   private toolUsageCount: Map<string, number>;
@@ -52,60 +67,50 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
     return new Map(this.toolUsageCount); // Return a copy
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  protected async run(input: any, config: RunnableConfig): Promise<T> {
-    const message = Array.isArray(input)
-      ? input[input.length - 1]
-      : input.messages[input.messages.length - 1];
-
-    if (message._getType() !== 'ai') {
-      throw new Error('ToolNode only accepts AIMessages as input.');
-    }
-
-    if (this.loadRuntimeTools) {
-      const { tools, toolMap } = this.loadRuntimeTools(
-        (message as AIMessage).tool_calls ?? []
+  /**
+   * Runs a single tool call with error handling
+   */
+  protected async runTool(
+    call: ToolCall,
+    config: RunnableConfig
+  ): Promise<BaseMessage | Command> {
+    const tool = this.toolMap.get(call.name);
+    try {
+      if (tool === undefined) {
+        throw new Error(`Tool "${call.name}" not found.`);
+      }
+      const turn = this.toolUsageCount.get(call.name) ?? 0;
+      this.toolUsageCount.set(call.name, turn + 1);
+      const args = call.args;
+      const stepId = this.toolCallStepIds?.get(call.id!);
+      const output = await tool.invoke(
+        { ...call, args, type: 'tool_call', stepId, turn },
+        config
       );
-      this.tools = tools;
-      this.toolMap = toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
-    }
-    const outputs = await Promise.all(
-      (message as AIMessage).tool_calls?.map(async (call) => {
-        const tool = this.toolMap.get(call.name);
+      if (
+        (isBaseMessage(output) && output._getType() === 'tool') ||
+        isCommand(output)
+      ) {
+        return output;
+      } else {
+        return new ToolMessage({
+          status: 'success',
+          name: tool.name,
+          content: typeof output === 'string' ? output : JSON.stringify(output),
+          tool_call_id: call.id!,
+        });
+      }
+    } catch (_e: unknown) {
+      const e = _e as Error;
+      if (!this.handleToolErrors) {
+        throw e;
+      }
+      if (isGraphInterrupt(e)) {
+        throw e;
+      }
+      if (this.errorHandler) {
         try {
-          if (tool === undefined) {
-            throw new Error(`Tool "${call.name}" not found.`);
-          }
-          const turn = this.toolUsageCount.get(call.name) ?? 0;
-          this.toolUsageCount.set(call.name, turn + 1);
-          const args = call.args;
-          const stepId = this.toolCallStepIds?.get(call.id!);
-          const output = await tool.invoke(
-            { ...call, args, type: 'tool_call', stepId, turn },
-            config
-          );
-          if (
-            (isBaseMessage(output) && output._getType() === 'tool') ||
-            isCommand(output)
-          ) {
-            return output;
-          } else {
-            return new ToolMessage({
-              name: tool.name,
-              content:
-                typeof output === 'string' ? output : JSON.stringify(output),
-              tool_call_id: call.id!,
-            });
-          }
-        } catch (_e: unknown) {
-          const e = _e as Error;
-          if (!this.handleToolErrors) {
-            throw e;
-          }
-          if (isGraphInterrupt(e)) {
-            throw e;
-          }
-          this.errorHandler?.(
+          await this.errorHandler(
             {
               error: e,
               id: call.id!,
@@ -114,27 +119,164 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
             },
             config.metadata
           );
-          return new ToolMessage({
-            content: `Error: ${e.message}\n Please fix your mistakes.`,
-            name: call.name,
-            tool_call_id: call.id ?? '',
+        } catch (handlerError) {
+          // eslint-disable-next-line no-console
+          console.error('Error in errorHandler:', {
+            toolName: call.name,
+            toolCallId: call.id,
+            toolArgs: call.args,
+            stepId: this.toolCallStepIds?.get(call.id!),
+            turn: this.toolUsageCount.get(call.name),
+            originalError: {
+              message: e.message,
+              stack: e.stack ?? undefined,
+            },
+            handlerError:
+              handlerError instanceof Error
+                ? {
+                  message: handlerError.message,
+                  stack: handlerError.stack ?? undefined,
+                }
+                : {
+                  message: String(handlerError),
+                  stack: undefined,
+                },
           });
         }
-      }) ?? []
-    );
+      }
+      return new ToolMessage({
+        status: 'error',
+        content: `Error: ${e.message}\n Please fix your mistakes.`,
+        name: call.name,
+        tool_call_id: call.id ?? '',
+      });
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  protected async run(input: any, config: RunnableConfig): Promise<T> {
+    let outputs: (BaseMessage | Command)[];
+
+    if (this.isSendInput(input)) {
+      outputs = [await this.runTool(input.lg_tool_call, config)];
+    } else {
+      let messages: BaseMessage[];
+      if (Array.isArray(input)) {
+        messages = input;
+      } else if (this.isMessagesState(input)) {
+        messages = input.messages;
+      } else {
+        throw new Error(
+          'ToolNode only accepts BaseMessage[] or { messages: BaseMessage[] } as input.'
+        );
+      }
+
+      const toolMessageIds: Set<string> = new Set(
+        messages
+          .filter((msg) => msg._getType() === 'tool')
+          .map((msg) => (msg as ToolMessage).tool_call_id)
+      );
+
+      let aiMessage: AIMessage | undefined;
+      for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (isAIMessage(message)) {
+          aiMessage = message;
+          break;
+        }
+      }
+
+      if (aiMessage == null || !isAIMessage(aiMessage)) {
+        throw new Error('ToolNode only accepts AIMessages as input.');
+      }
+
+      if (this.loadRuntimeTools) {
+        const { tools, toolMap } = this.loadRuntimeTools(
+          aiMessage.tool_calls ?? []
+        );
+        this.tools = tools;
+        this.toolMap =
+          toolMap ?? new Map(tools.map((tool) => [tool.name, tool]));
+      }
+
+      outputs = await Promise.all(
+        aiMessage.tool_calls
+          ?.filter((call) => {
+            /**
+             * Filter out:
+             * 1. Already processed tool calls (present in toolMessageIds)
+             * 2. Server tool calls (e.g., web_search with IDs starting with 'srvtoolu_')
+             *    which are executed by the provider's API and don't require invocation
+             */
+            return (
+              (call.id == null || !toolMessageIds.has(call.id)) &&
+              !(call.id?.startsWith('srvtoolu_') ?? false)
+            );
+          })
+          .map((call) => this.runTool(call, config)) ?? []
+      );
+    }
 
     if (!outputs.some(isCommand)) {
       return (Array.isArray(input) ? outputs : { messages: outputs }) as T;
     }
 
-    const combinedOutputs = outputs.map((output) => {
+    const combinedOutputs: (
+      | { messages: BaseMessage[] }
+      | BaseMessage[]
+      | Command
+    )[] = [];
+    let parentCommand: Command | null = null;
+
+    for (const output of outputs) {
       if (isCommand(output)) {
-        return output;
+        if (
+          output.graph === Command.PARENT &&
+          Array.isArray(output.goto) &&
+          output.goto.every((send): send is Send => isSend(send))
+        ) {
+          if (parentCommand) {
+            (parentCommand.goto as Send[]).push(...(output.goto as Send[]));
+          } else {
+            parentCommand = new Command({
+              graph: Command.PARENT,
+              goto: output.goto,
+            });
+          }
+        } else {
+          combinedOutputs.push(output);
+        }
+      } else {
+        combinedOutputs.push(
+          Array.isArray(input) ? [output] : { messages: [output] }
+        );
       }
-      return Array.isArray(input) ? [output] : { messages: [output] };
-    });
+    }
+
+    if (parentCommand) {
+      combinedOutputs.push(parentCommand);
+    }
+
     return combinedOutputs as T;
   }
+
+  private isSendInput(input: unknown): input is { lg_tool_call: ToolCall } {
+    return (
+      typeof input === 'object' && input != null && 'lg_tool_call' in input
+    );
+  }
+
+  private isMessagesState(
+    input: unknown
+  ): input is { messages: BaseMessage[] } {
+    return (
+      typeof input === 'object' &&
+      input != null &&
+      'messages' in input &&
+      Array.isArray((input as { messages: unknown }).messages) &&
+      (input as { messages: unknown[] }).messages.every(isBaseMessage)
+    );
+  }
 }
 
 function areToolCallsInvoked(

package/src/tools/handlers.ts

@@ -9,7 +9,6 @@ import type { AgentContext } from '@/agents/AgentContext';
 import type * as t from '@/types';
 import {
   ToolCallTypes,
-  ContentTypes,
   GraphEvents,
   StepTypes,
   Providers,
@@ -87,22 +86,33 @@ export async function handleToolCallChunks({
   const alreadyDispatched =
     prevRunStep?.type === StepTypes.MESSAGE_CREATION &&
     graph.messageStepHasToolCalls.has(prevStepId);
-  if (!alreadyDispatched && tool_calls?.length === toolCallChunks.length) {
-    await graph.dispatchMessageDelta(prevStepId, {
-      content: [
-        {
-          type: ContentTypes.TEXT,
-          text: '',
-          tool_call_ids: tool_calls.map((tc) => tc.id ?? ''),
-        },
-      ],
-    });
+
+  if (prevRunStep?.type === StepTypes.TOOL_CALLS) {
+    /**
+     * If previous step is already a tool_calls step, use that step ID
+     * This ensures tool call deltas are dispatched to the correct step
+     */
+    stepId = prevStepId;
+  } else if (
+    !alreadyDispatched &&
+    prevRunStep?.type === StepTypes.MESSAGE_CREATION
+  ) {
+    /**
+     * Create tool_calls step as soon as we receive the first tool call chunk
+     * This ensures deltas are always associated with the correct step
+     *
+     * NOTE: We do NOT dispatch an empty text block here because:
+     * - Empty text blocks cause providers (Anthropic, Bedrock) to reject messages
+     * - The tool_calls themselves are sufficient for the step
+     * - Empty content with tool_call_ids gets stored in conversation history
+     *   and causes "messages must have non-empty content" errors on replay
+     */
     graph.messageStepHasToolCalls.set(prevStepId, true);
     stepId = await graph.dispatchRunStep(
       stepKey,
       {
         type: StepTypes.TOOL_CALLS,
-        tool_calls,
+        tool_calls: tool_calls ?? [],
       },
       metadata
     );
@@ -149,26 +159,21 @@ export const handleToolCalls = async (
       // no previous step
     }
 
-    const dispatchToolCallIds = async (
-      lastMessageStepId: string
-    ): Promise<void> => {
-      await graph.dispatchMessageDelta(lastMessageStepId, {
-        content: [
-          {
-            type: 'text',
-            text: '',
-            tool_call_ids: [toolCallId],
-          },
-        ],
-      });
-    };
+    /**
+     * NOTE: We do NOT dispatch empty text blocks with tool_call_ids because:
+     * - Empty text blocks cause providers (Anthropic, Bedrock) to reject messages
+     * - They get stored in conversation history and cause errors on replay:
+     *   "messages must have non-empty content" (Anthropic)
+     *   "The content field in the Message object is empty" (Bedrock)
+     * - The tool_calls themselves are sufficient
+     */
+
     /* If the previous step exists and is a message creation */
     if (
       prevStepId &&
       prevRunStep &&
       prevRunStep.type === StepTypes.MESSAGE_CREATION
     ) {
-      await dispatchToolCallIds(prevStepId);
       graph.messageStepHasToolCalls.set(prevStepId, true);
       /* If the previous step doesn't exist or is not a message creation */
     } else if (
@@ -186,8 +191,7 @@ export const handleToolCalls = async (
         },
         metadata
       );
-      await dispatchToolCallIds(stepId);
-      graph.messageStepHasToolCalls.set(prevStepId, true);
+      graph.messageStepHasToolCalls.set(stepId, true);
     }
 
     await graph.dispatchRunStep(

package/src/tools/search/anthropic.ts

@@ -1,51 +1,51 @@
-import type {
-  AnthropicTextBlockParam,
-  AnthropicWebSearchResultBlockParam,
-} from '@/llm/anthropic/types';
-import type { SearchResultData, ProcessedOrganic } from './types';
-import { getAttribution } from './utils';
-
-/**
- * Coerces Anthropic web search results to the SearchResultData format
- * @param results - Array of Anthropic web search results
- * @param turn - The turn number to associate with these results
- * @returns SearchResultData with minimal ProcessedOrganic items
- */
-export function coerceAnthropicSearchResults({
-  results,
-  turn = 0,
-}: {
-  results: (AnthropicTextBlockParam | AnthropicWebSearchResultBlockParam)[];
-  turn?: number;
-}): SearchResultData {
-  const organic: ProcessedOrganic[] = results
-    .filter((result) => result.type === 'web_search_result')
-    .map((result, index) => ({
-      link: result.url,
-      position: index + 1,
-      title: result.title,
-      date: result.page_age ?? undefined,
-      attribution: getAttribution(result.url),
-    }));
-
-  return {
-    turn,
-    organic,
-  };
-}
-
-/**
- * Helper function to check if an object is an Anthropic web search result
- */
-export function isAnthropicWebSearchResult(
-  obj: unknown
-): obj is AnthropicWebSearchResultBlockParam {
-  return (
-    typeof obj === 'object' &&
-    obj !== null &&
-    'type' in obj &&
-    obj.type === 'web_search_result' &&
-    'url' in obj &&
-    typeof (obj as Record<string, unknown>).url === 'string'
-  );
-}
+import type {
+  AnthropicTextBlockParam,
+  AnthropicWebSearchResultBlockParam,
+} from '@/llm/anthropic/types';
+import type { SearchResultData, ProcessedOrganic } from './types';
+import { getAttribution } from './utils';
+
+/**
+ * Coerces Anthropic web search results to the SearchResultData format
+ * @param results - Array of Anthropic web search results
+ * @param turn - The turn number to associate with these results
+ * @returns SearchResultData with minimal ProcessedOrganic items
+ */
+export function coerceAnthropicSearchResults({
+  results,
+  turn = 0,
+}: {
+  results: (AnthropicTextBlockParam | AnthropicWebSearchResultBlockParam)[];
+  turn?: number;
+}): SearchResultData {
+  const organic: ProcessedOrganic[] = results
+    .filter((result) => result.type === 'web_search_result')
+    .map((result, index) => ({
+      link: result.url,
+      position: index + 1,
+      title: result.title,
+      date: result.page_age ?? undefined,
+      attribution: getAttribution(result.url),
+    }));
+
+  return {
+    turn,
+    organic,
+  };
+}
+
+/**
+ * Helper function to check if an object is an Anthropic web search result
+ */
+export function isAnthropicWebSearchResult(
+  obj: unknown
+): obj is AnthropicWebSearchResultBlockParam {
+  return (
+    typeof obj === 'object' &&
+    obj !== null &&
+    'type' in obj &&
+    obj.type === 'web_search_result' &&
+    'url' in obj &&
+    typeof (obj as Record<string, unknown>).url === 'string'
+  );
+}