illuma-agents 1.0.8 → 1.0.10

package/src/stream.ts

@@ -107,6 +107,25 @@ export function getChunkContent({
         | undefined
     )?.summary?.[0]?.text;
   }
+  if (
+    provider === Providers.OPENROUTER &&
+    chunk?.additional_kwargs?.reasoning_details != null &&
+    Array.isArray(chunk.additional_kwargs.reasoning_details)
+  ) {
+    // Extract text from reasoning_details array (for Gemini, DeepSeek, etc.)
+    const textEntries = chunk.additional_kwargs.reasoning_details
+      .filter(
+        (detail) =>
+          detail.type === 'reasoning.text' &&
+          detail.text != null &&
+          detail.text !== ''
+      )
+      .map((detail) => detail.text)
+      .join('');
+    if (textEntries) {
+      return textEntries;
+    }
+  }
   return (
     ((chunk?.additional_kwargs?.[reasoningKey] as string | undefined) ?? '') ||
     chunk?.content
@@ -155,7 +174,10 @@ export class ChatModelStreamHandler implements t.EventHandler {
       chunk.tool_calls.length > 0 &&
       chunk.tool_calls.every(
         (tc) =>
-          tc.id != null && tc.id !== '' && tc.name != null && tc.name !== ''
+          tc.id != null &&
+          tc.id !== '' &&
+          (tc as Partial<ToolCall>).name != null &&
+          tc.name !== ''
       )
     ) {
       hasToolCalls = true;
@@ -352,6 +374,13 @@ hasToolCallChunks: ${hasToolCallChunks}
       reasoning_content.summary[0].text
     ) {
       reasoning_content = 'valid';
+    } else if (
+      agentContext.provider === Providers.OPENROUTER &&
+      chunk.additional_kwargs?.reasoning_details != null &&
+      Array.isArray(chunk.additional_kwargs.reasoning_details) &&
+      chunk.additional_kwargs.reasoning_details.length > 0
+    ) {
+      reasoning_content = 'valid';
     }
     if (
       reasoning_content != null &&

package/src/tools/ToolNode.ts

@@ -87,6 +87,18 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
         { ...call, args, type: 'tool_call', stepId, turn },
         config
       );
+      
+      // Debug logging for image generation
+      if (call.name === 'image_generation') {
+        console.log('[ToolNode] image_generation output:', {
+          isBaseMessage: isBaseMessage(output),
+          messageType: isBaseMessage(output) ? output._getType() : 'not a message',
+          isCommand: isCommand(output),
+          hasArtifact: isBaseMessage(output) && (output as ToolMessage).artifact !== undefined,
+          outputType: typeof output,
+        });
+      }
+      
       if (
         (isBaseMessage(output) && output._getType() === 'tool') ||
         isCommand(output)
@@ -201,7 +213,18 @@ export class ToolNode<T = any> extends RunnableCallable<T, T> {
 
       outputs = await Promise.all(
         aiMessage.tool_calls
-          ?.filter((call) => call.id == null || !toolMessageIds.has(call.id))
+          ?.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)) ?? []
       );
     }

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'
+  );
+}

package/src/tools/search/content.test.ts

