feat(llm): consolidate tool call streaming events and add activeTools filtering

- Unify tool call event types into single streaming pipeline (tool_call_start, tool_call_delta, tool_call_delta_end, tool_call_available)
- Remove separate onLLMToolCall IPC listener in favor of integrated stream events
- Add activeTools parameter to StreamingService for dynamic tool availability filtering
- Implement experimental_repairToolCall handler to auto-fix malformed tool call JSON (unclosed quotes, braces, brackets)
- Replace custom cosineSimilarity implementation with AI SDK built-in function
- Simplify LLMStreamChunk interface to flatten tool call data structure with id, name, arguments, and argumentsDelta fields
- Remove LLMToolCall interface from preload in favor of inline stream chunk properties
- Update EventBus, stream processing, and tool handling to work with consolidated event model
- Improves tool call reliability and reduces IPC message overhead by consolidating events

Author: adnaan-worker

src/main/preload.ts

@@ -21,21 +21,13 @@ interface SearchFileResult {
 }
 
 interface LLMStreamChunk {
-  type: 'text' | 'reasoning' | 'error' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_end' | 'tool_call'
+  type: 'text' | 'reasoning' | 'error' | 'tool_call_start' | 'tool_call_delta' | 'tool_call_delta_end' | 'tool_call_available'
   content?: string
   error?: string
-  toolCallDelta?: {
-    id?: string
-    name?: string
-    args?: string
-  }
-  toolCall?: LLMToolCall
-}
-
-interface LLMToolCall {
-  id: string
-  name: string
-  arguments: Record<string, unknown>
+  id?: string
+  name?: string
+  arguments?: Record<string, unknown>
+  argumentsDelta?: string
 }
 
 interface LLMError {
@@ -47,7 +39,6 @@ interface LLMError {
 interface LLMResult {
   content: string
   reasoning?: string
-  toolCalls?: LLMToolCall[]
   usage?: {
     promptTokens: number
     completionTokens: number
@@ -193,7 +184,6 @@ export interface ElectronAPI {
   embedMany: (params: { texts: string[]; config: any }) => Promise<any>
   findSimilar: (params: { query: string; candidates: string[]; config: any; topK?: number }) => Promise<any>
   onLLMStream: (callback: (data: LLMStreamChunk) => void) => () => void
-  onLLMToolCall: (callback: (toolCall: LLMToolCall) => void) => () => void
   onLLMError: (callback: (error: LLMError) => void) => () => void
   onLLMDone: (callback: (data: LLMResult) => void) => () => void
 
@@ -438,11 +428,6 @@ contextBridge.exposeInMainWorld('electronAPI', {
     ipcRenderer.on('llm:stream', handler)
     return () => ipcRenderer.removeListener('llm:stream', handler)
   },
-  onLLMToolCall: (callback: (toolCall: LLMToolCall) => void) => {
-    const handler = (_: IpcRendererEvent, toolCall: LLMToolCall) => callback(toolCall)
-    ipcRenderer.on('llm:toolCall', handler)
-    return () => ipcRenderer.removeListener('llm:toolCall', handler)
-  },
   onLLMError: (callback: (error: LLMError) => void) => {
     const handler = (_: IpcRendererEvent, error: LLMError) => callback(error)
     ipcRenderer.on('llm:error', handler)

src/main/services/llm/LLMService.ts

@@ -37,6 +37,7 @@ export class LLMService {
     messages: LLMMessage[]
     tools?: ToolDefinition[]
     systemPrompt?: string
+    activeTools?: string[]
   }) {
     this.currentAbortController = new AbortController()
     try {

src/main/services/llm/services/EmbeddingService.ts

@@ -3,7 +3,7 @@
  * 用于代码语义搜索、相似度匹配、RAG
  */
 
-import { embed, embedMany } from 'ai'
+import { embed, embedMany, cosineSimilarity } from 'ai'
 import { createOpenAI } from '@ai-sdk/openai'
 import { logger } from '@shared/utils/Logger'
 import { LLMError } from '../types'
@@ -105,24 +105,10 @@ export class EmbeddingService {
   }
 
   /**
-   * 计算余弦相似度
+   * 计算余弦相似度（使用 AI SDK 内置实现）
    */
   cosineSimilarity(a: number[], b: number[]): number {
-    if (a.length !== b.length) {
-      throw new Error('Vectors must have the same length')
-    }
-
-    let dotProduct = 0
-    let normA = 0
-    let normB = 0
-
-    for (let i = 0; i < a.length; i++) {
-      dotProduct += a[i] * b[i]
-      normA += a[i] * a[i]
-      normB += b[i] * b[i]
-    }
-
-    return dotProduct / (Math.sqrt(normA) * Math.sqrt(normB))
+    return cosineSimilarity(a, b)
   }
 
   /**

src/main/services/llm/services/StreamingService.ts

@@ -22,6 +22,7 @@ export interface StreamingParams {
   tools?: ToolDefinition[]
   systemPrompt?: string
   abortSignal?: AbortSignal
+  activeTools?: string[]  // 限制可用的工具列表
 }
 
 export interface StreamingResult {
@@ -46,7 +47,7 @@ export class StreamingService {
    * 流式生成文本
    */
   async generate(params: StreamingParams): Promise<StreamingResult> {
-    const { config, messages, tools, systemPrompt, abortSignal } = params
+    const { config, messages, tools, systemPrompt, abortSignal, activeTools } = params
 
     // 创建 thinking 策略（只为需要特殊处理的模型）
     const strategy = ThinkingStrategyFactory.create(config.model)
@@ -79,6 +80,7 @@ export class StreamingService {
         model,
         messages: coreMessages,
         tools: coreTools,
+        activeTools,  // 动态限制可用工具
         maxOutputTokens: config.maxTokens,
         temperature: config.temperature,
         topP: config.topP,
@@ -88,6 +90,46 @@ export class StreamingService {
         stopSequences: config.stopSequences,
         seed: config.seed,
         abortSignal,
+        // 自动修复工具调用 JSON 格式错误
+        experimental_repairToolCall: async ({ toolCall, error }) => {
+          logger.llm.warn('[StreamingService] Tool call parse error, attempting repair:', {
+            toolName: toolCall.toolName,
+            error: error.message,
+          })
+          
+          try {
+            const inputText = toolCall.input
+            
+            // 1. 修复未闭合的引号
+            let fixed = inputText.replace(/([^\\])"([^"]*?)$/g, '$1"$2"')
+            
+            // 2. 修复未闭合的大括号
+            const openBraces = (fixed.match(/\{/g) || []).length
+            const closeBraces = (fixed.match(/\}/g) || []).length
+            if (openBraces > closeBraces) {
+              fixed += '}'.repeat(openBraces - closeBraces)
+            }
+            
+            // 3. 修复未闭合的方括号
+            const openBrackets = (fixed.match(/\[/g) || []).length
+            const closeBrackets = (fixed.match(/\]/g) || []).length
+            if (openBrackets > closeBrackets) {
+              fixed += ']'.repeat(openBrackets - closeBrackets)
+            }
+            
+            // 4. 尝试解析修复后的 JSON
+            JSON.parse(fixed)
+            
+            logger.llm.info('[StreamingService] Tool call repaired successfully')
+            return {
+              ...toolCall,
+              input: fixed,
+            }
+          } catch (repairError) {
+            logger.llm.error('[StreamingService] Tool call repair failed:', repairError)
+            return null // 返回 null 表示无法修复
+          }
+        },
       })
 
       // 处理流式响应
@@ -169,10 +211,18 @@ export class StreamingService {
             })
             break
 
-          // 工具调用完成（最终参数）
+          // 工具调用参数传输完成
+          case 'tool-input-end':
+            this.sendEvent({
+              type: 'tool-call-delta-end',
+              id: part.id,
+            })
+            break
+
+          // 工具调用完整信息（包含解析后的参数）
           case 'tool-call':
             this.sendEvent({
-              type: 'tool-call',
+              type: 'tool-call-available',
               id: part.toolCallId,
               name: part.toolName,
               arguments: part.input as Record<string, unknown>,
@@ -268,9 +318,16 @@ export class StreamingService {
           })
           break
 
-        case 'tool-call':
-          this.window.webContents.send('llm:toolCall', {
-            type: 'tool_call',
+        case 'tool-call-delta-end':
+          this.window.webContents.send('llm:stream', {
+            type: 'tool_call_delta_end',
+            id: event.id,
+          })
+          break
+
+        case 'tool-call-available':
+          this.window.webContents.send('llm:stream', {
+            type: 'tool_call_available',
             id: event.id,
             name: event.name,
             arguments: event.arguments,

src/main/services/llm/types.ts

@@ -90,7 +90,8 @@ export type StreamEvent =
   | { type: 'reasoning'; content: string }
   | { type: 'tool-call-start'; id: string; name: string }
   | { type: 'tool-call-delta'; id: string; name?: string; argumentsDelta: string }
-  | { type: 'tool-call'; id: string; name: string; arguments: Record<string, unknown> }
+  | { type: 'tool-call-delta-end'; id: string }
+  | { type: 'tool-call-available'; id: string; name: string; arguments: Record<string, unknown> }
   | { type: 'error'; error: LLMError }
   | { type: 'done'; usage?: TokenUsage; metadata?: ResponseMetadata }
 

src/renderer/agent/context/CompressionManager.ts

@@ -9,6 +9,7 @@
 
 import { logger } from '@utils/Logger'
 import { getAgentConfig } from '../utils/AgentConfig'
+import { pruneMessages } from 'ai'
 import type { ChatMessage, AssistantMessage, ToolResultMessage, UserMessage, ToolCall, MessageContent } from '../types'
 
 // ===== 类型 =====
@@ -123,6 +124,8 @@ function truncateToolCallArgs(tc: ToolCall, maxChars: number): { tc: ToolCall; t
  * - 当前用户消息在数组的最后一条
  * - 需要保留最后一条消息的图片（AI 需要分析）
  * - 历史消息中的图片替换为占位符（AI 已经分析过，节省 token）
+ * 
+ * 优化：结合 AI SDK 的 pruneMessages 进行智能修剪
  */
 export function prepareMessages(
   messages: ChatMessage[],
@@ -137,7 +140,66 @@ export function prepareMessages(
   // 过滤 checkpoint 消息
   result = result.filter(m => m.role !== 'checkpoint')
 
-  // 0. 替换历史消息中的图片为占位符（节省 token）
+  // 0. 使用 AI SDK 的 pruneMessages 进行智能修剪（L2+）
+  if (lastLevel >= 2) {
+    try {
+      const beforeCount = result.length
+      
+      // 转换为 AI SDK 格式
+      const aiMessages = result.map(m => {
+        if (m.role === 'assistant') {
+          const am = m as AssistantMessage
+          return {
+            role: 'assistant' as const,
+            content: am.content || '',
+            tool_calls: am.toolCalls?.map(tc => ({
+              id: tc.id,
+              type: 'function' as const,
+              function: { name: tc.name, arguments: JSON.stringify(tc.arguments) }
+            }))
+          }
+        }
+        if (m.role === 'tool') {
+          const tm = m as ToolResultMessage
+          return {
+            role: 'tool' as const,
+            tool_call_id: tm.toolCallId,
+            name: tm.name,
+            content: [{ type: 'text' as const, text: tm.content }]
+          }
+        }
+        if (m.role === 'user') {
+          const um = m as UserMessage
+          return {
+            role: 'user' as const,
+            content: typeof um.content === 'string' ? um.content : JSON.stringify(um.content)
+          }
+        }
+        return {
+          role: 'system' as const,
+          content: ''
+        }
+      })
+      
+      // 应用 pruneMessages
+      const pruned = pruneMessages({
+        messages: aiMessages as any, // 类型转换，避免复杂的类型匹配
+        reasoning: lastLevel >= 3 ? 'before-last-message' : 'all',
+        toolCalls: lastLevel >= 3 ? 'before-last-2-messages' : 'all',
+        emptyMessages: 'remove'
+      })
+      
+      removedMessages = beforeCount - pruned.length
+      if (removedMessages > 0) {
+        logger.agent.info(`[Compression] pruneMessages removed ${removedMessages} messages`)
+        result = result.slice(-pruned.length)
+      }
+    } catch (e) {
+      logger.agent.warn('[Compression] pruneMessages failed:', e)
+    }
+  }
+  
+  // 1. 替换历史消息中的图片为占位符（节省 token）
   // 注意：messages 包含刚添加的当前用户消息，它在最后一条
   // 需要保留最后一条用户消息的图片，只替换之前的历史消息
   const lastIndex = result.length - 1

src/renderer/agent/core/EventBus.ts

@@ -20,7 +20,7 @@ export type AgentEvent =
   | { type: 'stream:reasoning'; text: string; phase: 'start' | 'delta' | 'end' }
   | { type: 'stream:tool_start'; id: string; name: string }
   | { type: 'stream:tool_delta'; id: string; args: string }
-  | { type: 'stream:tool_end'; id: string; args: Record<string, unknown> }
+  | { type: 'stream:tool_available'; id: string; name: string; args: Record<string, unknown> }
 
   // LLM 事件
   | { type: 'llm:start' }

src/renderer/agent/core/loop.ts

@@ -64,12 +64,41 @@ async function callLLM(
     })
     const tools = chatMode === 'chat' ? [] : toolManager.getAllToolDefinitions()
 
+    // 动态工具控制：根据上下文限制可用工具
+    let activeTools: string[] | undefined
+    
+    if (tools.length > 0) {
+      const allToolNames = tools.map(t => t.name)
+      const store = useAgentStore.getState()
+      
+      // 场景1: Chat 模式 - 禁用所有工具（已在上面处理）
+      // 场景2: Plan 模式 - 启用所有工具（包括 plan 相关工具）
+      // 场景3: Code 模式 - 根据压缩等级动态调整
+      
+      // 当上下文压缩等级较高时，限制工具以减少 token 使用
+      const compressionLevel = store.compressionStats?.level || 0
+      if (compressionLevel >= 3) {
+        // L3/L4: 只保留核心工具，移除 AI 辅助工具（节省 token）
+        const coreTools = allToolNames.filter(name => 
+          !['analyze_code', 'suggest_refactoring', 'suggest_fixes', 'generate_tests'].includes(name)
+        )
+        activeTools = coreTools
+        logger.agent.info(`[Loop] Compression L${compressionLevel}: ${activeTools.length}/${allToolNames.length} tools active (AI tools disabled)`)
+      }
+      
+      // 未来可扩展的场景：
+      // - 只读模式：activeTools = allToolNames.filter(name => getReadOnlyTools().includes(name))
+      // - 安全模式：activeTools = allToolNames.filter(name => !getDangerousTools().includes(name))
+      // - 特定任务：activeTools = getToolsForTask(taskType)
+    }
+
     // 发送请求
     await api.llm.send({
       config: config as import('@shared/types/llm').LLMConfig,
       messages: messages as LLMMessage[],
       tools,
-      systemPrompt: ''
+      systemPrompt: '',
+      activeTools
     })
 
     // 等待流式响应完成