illuma-agents 1.0.16 → 1.0.18

package/src/llm/bedrock/index.ts

@@ -29,7 +29,8 @@ import { ChatGenerationChunk } from '@langchain/core/outputs';
 import type { CallbackManagerForLLMRun } from '@langchain/core/callbacks/manager';
 
 /** Extended input type with promptCache option */
-export interface CustomChatBedrockConverseInput extends ChatBedrockConverseInput {
+export interface CustomChatBedrockConverseInput
+  extends ChatBedrockConverseInput {
   promptCache?: boolean;
 }
 
@@ -48,12 +49,12 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
   /**
    * Override invocationParams to add cachePoint to tools when promptCache is enabled.
    * This enables Bedrock prompt caching for tool definitions.
-   * 
+   *
    * STRATEGY: Separate cachePoints for core tools and MCP tools
    * - Core tools (web_search, execute_code, etc.) are stable → cache first
    * - MCP tools (have '_mcp_' in name) are dynamic → cache separately after
    * - This allows core tools to stay cached when MCP selection changes
-   * 
+   *
    * NOTE: Only Claude models support cachePoint - Nova and other models will reject it.
    */
   invocationParams(
@@ -63,8 +64,9 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
 
     // Add cachePoint to tools array if promptCache is enabled and tools exist
     // Only Claude models support cachePoint - check model name
-    const modelId = this.model?.toLowerCase() ?? '';
-    const isClaudeModel = modelId.includes('claude') || modelId.includes('anthropic');
+    const modelId = this.model.toLowerCase();
+    const isClaudeModel =
+      modelId.includes('claude') || modelId.includes('anthropic');
 
     if (
       this.promptCache &&
@@ -79,10 +81,11 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
       const mcpTools: typeof params.toolConfig.tools = [];
       const coreToolNames: string[] = [];
       const mcpToolNames: string[] = [];
-      
+
       for (const tool of params.toolConfig.tools) {
         // Check if tool has a name property with '_mcp_' pattern
-        const toolName = (tool as { toolSpec?: { name?: string } })?.toolSpec?.name ?? '';
+        const toolName =
+          (tool as { toolSpec?: { name?: string } }).toolSpec?.name ?? '';
         if (toolName.includes('_mcp_')) {
           mcpTools.push(tool);
           mcpToolNames.push(toolName);
@@ -92,35 +95,27 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
         }
       }
 
-
-
       // Build tools array with strategic cachePoints:
       // [CoreTool1, CoreTool2, cachePoint] + [MCPTool1, MCPTool2, cachePoint]
       const toolsWithCache: typeof params.toolConfig.tools = [];
-      let cachePointCount = 0;
-      
+
       // Add core tools with cachePoint (if any)
       if (coreTools.length > 0) {
         toolsWithCache.push(...coreTools);
         toolsWithCache.push({ cachePoint: { type: 'default' } });
-        cachePointCount++;
       }
-      
+
       // Add MCP tools with their own cachePoint (if any)
       if (mcpTools.length > 0) {
         toolsWithCache.push(...mcpTools);
         toolsWithCache.push({ cachePoint: { type: 'default' } });
-        cachePointCount++;
       }
-      
+
       // If no tools at all (shouldn't happen but safety check)
       if (toolsWithCache.length === 0) {
         toolsWithCache.push({ cachePoint: { type: 'default' } });
-        cachePointCount++;
       }
-      
 
-      
       params.toolConfig.tools = toolsWithCache;
     }
 
@@ -150,37 +145,54 @@ export class CustomChatBedrockConverse extends ChatBedrockConverse {
         (chunk.message as Partial<AIMessageChunk>).response_metadata &&
         typeof chunk.message.response_metadata === 'object'
       ) {
-        const responseMetadata = chunk.message.response_metadata as Record<string, unknown>;
+        const responseMetadata = chunk.message.response_metadata as Record<
+          string,
+          unknown
+        >;
         let needsModification = false;
         let cleanedMetadata = responseMetadata;
 
         // Check if contentBlockIndex exists anywhere in response_metadata
-        const hasContentBlockIndex = this.hasContentBlockIndex(responseMetadata);
+        const hasContentBlockIndex =
+          this.hasContentBlockIndex(responseMetadata);
         if (hasContentBlockIndex) {
-          cleanedMetadata = this.removeContentBlockIndex(responseMetadata) as Record<string, unknown>;
+          cleanedMetadata = this.removeContentBlockIndex(
+            responseMetadata
+          ) as Record<string, unknown>;
           needsModification = true;
         }
 
         // Extract cache tokens from metadata.usage (Bedrock streaming format)
         // The metadata chunk contains usage with cacheReadInputTokens/cacheWriteInputTokens
-        const metadata = responseMetadata.metadata as Record<string, unknown> | undefined;
-        const usage = (metadata?.usage ?? responseMetadata.usage) as Record<string, unknown> | undefined;
-        
-        let enhancedUsageMetadata: UsageMetadata | undefined = chunk.message.usage_metadata;
-        
+        const metadata = responseMetadata.metadata as
+          | Record<string, unknown>
+          | undefined;
+        const usage = (metadata?.usage ?? responseMetadata.usage) as
+          | Record<string, unknown>
+          | undefined;
+
+        let enhancedUsageMetadata: UsageMetadata | undefined =
+          chunk.message.usage_metadata;
+
         if (usage) {
-          const cacheRead = (usage.cacheReadInputTokens as number) ?? 0;
-          const cacheWrite = (usage.cacheWriteInputTokens as number) ?? 0;
-          const inputTokens = (usage.inputTokens as number) ?? 0;
-          const outputTokens = (usage.outputTokens as number) ?? 0;
-          
+          const cacheRead =
+            (usage.cacheReadInputTokens as number | undefined) ?? 0;
+          const cacheWrite =
+            (usage.cacheWriteInputTokens as number | undefined) ?? 0;
+          const inputTokens = (usage.inputTokens as number | undefined) ?? 0;
+          const outputTokens = (usage.outputTokens as number | undefined) ?? 0;
+
           if (cacheRead > 0 || cacheWrite > 0) {
-            
             needsModification = true;
             enhancedUsageMetadata = {
-              input_tokens: chunk.message.usage_metadata?.input_tokens ?? inputTokens,
-              output_tokens: chunk.message.usage_metadata?.output_tokens ?? outputTokens,
-              total_tokens: chunk.message.usage_metadata?.total_tokens ?? (usage.totalTokens as number) ?? 0,
+              input_tokens:
+                chunk.message.usage_metadata?.input_tokens ?? inputTokens,
+              output_tokens:
+                chunk.message.usage_metadata?.output_tokens ?? outputTokens,
+              total_tokens:
+                chunk.message.usage_metadata?.total_tokens ??
+                (usage.totalTokens as number | undefined) ??
+                0,
               input_token_details: {
                 cache_read: cacheRead,
                 cache_creation: cacheWrite,

package/src/llm/openrouter/index.ts

@@ -128,6 +128,8 @@ export class ChatOpenRouter extends ChatOpenAI {
       // Accumulate reasoning_details from each delta
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       const deltaAny = delta as Record<string, any>;
+      // Extract current chunk's reasoning text for streaming (before accumulation)
+      let currentChunkReasoningText = '';
       if (
         deltaAny.reasoning_details != null &&
         Array.isArray(deltaAny.reasoning_details)
@@ -143,7 +145,9 @@ export class ChatOpenRouter extends ChatOpenAI {
               index: detail.index,
             });
           } else if (detail.type === 'reasoning.text') {
-            // For text reasoning, accumulate text by index
+            // Extract current chunk's text for streaming
+            currentChunkReasoningText += detail.text || '';
+            // For text reasoning, accumulate text by index for final message
             const idx = detail.index ?? 0;
             const existing = reasoningTextByIndex.get(idx);
             if (existing) {
@@ -167,6 +171,12 @@ export class ChatOpenRouter extends ChatOpenAI {
         defaultRole
       );
 
+      // For models that send reasoning_details (Gemini style) instead of reasoning (DeepSeek style),
+      // set the current chunk's reasoning text to additional_kwargs.reasoning for streaming
+      if (currentChunkReasoningText && !chunk.additional_kwargs.reasoning) {
+        chunk.additional_kwargs.reasoning = currentChunkReasoningText;
+      }
+
       // IMPORTANT: Only set reasoning_details on the FINAL chunk to prevent
       // LangChain's chunk concatenation from corrupting the array
       // Check if this is the final chunk (has finish_reason)

package/src/llm/vertexai/index.ts

@@ -17,11 +17,14 @@ class CustomChatConnection extends ChatConnection<VertexAIClientOptions> {
       input,
       parameters
     )) as GeminiRequest;
-    if (
-      formattedData.generationConfig?.thinkingConfig?.thinkingBudget === -1 &&
-      formattedData.generationConfig.thinkingConfig.includeThoughts === false
-    ) {
-      formattedData.generationConfig.thinkingConfig.includeThoughts = true;
+    if (formattedData.generationConfig?.thinkingConfig?.thinkingBudget === -1) {
+      // -1 means "let the model decide" - delete the property so the API doesn't receive an invalid value
+      if (
+        formattedData.generationConfig.thinkingConfig.includeThoughts === false
+      ) {
+        formattedData.generationConfig.thinkingConfig.includeThoughts = true;
+      }
+      delete formattedData.generationConfig.thinkingConfig.thinkingBudget;
     }
     return formattedData;
   }
@@ -318,11 +321,7 @@ export class ChatVertexAI extends ChatGoogle {
   }
 
   constructor(fields?: VertexAIClientOptions) {
-    let dynamicThinkingBudget = false;
-    if (fields?.thinkingBudget === -1) {
-      dynamicThinkingBudget = true;
-      fields.thinkingBudget = 1;
-    }
+    const dynamicThinkingBudget = fields?.thinkingBudget === -1;
     super({
       ...fields,
       platformType: 'gcp',

package/src/messages/cache.ts

@@ -8,10 +8,13 @@ type MessageWithContent = {
 };
 
 /** Debug logger for cache operations - set ILLUMA_DEBUG_CACHE=true to enable */
-const debugCache = (message: string, data?: unknown) => {
+const debugCache = (message: string, data?: unknown): void => {
   if (process.env.ILLUMA_DEBUG_CACHE === 'true') {
     // eslint-disable-next-line no-console
-    console.log(`[Cache] ${message}`, data !== undefined ? JSON.stringify(data, null, 2) : '');
+    console.log(
+      `[Cache] ${message}`,
+      data !== undefined ? JSON.stringify(data, null, 2) : ''
+    );
   }
 };
 
@@ -148,26 +151,26 @@ export function stripBedrockCacheControl<T extends MessageWithContent>(
 
 /**
  * Adds Bedrock Converse API cache points using "Stable Prefix Caching" strategy.
- * 
+ *
  * STRATEGY: Place cache point after the LAST ASSISTANT message only.
  * This ensures the prefix (everything before the cache point) remains STABLE
  * as the conversation grows, maximizing cache hits.
- * 
+ *
  * Why this works:
  * - System message has its own cachePoint (added in AgentContext)
  * - Tools have their own cachePoint (added in CustomChatBedrockConverse)
  * - Conversation history grows, but the PREFIX stays the same
  * - Only the NEW user message is uncached (it's always different)
- * 
+ *
  * Example conversation flow:
  * Request 1: [System+cachePoint][Tools+cachePoint][User1] → No conversation cache yet
  * Request 2: [System][Tools][User1][Assistant1+cachePoint][User2] → Cache User1+Assistant1
  * Request 3: [System][Tools][User1][Assistant1][User2][Assistant2+cachePoint][User3]
  *            → Cache reads User1+A1+User2+A2, cache writes new portion
- * 
+ *
  * Claude's "Simplified Cache Management" automatically looks back up to 20 content
  * blocks from the cache checkpoint to find the longest matching prefix.
- * 
+ *
  * @param messages - The array of message objects (excluding system message).
  * @returns - The updated array with a single cache point after the last assistant message.
  */
@@ -175,16 +178,21 @@ export function addBedrockCacheControl<
   T extends Partial<BaseMessage> & MessageWithContent,
 >(messages: T[]): T[] {
   if (!Array.isArray(messages) || messages.length < 1) {
-    debugCache('addBedrockCacheControl: Skipping - no messages', { count: messages?.length });
+    debugCache('addBedrockCacheControl: Skipping - no messages', {
+      count: messages.length,
+    });
     return messages;
   }
 
-  debugCache('addBedrockCacheControl: Processing messages with stable prefix strategy', { 
-    count: messages.length 
-  });
-  
+  debugCache(
+    'addBedrockCacheControl: Processing messages with stable prefix strategy',
+    {
+      count: messages.length,
+    }
+  );
+
   const updatedMessages: T[] = messages.slice();
-  
+
   // First pass: Remove ALL existing cache points to ensure clean state
   // This prevents accumulation of stale cache points
   for (const message of updatedMessages) {
@@ -214,7 +222,7 @@ export function addBedrockCacheControl<
       const type = (block as { type?: string }).type;
       // Check for all reasoning/thinking block types:
       // - reasoning_content: Bedrock Anthropic extended thinking
-      // - reasoning: Generic reasoning format  
+      // - reasoning: Generic reasoning format
       // - thinking: Anthropic direct API thinking
       // - redacted_thinking: Anthropic redacted thinking blocks
       if (
@@ -233,27 +241,32 @@ export function addBedrockCacheControl<
   // Messages with reasoning/thinking blocks cannot have cache points after them (Bedrock limitation)
   let lastAssistantIndex = -1;
   let skippedWithReasoning = 0;
-  
+
   // Count message types for logging
   const messageTypes: Record<string, number> = {};
   for (const message of updatedMessages) {
-    const msgType = 'getType' in message && typeof message.getType === 'function' 
-      ? message.getType() 
-      : 'unknown';
+    const msgType =
+      'getType' in message && typeof message.getType === 'function'
+        ? message.getType()
+        : 'unknown';
     messageTypes[msgType] = (messageTypes[msgType] || 0) + 1;
   }
-  
+
   for (let i = updatedMessages.length - 1; i >= 0; i--) {
     const message = updatedMessages[i];
-    const messageType = 'getType' in message && typeof message.getType === 'function' 
-      ? message.getType() 
-      : 'unknown';
-    
+    const messageType =
+      'getType' in message && typeof message.getType === 'function'
+        ? message.getType()
+        : 'unknown';
+
     if (messageType === 'ai') {
       // Skip assistant messages with reasoning blocks - cache points not allowed after them
       if (hasReasoningBlock(message)) {
         skippedWithReasoning++;
-        debugCache('addBedrockCacheControl: Skipping assistant message with reasoning block', { index: i });
+        debugCache(
+          'addBedrockCacheControl: Skipping assistant message with reasoning block',
+          { index: i }
+        );
         continue;
       }
       lastAssistantIndex = i;
@@ -262,12 +275,20 @@ export function addBedrockCacheControl<
   }
 
   // Log message summary
-  debugCache(`📨 Messages | total=${updatedMessages.length} | ${Object.entries(messageTypes).map(([k,v]) => `${k}:${v}`).join(' ')} | skippedReasoning=${skippedWithReasoning}`);
+  debugCache(
+    `📨 Messages | total=${updatedMessages.length} | ${Object.entries(
+      messageTypes
+    )
+      .map(([k, v]) => `${k}:${v}`)
+      .join(' ')} | skippedReasoning=${skippedWithReasoning}`
+  );
 
   // If no suitable assistant message found, skip conversation caching
   // (System and Tools caching are still handled separately)
   if (lastAssistantIndex === -1) {
-    debugCache('📨 Messages | No suitable assistant message for cachePoint (first turn or all have reasoning)');
+    debugCache(
+      '📨 Messages | No suitable assistant message for cachePoint (first turn or all have reasoning)'
+    );
     return updatedMessages;
   }
 
@@ -280,22 +301,35 @@ export function addBedrockCacheControl<
       { type: ContentTypes.TEXT, text: content },
       { cachePoint: { type: 'default' } },
     ] as MessageContentComplex[];
-    debugCache(`📍 Message cachePoint at index ${lastAssistantIndex} (string, ${content.length} chars)`);
-    debugCache('addBedrockCacheControl: Added cachePoint to assistant message (string content)', {
-      index: lastAssistantIndex,
-      contentLength: content.length,
-    });
-  } else if (Array.isArray(assistantMessage.content) && assistantMessage.content.length > 0) {
+    debugCache(
+      `📍 Message cachePoint at index ${lastAssistantIndex} (string, ${content.length} chars)`
+    );
+    debugCache(
+      'addBedrockCacheControl: Added cachePoint to assistant message (string content)',
+      {
+        index: lastAssistantIndex,
+        contentLength: content.length,
+      }
+    );
+  } else if (
+    Array.isArray(assistantMessage.content) &&
+    assistantMessage.content.length > 0
+  ) {
     // Double-check: If this message has reasoning blocks, skip adding cache point entirely
     // This handles edge cases where the initial skip check might have missed it
     if (hasReasoningBlock(assistantMessage)) {
-      debugCache(`⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (has reasoning blocks)`);
-      debugCache('addBedrockCacheControl: Skipping - assistant message has reasoning blocks (safety check)', {
-        index: lastAssistantIndex,
-      });
+      debugCache(
+        `⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (has reasoning blocks)`
+      );
+      debugCache(
+        'addBedrockCacheControl: Skipping - assistant message has reasoning blocks (safety check)',
+        {
+          index: lastAssistantIndex,
+        }
+      );
       return updatedMessages;
     }
-    
+
     // Find the last text block and insert cache point after it
     let inserted = false;
     for (let j = assistantMessage.content.length - 1; j >= 0; j--) {
@@ -303,37 +337,52 @@ export function addBedrockCacheControl<
       const type = (block as { type?: string }).type;
       if (type === ContentTypes.TEXT || type === 'text') {
         const text = (block as { text?: string }).text;
-        if (text && text !== '') {
+        if (text != null && text !== '') {
           assistantMessage.content.splice(j + 1, 0, {
             cachePoint: { type: 'default' },
           } as MessageContentComplex);
           inserted = true;
-          debugCache(`📍 Message cachePoint at index ${lastAssistantIndex} (array, block ${j}, ${text.length} chars)`);
-          debugCache('addBedrockCacheControl: Added cachePoint after text block in assistant message', {
-            index: lastAssistantIndex,
-            textBlockIndex: j,
-            contentLength: text.length,
-          });
+          debugCache(
+            `📍 Message cachePoint at index ${lastAssistantIndex} (array, block ${j}, ${text.length} chars)`
+          );
+          debugCache(
+            'addBedrockCacheControl: Added cachePoint after text block in assistant message',
+            {
+              index: lastAssistantIndex,
+              textBlockIndex: j,
+              contentLength: text.length,
+            }
+          );
           break;
         }
       }
     }
-    
+
     // If no text block found, don't append cache point as the message structure is unexpected
     if (!inserted) {
-      const contentTypes = assistantMessage.content.map((b) => (b as { type?: string }).type);
-      debugCache(`⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (no text block, types: ${contentTypes.join(',')})`);
-      debugCache('addBedrockCacheControl: No suitable text block found, skipping cache point', {
-        index: lastAssistantIndex,
-        contentTypes,
-      });
+      const contentTypes = assistantMessage.content.map(
+        (b) => (b as { type?: string }).type
+      );
+      debugCache(
+        `⚠️ Message cachePoint SKIPPED at index ${lastAssistantIndex} (no text block, types: ${contentTypes.join(',')})`
+      );
+      debugCache(
+        'addBedrockCacheControl: No suitable text block found, skipping cache point',
+        {
+          index: lastAssistantIndex,
+          contentTypes,
+        }
+      );
     }
   }
 
-  debugCache('addBedrockCacheControl: Complete - stable prefix caching applied', { 
-    lastAssistantIndex,
-    totalMessages: updatedMessages.length,
-  });
+  debugCache(
+    'addBedrockCacheControl: Complete - stable prefix caching applied',
+    {
+      lastAssistantIndex,
+      totalMessages: updatedMessages.length,
+    }
+  );
 
   return updatedMessages;
 }

package/src/messages/core.ts

@@ -8,7 +8,7 @@ import {
 } from '@langchain/core/messages';
 import type { ToolCall } from '@langchain/core/messages/tool';
 import type * as t from '@/types';
-import { Providers } from '@/common';
+import { Providers, MessageTypes } from '@/common';
 
 export function getConverseOverrideMessage({
   userMessage,
@@ -346,7 +346,9 @@ export function convertMessagesToContent(
 
 export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
   const lastMessage = messages[messages.length - 1];
-  if (!(lastMessage instanceof ToolMessage)) return;
+  // Use getType() instead of instanceof to avoid module mismatch issues
+  if (lastMessage.getType() !== 'tool') return;
+  const lastToolMessage = lastMessage as ToolMessage;
 
   // Find the latest AIMessage with tool_calls that this tool message belongs to
   const latestAIParentIndex = findLastIndex(
@@ -354,20 +356,21 @@ export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
     (msg) =>
       (msg instanceof AIMessageChunk &&
         (msg.tool_calls?.length ?? 0) > 0 &&
-        msg.tool_calls?.some((tc) => tc.id === lastMessage.tool_call_id)) ??
+        msg.tool_calls?.some((tc) => tc.id === lastToolMessage.tool_call_id)) ??
       false
   );
 
   if (latestAIParentIndex === -1) return;
 
   // Check if any tool message after the AI message has array artifact content
+  // Use getType() instead of instanceof to avoid module mismatch issues
   const hasArtifactContent = messages.some(
     (msg, i) =>
       i > latestAIParentIndex &&
-      msg instanceof ToolMessage &&
-      msg.artifact != null &&
-      msg.artifact?.content != null &&
-      Array.isArray(msg.artifact.content)
+      msg.getType() === MessageTypes.TOOL &&
+      (msg as ToolMessage).artifact != null &&
+      (msg as ToolMessage).artifact?.content != null &&
+      Array.isArray((msg as ToolMessage).artifact.content)
   );
 
   if (!hasArtifactContent) return;
@@ -377,21 +380,26 @@ export function formatAnthropicArtifactContent(messages: BaseMessage[]): void {
 
   for (let j = latestAIParentIndex + 1; j < messages.length; j++) {
     const msg = messages[j];
+    // Use getType() instead of instanceof to avoid module mismatch issues
     if (
-      msg instanceof ToolMessage &&
-      toolCallIds.includes(msg.tool_call_id) &&
-      msg.artifact != null &&
-      Array.isArray(msg.artifact?.content) &&
+      msg.getType() === MessageTypes.TOOL &&
+      toolCallIds.includes((msg as ToolMessage).tool_call_id) &&
+      (msg as ToolMessage).artifact != null &&
+      Array.isArray((msg as ToolMessage).artifact?.content) &&
       Array.isArray(msg.content)
     ) {
-      msg.content = msg.content.concat(msg.artifact.content);
+      msg.content = (msg.content as t.MessageContentComplex[]).concat(
+        (msg as ToolMessage).artifact.content
+      );
     }
   }
 }
 
 export function formatArtifactPayload(messages: BaseMessage[]): void {
   const lastMessageY = messages[messages.length - 1];
-  if (!(lastMessageY instanceof ToolMessage)) return;
+  // Use getType() instead of instanceof to avoid module mismatch issues
+  if (lastMessageY.getType() !== 'tool') return;
+  const lastToolMessage = lastMessageY as ToolMessage;
 
   // Find the latest AIMessage with tool_calls that this tool message belongs to
   const latestAIParentIndex = findLastIndex(
@@ -399,28 +407,30 @@ export function formatArtifactPayload(messages: BaseMessage[]): void {
     (msg) =>
       (msg instanceof AIMessageChunk &&
         (msg.tool_calls?.length ?? 0) > 0 &&
-        msg.tool_calls?.some((tc) => tc.id === lastMessageY.tool_call_id)) ??
+        msg.tool_calls?.some((tc) => tc.id === lastToolMessage.tool_call_id)) ??
       false
   );
 
   if (latestAIParentIndex === -1) return;
 
   // Check if any tool message after the AI message has array artifact content
+  // Use getType() instead of instanceof to avoid module mismatch issues
   const hasArtifactContent = messages.some(
     (msg, i) =>
       i > latestAIParentIndex &&
-      msg instanceof ToolMessage &&
-      msg.artifact != null &&
-      msg.artifact?.content != null &&
-      Array.isArray(msg.artifact.content)
+      msg.getType() === MessageTypes.TOOL &&
+      (msg as ToolMessage).artifact != null &&
+      (msg as ToolMessage).artifact?.content != null &&
+      Array.isArray((msg as ToolMessage).artifact.content)
   );
 
   if (!hasArtifactContent) return;
 
   // Collect all relevant tool messages and their artifacts
+  // Use getType() instead of instanceof to avoid module mismatch issues
   const relevantMessages = messages
     .slice(latestAIParentIndex + 1)
-    .filter((msg) => msg instanceof ToolMessage) as ToolMessage[];
+    .filter((msg) => msg.getType() === MessageTypes.TOOL) as ToolMessage[];
 
   // Aggregate all content and artifacts
   const aggregatedContent: t.MessageContentComplex[] = [];

package/src/messages/format.ts

@@ -19,7 +19,8 @@ import type {
   TPayload,
   TMessage,
 } from '@/types';
-import { Providers, ContentTypes } from '@/common';
+import { Providers, ContentTypes, MessageTypes } from '@/common';
+import { processToolOutput } from '@/utils/toonFormat';
 
 interface MediaMessageParams {
   message: {
@@ -359,11 +360,16 @@ function formatAssistantMessage(
         }
         lastAIMessage.tool_calls.push(tool_call as ToolCall);
 
+        // Apply TOON compression to historical tool outputs for context efficiency
+        // processToolOutput handles: JSON→TOON conversion, already-TOON detection (skip), truncation
+        const processedOutput =
+          output != null ? processToolOutput(output).content : '';
+
         formattedMessages.push(
           new ToolMessage({
             tool_call_id: tool_call.id ?? '',
             name: tool_call.name,
-            content: output != null ? output : '',
+            content: processedOutput,
           })
         );
       } else if (part.type === ContentTypes.THINK) {
@@ -898,7 +904,12 @@ export function ensureThinkingBlockInMessages(
       let j = i + 1;
 
       // Look ahead for tool messages that belong to this AI message
-      while (j < messages.length && messages[j] instanceof ToolMessage) {
+      // Use getType() instead of instanceof to avoid module mismatch issues
+      // where different copies of ToolMessage class might be loaded
+      while (
+        j < messages.length &&
+        messages[j].getType() === MessageTypes.TOOL
+      ) {
         toolSequence.push(messages[j]);
         j++;
       }