@@ -1,173 +1,173 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable no-console */
-// content.test.ts
-import * as fs from 'fs';
-import { processContent } from './content';
-
-describe('Link Processor', () => {
-  afterAll(() => {
-    if (fs.existsSync('./temp.html')) {
-      fs.unlinkSync('./temp.html');
-    }
-    if (fs.existsSync('./temp.md')) {
-      fs.unlinkSync('./temp.md');
-    }
-  });
-  // Basic functionality tests
-  test('should replace basic links with references', () => {
-    const html = `
-      <p>Test with <a href="https://example.com/link" title="Example">a link</a></p>
-      <p>And an <img src="https://example.com/img.jpg" alt="image"></p>
-      <p>Plus a <video src="https://example.com/video.mp4"></video></p>
-    `;
-
-    const markdown = `
-      Test with [a link](https://example.com/link "Example")
-      And an ![image](https://example.com/img.jpg)
-      Plus a [video](https://example.com/video.mp4)
-    `;
-
-    const result = processContent(html, markdown);
-
-    expect(result.links.length).toBe(1);
-    expect(result.images.length).toBe(1);
-    expect(result.videos.length).toBe(1);
-    expect(result.markdown).toContain('link#1');
-    expect(result.markdown).toContain('image#1');
-    expect(result.markdown).toContain('video#1');
-  });
-
-  // Edge case tests
-  test('should handle links with parentheses and special characters', () => {
-    const html = `
-      <a href="https://example.com/page(1).html" title="Parens">Link with parens</a>
-      <a href="https://example.com/path?query=test&param=value">Link with query</a>
-    `;
-
-    const markdown = `
-      [Link with parens](https://example.com/page(1).html "Parens")
-      [Link with query](https://example.com/path?query=test&param=value)
-    `;
-
-    const result = processContent(html, markdown);
-
-    expect(result.links.length).toBe(2);
-    expect(result.markdown).toContain('link#1');
-    expect(result.markdown).toContain('link#2');
-  });
-
-  // Performance test with large files
-  test('should process large files efficiently', () => {
-    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
-    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
-
-    // const largeHtml = generateLargeHtml(1000); // 1000 links
-    // fs.writeFileSync('./temp.html', largeHtml);
-
-    // const largeMd = generateLargeMarkdown(1000); // 1000 links
-    // fs.writeFileSync('./temp.md', largeMd);
-
-    // const html = fs.readFileSync('./temp.html', 'utf-8');
-    // const markdown = fs.readFileSync('./temp.md', 'utf-8');
-
-    // Measure time taken to process
-    const startTime = process.hrtime();
-    const result = processContent(html, markdown);
-    const elapsed = process.hrtime(startTime);
-    const timeInMs = elapsed[0] * 1000 + elapsed[1] / 1000000;
-
-    console.log(
-      `Processed ${result.links.length} links, ${result.images.length} images, and ${result.videos.length} videos in ${timeInMs.toFixed(2)}ms`
-    );
-
-    // Basic validations for large file processing
-    expect(result.links.length).toBeGreaterThan(0);
-    expect(result.markdown).toContain('link#');
-
-    // Check if all links were replaced (sample check)
-    expect(result.markdown).not.toContain('https://example.com/link');
-  });
-
-  // Memory usage test
-  test('should have reasonable memory usage', () => {
-    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
-    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
-
-    const beforeMem = process.memoryUsage();
-    processContent(html, markdown);
-    const afterMem = process.memoryUsage();
-
-    const heapUsed = (afterMem.heapUsed - beforeMem.heapUsed) / 1024 / 1024; // MB
-
-    console.log(`Memory used: ${heapUsed.toFixed(2)} MB`);
-
-    // This is a loose check - actual thresholds depend on your environment
-    expect(heapUsed).toBeLessThan(100); // Should use less than 100MB additional heap
-  });
-
-  // Real-world file test (if available)
-  test('should process real-world Wikipedia content', () => {
-    // Try to find real-world test files if they exist
-    const wikiHtml = 'src/tools/search/test.html';
-    const wikiMd = 'src/tools/search/test.md';
-
-    if (fs.existsSync(wikiHtml) && fs.existsSync(wikiMd)) {
-      const html = fs.readFileSync(wikiHtml, 'utf-8');
-      const markdown = fs.readFileSync(wikiMd, 'utf-8');
-
-      const result = processContent(html, markdown);
-
-      console.log(
-        `Processed ${result.links.length} Wikipedia links, ${result.images.length} images, and ${result.videos.length} videos`
-      );
-
-      expect(result.links.length).toBeGreaterThan(10); // Wikipedia articles typically have many links
-      expect(result.markdown).not.toMatch(/\]\(https?:\/\/[^\s")]+\)/); // No regular URLs should remain
-    } else {
-      console.log('Wikipedia test files not found, skipping this test');
-    }
-  });
-});
-
-// Helper function to generate large HTML test data
-function generateLargeHtml(linkCount: number): string {
-  let html = '<html><body>';
-
-  for (let i = 1; i <= linkCount; i++) {
-    html += `<p>Paragraph ${i} with <a href="https://example.com/link${i}" title="Link ${i}">link ${i}</a>`;
-
-    if (i % 10 === 0) {
-      html += ` and <img src="https://example.com/image${i / 10}.jpg" alt="Image ${i / 10}">`;
-    }
-
-    if (i % 50 === 0) {
-      html += ` and <video src="https://example.com/video${i / 50}.mp4" title="Video ${i / 50}"></video>`;
-    }
-
-    html += '</p>';
-  }
-
-  html += '</body></html>';
-  return html;
-}
-
-/** Helper function to generate large Markdown test data  */
-function generateLargeMarkdown(linkCount: number): string {
-  let markdown = '# Test Document\n\n';
-
-  for (let i = 1; i <= linkCount; i++) {
-    markdown += `Paragraph ${i} with [link ${i}](https://example.com/link${i} "Link ${i}")`;
-
-    if (i % 10 === 0) {
-      markdown += ` and ![Image ${i / 10}](https://example.com/image${i / 10}.jpg)`;
-    }
-
-    if (i % 50 === 0) {
-      markdown += ` and [Video ${i / 50}](https://example.com/video${i / 50}.mp4 "Video ${i / 50}")`;
-    }
-
-    markdown += '\n\n';
-  }
-
-  return markdown;
-}
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-console */
+// content.test.ts
+import * as fs from 'fs';
+import { processContent } from './content';
+
+describe('Link Processor', () => {
+  afterAll(() => {
+    if (fs.existsSync('./temp.html')) {
+      fs.unlinkSync('./temp.html');
+    }
+    if (fs.existsSync('./temp.md')) {
+      fs.unlinkSync('./temp.md');
+    }
+  });
+  // Basic functionality tests
+  test('should replace basic links with references', () => {
+    const html = `
+      <p>Test with <a href="https://example.com/link" title="Example">a link</a></p>
+      <p>And an <img src="https://example.com/img.jpg" alt="image"></p>
+      <p>Plus a <video src="https://example.com/video.mp4"></video></p>
+    `;
+
+    const markdown = `
+      Test with [a link](https://example.com/link "Example")
+      And an ![image](https://example.com/img.jpg)
+      Plus a [video](https://example.com/video.mp4)
+    `;
+
+    const result = processContent(html, markdown);
+
+    expect(result.links.length).toBe(1);
+    expect(result.images.length).toBe(1);
+    expect(result.videos.length).toBe(1);
+    expect(result.markdown).toContain('link#1');
+    expect(result.markdown).toContain('image#1');
+    expect(result.markdown).toContain('video#1');
+  });
+
+  // Edge case tests
+  test('should handle links with parentheses and special characters', () => {
+    const html = `
+      <a href="https://example.com/page(1).html" title="Parens">Link with parens</a>
+      <a href="https://example.com/path?query=test&param=value">Link with query</a>
+    `;
+
+    const markdown = `
+      [Link with parens](https://example.com/page(1).html "Parens")
+      [Link with query](https://example.com/path?query=test&param=value)
+    `;
+
+    const result = processContent(html, markdown);
+
+    expect(result.links.length).toBe(2);
+    expect(result.markdown).toContain('link#1');
+    expect(result.markdown).toContain('link#2');
+  });
+
+  // Performance test with large files
+  test('should process large files efficiently', () => {
+    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
+    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
+
+    // const largeHtml = generateLargeHtml(1000); // 1000 links
+    // fs.writeFileSync('./temp.html', largeHtml);
+
+    // const largeMd = generateLargeMarkdown(1000); // 1000 links
+    // fs.writeFileSync('./temp.md', largeMd);
+
+    // const html = fs.readFileSync('./temp.html', 'utf-8');
+    // const markdown = fs.readFileSync('./temp.md', 'utf-8');
+
+    // Measure time taken to process
+    const startTime = process.hrtime();
+    const result = processContent(html, markdown);
+    const elapsed = process.hrtime(startTime);
+    const timeInMs = elapsed[0] * 1000 + elapsed[1] / 1000000;
+
+    console.log(
+      `Processed ${result.links.length} links, ${result.images.length} images, and ${result.videos.length} videos in ${timeInMs.toFixed(2)}ms`
+    );
+
+    // Basic validations for large file processing
+    expect(result.links.length).toBeGreaterThan(0);
+    expect(result.markdown).toContain('link#');
+
+    // Check if all links were replaced (sample check)
+    expect(result.markdown).not.toContain('https://example.com/link');
+  });
+
+  // Memory usage test
+  test('should have reasonable memory usage', () => {
+    const html = fs.readFileSync('src/tools/search/test.html', 'utf-8');
+    const markdown = fs.readFileSync('src/tools/search/test.md', 'utf-8');
+
+    const beforeMem = process.memoryUsage();
+    processContent(html, markdown);
+    const afterMem = process.memoryUsage();
+
+    const heapUsed = (afterMem.heapUsed - beforeMem.heapUsed) / 1024 / 1024; // MB
+
+    console.log(`Memory used: ${heapUsed.toFixed(2)} MB`);
+
+    // This is a loose check - actual thresholds depend on your environment
+    expect(heapUsed).toBeLessThan(100); // Should use less than 100MB additional heap
+  });
+
+  // Real-world file test (if available)
+  test('should process real-world Wikipedia content', () => {
+    // Try to find real-world test files if they exist
+    const wikiHtml = 'src/tools/search/test.html';
+    const wikiMd = 'src/tools/search/test.md';
+
+    if (fs.existsSync(wikiHtml) && fs.existsSync(wikiMd)) {
+      const html = fs.readFileSync(wikiHtml, 'utf-8');
+      const markdown = fs.readFileSync(wikiMd, 'utf-8');
+
+      const result = processContent(html, markdown);
+
+      console.log(
+        `Processed ${result.links.length} Wikipedia links, ${result.images.length} images, and ${result.videos.length} videos`
+      );
+
+      expect(result.links.length).toBeGreaterThan(10); // Wikipedia articles typically have many links
+      expect(result.markdown).not.toMatch(/\]\(https?:\/\/[^\s")]+\)/); // No regular URLs should remain
+    } else {
+      console.log('Wikipedia test files not found, skipping this test');
+    }
+  });
+});
+
+// Helper function to generate large HTML test data
+function generateLargeHtml(linkCount: number): string {
+  let html = '<html><body>';
+
+  for (let i = 1; i <= linkCount; i++) {
+    html += `<p>Paragraph ${i} with <a href="https://example.com/link${i}" title="Link ${i}">link ${i}</a>`;
+
+    if (i % 10 === 0) {
+      html += ` and <img src="https://example.com/image${i / 10}.jpg" alt="Image ${i / 10}">`;
+    }
+
+    if (i % 50 === 0) {
+      html += ` and <video src="https://example.com/video${i / 50}.mp4" title="Video ${i / 50}"></video>`;
+    }
+
+    html += '</p>';
+  }
+
+  html += '</body></html>';
+  return html;
+}
+
+/** Helper function to generate large Markdown test data  */
+function generateLargeMarkdown(linkCount: number): string {
+  let markdown = '# Test Document\n\n';
+
+  for (let i = 1; i <= linkCount; i++) {
+    markdown += `Paragraph ${i} with [link ${i}](https://example.com/link${i} "Link ${i}")`;
+
+    if (i % 10 === 0) {
+      markdown += ` and ![Image ${i / 10}](https://example.com/image${i / 10}.jpg)`;
+    }
+
+    if (i % 50 === 0) {
+      markdown += ` and [Video ${i / 50}](https://example.com/video${i / 50}.mp4 "Video ${i / 50}")`;
+    }
+
+    markdown += '\n\n';
+  }
+
+  return markdown;
+}