@cicctencent/agent-core 0.1.1

package/src/agent/history-manager.ts

@@ -0,0 +1,323 @@
+// ============================================================
+// HistoryManager — 会话历史管理（滑动窗口 + 智能压缩）
+// ============================================================
+
+import type { Message, ToolCall } from '../types.ts';
+import type { ToolResultStore, OffloadEntry } from './types.ts';
+import { countMessageTokens } from '../utils/token-counter.ts';
+
+/** 历史管理配置 */
+export interface HistoryManagerConfig {
+  /** 消息历史上限（滑动窗口），默认 50 */
+  maxMessages: number;
+  /** 上下文压缩配置 */
+  contextBudget?: {
+    maxToolOutput?: number;
+    compactThreshold?: number;
+    maxContextTokens?: number;
+  };
+  /** 工具结果存储（可选） */
+  toolResultStore?: ToolResultStore;
+}
+
+/**
+ * 会话历史管理器
+ *
+ * 职责：
+ * - 维护 per-session 的消息历史（滑动窗口）
+ * - 多级智能压缩（token 感知）
+ * - Offload 大工具结果到外部存储
+ */
+export class HistoryManager {
+  private config: HistoryManagerConfig;
+  /** sessionId → Message[]（会话历史，滑动窗口） */
+  private historyMap = new Map<string, Message[]>();
+  /** sessionId → 当前 token 总数（增量维护，避免全量重算） */
+  private tokenCountMap = new Map<string, number>();
+
+  constructor(config: HistoryManagerConfig) {
+    this.config = config;
+  }
+
+  // ---- 公开接口 ----
+
+  /** 注入会话历史（从外部恢复，如持久化存储） */
+  setHistory(sessionId: string, messages: Message[]): void {
+    this.historyMap.set(sessionId, [...messages]);
+    // 重建 token 计数
+    this.tokenCountMap.set(sessionId, countMessageTokens(messages));
+  }
+
+  /** 获取会话历史副本（用于持久化保存） */
+  getHistorySnapshot(sessionId: string): Message[] {
+    return [...(this.historyMap.get(sessionId) || [])];
+  }
+
+  /** 获取会话历史副本（用于构建 LLM 请求） */
+  getHistory(sessionId: string): Message[] {
+    return [...(this.historyMap.get(sessionId) || [])];
+  }
+
+  /** 追加消息到会话历史（含自动压缩） */
+  addHistory(sessionId: string, msg: Message): void {
+    if (!this.historyMap.has(sessionId)) {
+      this.historyMap.set(sessionId, []);
+    }
+    const history = this.historyMap.get(sessionId)!;
+    history.push(msg);
+
+    // 增量 token 计数
+    const addedTokens = countMessageTokens([msg]);
+    const currentTokens = (this.tokenCountMap.get(sessionId) || 0) + addedTokens;
+    this.tokenCountMap.set(sessionId, currentTokens);
+
+    // Level 1: token 预算压缩
+    const maxTokens = this.config.contextBudget?.maxContextTokens ?? 100000;
+    if (currentTokens > maxTokens) {
+      this.compactHistorySmart(history, maxTokens, sessionId);
+      // 压缩后重算 token 数
+      this.tokenCountMap.set(sessionId, countMessageTokens(history));
+    }
+
+    // Level 2: 成对裁剪（消息数超过阈值时触发）
+    const threshold = this.config.contextBudget?.compactThreshold
+      ?? Math.floor(this.config.maxMessages * 0.8);
+    if (history.length > threshold) {
+      this.compactHistoryPairs(history);
+    }
+
+    // 安全兜底：极端情况下仍使用滑动窗口
+    while (history.length > this.config.maxMessages) {
+      history.shift();
+    }
+  }
+
+  /** 清理指定会话的历史 */
+  clearHistory(sessionId: string): void {
+    this.historyMap.delete(sessionId);
+    this.tokenCountMap.delete(sessionId);
+  }
+
+  /** 清理所有会话历史 */
+  clearAll(): void {
+    this.historyMap.clear();
+    this.tokenCountMap.clear();
+  }
+
+  // ---- 工具输出处理（智能截断 + 文件化）----
+
+  /** 不应被 offload 的读取类工具（避免 offload → read → offload 无限链） */
+  private static READ_THROUGH_TOOLS = new Set(['read_offload', 'read_tool_result']);
+
+  /**
+   * 处理工具输出：
+   * - 小结果直接返回
+   * - 大结果写入 OffloadStore，返回摘要标签（保留 100% 可溯源）
+   * - 无 OffloadStore 时回退到截断
+   */
+  processToolOutput(output: string, callId: string, toolName?: string, sessionId?: string): string {
+    const max = this.config.contextBudget?.maxToolOutput ?? 8000;
+
+    // 读取类工具：直接返回完整内容，不做 offload（避免无限链）
+    if (toolName && HistoryManager.READ_THROUGH_TOOLS.has(toolName)) {
+      return output.length <= max ? output : this.truncateOutput(output);
+    }
+
+    // 普通工具：在 maxToolOutput 预算内直接返回，超出则 offload
+    const offloadThreshold = max;
+    if (output.length <= offloadThreshold) return output;
+
+    // 优先使用 OffloadStore（非破坏性卸载）
+    const store = this.config.toolResultStore;
+    if (store && sessionId) {
+      const nodeId = `${toolName || 'tool'}_${Date.now()}_${Math.abs(HistoryManager.simpleHash(output)).toString(36)}`;
+      const preview = output.slice(0, 300).replace(/\n/g, ' ').trim();
+      store.writeOffload(
+        { nodeId, toolName: toolName || 'unknown', summary: preview, createdAt: Date.now(), charCount: output.length, sessionId },
+        output
+      );
+      // 同时写入 toolResultStore（按 callId），让 read_tool_result 也能找到
+      store.write(callId, output);
+      return (
+        `[offload:${nodeId}] ${toolName || 'tool'}: ${preview.slice(0, 150)}... ` +
+        `(${output.length} chars offloaded, use read_offload(node_id="${nodeId}") or read_tool_result(call_id="${callId}") to retrieve) [/offload]`
+      );
+    }
+
+    // 回退：超大结果写入文件
+    if (output.length > max && store) {
+      const filePath = store.write(callId, output);
+      const previewLen = Math.min(200, Math.floor(max * 0.1));
+      const preview = output.slice(0, previewLen);
+      return (
+        `[Result saved to file: ${output.length} chars → ${filePath}]\n` +
+        `Preview:\n${preview}...\n\n` +
+        `Use read_tool_result(call_id="${callId}") to read full content.`
+      );
+    }
+
+    // 无 store 时回退到截断
+    return this.truncateOutput(output);
+  }
+
+  /**
+   * 压缩消息列表（公开接口，供 LLMCaller 在上下文过长时调用）
+   *
+   * 使用与 addHistory 相同的多级压缩策略，但直接作用于传入的 messages 数组。
+   * 返回压缩后的 token 估算值。
+   */
+  compressMessages(messages: Message[], targetTokens?: number): number {
+    const maxTokens = targetTokens ?? this.config.contextBudget?.maxContextTokens ?? 100000;
+    // 更激进的目标：压缩到 70% 的预算，给 system prompt + tool defs 留空间
+    const aggressiveTarget = Math.floor(maxTokens * 0.7);
+    this.compactHistorySmart(messages, aggressiveTarget, '__compress__');
+    return countMessageTokens(messages);
+  }
+
+  // ---- 内部方法：智能压缩 ----
+
+  /** Level 1: 智能压缩（token 感知多级压缩管道） */
+  private compactHistorySmart(history: Message[], targetTokens: number, sessionId: string): void {
+    // 阶段 1: 卸载超长工具参数
+    this.offloadToolArguments(history);
+    if (countMessageTokens(history) <= targetTokens) return;
+
+    // 阶段 2: 卸载 base64 数据块
+    this.offloadBase64Content(history);
+    if (countMessageTokens(history) <= targetTokens) return;
+
+    // 阶段 3: 将大工具结果卸载到 OffloadStore（非破坏性，保留溯源）
+    this.offloadLargeToolResults(history, sessionId);
+    if (countMessageTokens(history) <= targetTokens) return;
+
+    // 阶段 4: 截断大工具结果（无 OffloadStore 时回退）
+    this.truncateLargeToolResults(history);
+    if (countMessageTokens(history) <= targetTokens) return;
+
+    // 阶段 5: 消息对裁剪（兜底）
+    this.compactHistoryPairs(history);
+  }
+
+  /** 压缩阶段 1: 卸载超长工具参数 */
+  private offloadToolArguments(history: Message[]): void {
+    const maxArgsLen = 500;
+    for (const msg of history) {
+      if (msg.role === 'assistant' && msg.tool_calls) {
+        for (const tc of msg.tool_calls) {
+          if (tc.function.arguments && tc.function.arguments.length > maxArgsLen) {
+            try {
+              const parsed = JSON.parse(tc.function.arguments);
+              const summary: Record<string, string> = {};
+              for (const [key, value] of Object.entries(parsed)) {
+                const val = typeof value === 'string' ? value : JSON.stringify(value);
+                summary[key] = val.length > 50 ? val.slice(0, 50) + '...' : val;
+              }
+              tc.function.arguments = JSON.stringify(summary);
+            } catch {
+              tc.function.arguments = `[args: ${tc.function.arguments.length} chars]`;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  /** 压缩阶段 2: 卸载 base64 数据块 */
+  private offloadBase64Content(history: Message[]): void {
+    const base64Pattern = /[A-Za-z0-9+/]{200,}={0,2}/g;
+    for (const msg of history) {
+      if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > 500) {
+        msg.content = msg.content.replace(base64Pattern, (match) => {
+          return `[base64: ${match.length} chars]`;
+        });
+      }
+    }
+  }
+
+  /** 压缩阶段 3: 非破坏性卸载大工具结果 */
+  private offloadLargeToolResults(history: Message[], sessionId: string): void {
+    const store = this.config.toolResultStore;
+    if (!store) return;
+
+    const offloadThreshold = 2000;
+    for (const msg of history) {
+      if (msg.role !== 'tool' || typeof msg.content !== 'string') continue;
+      if (msg.content.length <= offloadThreshold) continue;
+      if (/^\[offload:/.test(msg.content)) continue;
+
+      const toolName = HistoryManager.findToolNameForCallId(msg.tool_call_id || '', history);
+      const nodeId = `${toolName}_${Date.now()}_${Math.abs(HistoryManager.simpleHash(msg.content)).toString(36)}`;
+      const preview = msg.content.slice(0, 300).replace(/\n/g, ' ').trim();
+
+      store.writeOffload(
+        { nodeId, toolName, summary: preview, createdAt: Date.now(), charCount: msg.content.length, sessionId },
+        msg.content
+      );
+
+      msg.content = (
+        `[offload:${nodeId}] ${toolName}: ${preview.slice(0, 150)}... ` +
+        `(${msg.content.length} chars offloaded, use read_offload(node_id="${nodeId}") to retrieve) [/offload]`
+      );
+    }
+  }
+
+  /** 压缩阶段 4: 截断大工具结果 */
+  private truncateLargeToolResults(history: Message[]): void {
+    const maxResultLen = this.config.contextBudget?.maxToolOutput ?? 8000;
+    for (const msg of history) {
+      if (msg.role === 'tool' && typeof msg.content === 'string' && msg.content.length > maxResultLen) {
+        const headLen = Math.floor(maxResultLen * 0.4);
+        const tailLen = Math.floor(maxResultLen * 0.4);
+        msg.content = msg.content.slice(0, headLen)
+          + `\n\n... [${msg.content.length - headLen - tailLen} characters truncated] ...\n\n`
+          + msg.content.slice(-tailLen);
+      }
+    }
+  }
+
+  /** Level 2: 成对裁剪历史（移除最早的 assistant + 关联 tool 消息） */
+  private compactHistoryPairs(history: Message[]): void {
+    const keepCount = Math.floor(this.config.maxMessages * 0.5);
+    while (history.length > keepCount) {
+      const idx = history.findIndex(m => m.role === 'assistant');
+      if (idx === -1) break;
+      history.splice(idx, 1);
+      while (idx < history.length && history[idx]?.role === 'tool') {
+        history.splice(idx, 1);
+      }
+    }
+  }
+
+  /** 截断工具输出（保留首尾，中间省略） */
+  private truncateOutput(output: string): string {
+    const max = this.config.contextBudget?.maxToolOutput ?? 8000;
+    if (output.length <= max) return output;
+    const headLen = Math.floor(max * 0.4);
+    const tailLen = Math.floor(max * 0.4);
+    return output.slice(0, headLen)
+      + `\n\n... [${output.length - headLen - tailLen} characters omitted] ...\n\n`
+      + output.slice(-tailLen);
+  }
+
+  // ---- 静态辅助 ----
+
+  /** 根据 tool_call_id 从历史中查找工具名 */
+  static findToolNameForCallId(callId: string, history: Message[]): string {
+    for (const msg of history) {
+      if (msg.role === 'assistant' && msg.tool_calls) {
+        const match = msg.tool_calls.find(tc => tc.id === callId);
+        if (match) return match.function.name;
+      }
+    }
+    return 'unknown_tool';
+  }
+
+  /** DJB2 哈希（用于生成短 nodeId） */
+  static simpleHash(str: string): number {
+    let hash = 5381;
+    for (let i = 0; i < str.length; i++) {
+      hash = ((hash << 5) + hash + str.charCodeAt(i)) | 0;
+    }
+    return hash;
+  }
+}

package/src/agent/llm-caller.ts

@@ -0,0 +1,383 @@
+// ============================================================
+// LLMCaller — LLM 调用 + 重试 + 降级
+// ============================================================
+
+import type { AgentEvent, Message, ToolCall, TokenUsage } from '../types.ts';
+import type { LLMProvider } from '../llm/types.ts';
+import type { ToolDefinition } from '../tool/types.ts';
+import type { RetryPolicy } from './types.ts';
+import type { HookEvent, HookContext, HookResult } from '../hooks/types.ts';
+import type { HistoryManager } from './history-manager.ts';
+
+/** LLM 调用配置 */
+export interface LLMCallerConfig {
+  /** 主 LLM Provider */
+  llmProvider: LLMProvider;
+  /** 降级 LLM Provider（可选） */
+  fallbackProvider?: LLMProvider;
+  /** 重试策略 */
+  retryPolicy?: RetryPolicy;
+  /** LLM 推理超时（毫秒） */
+  llmTimeout: number;
+  /** Hook 执行器（由 Engine 注入） */
+  runHooks: (event: HookEvent, ctx: HookContext) => Promise<HookResult[]>;
+  /** 事件创建辅助（由 Engine 注入） */
+  createEvent: (sessionId: string, event: Record<string, unknown>) => AgentEvent;
+  /** 历史管理器（可选，用于上下文过长时压缩） */
+  historyManager?: HistoryManager;
+}
+
+/** 单次 LLM 调用结果 */
+export interface LLMCallResult {
+  /** 完整的 assistant message */
+  assistant: Message;
+  /** 本次调用消耗的 token */
+  usage?: TokenUsage;
+}
+
+/**
+ * LLM 调用管理器
+ *
+ * 职责：
+ * - 流式调用 LLM（支持 tool_calls 累积）
+ * - 重试 + 指数退避
+ * - 主 Provider → Fallback Provider 降级
+ */
+export class LLMCaller {
+  private config: LLMCallerConfig;
+
+  constructor(config: LLMCallerConfig) {
+    this.config = config;
+  }
+
+  /** 更新主 Provider（热更新场景） */
+  updateProvider(provider: LLMProvider): void {
+    this.config.llmProvider = provider;
+  }
+
+  /**
+   * 带重试和降级的 LLM 调用
+   * 返回 assistant message 或 null（所有尝试失败）
+   *
+   * 特殊处理：当 API 返回“输入过长”错误时，自动压缩历史并重试（最多一次）
+   */
+  async *callWithRetry(
+    sessionId: string,
+    messages: Message[],
+    toolDefs: ToolDefinition[],
+    abortSignal: AbortSignal,
+  ): AsyncGenerator<AgentEvent, Message | null> {
+    const policy = this.config.retryPolicy;
+    const maxRetries = policy?.maxRetries ?? 0;
+    const initialDelay = policy?.initialDelay ?? 1000;
+    const maxDelay = policy?.maxDelay ?? 30000;
+    const backoffFactor = policy?.backoffFactor ?? 2;
+
+    // 尝试主 Provider
+    const { result: firstResult, contextTooLong } = yield* this.callOnceWithDiag(sessionId, messages, toolDefs, abortSignal, this.config.llmProvider, false);
+    if (firstResult !== null) return firstResult;
+
+    // 上下文过长：压缩后重试（仅一次）
+    if (contextTooLong && this.config.historyManager) {
+      const tokensAfter = this.config.historyManager.compressMessages(messages);
+      console.log(`[LLMCaller] Context too long, compressed to ~${tokensAfter} tokens, retrying...`);
+      yield this.config.createEvent(sessionId, {
+        type: 'thinking',
+        content: `🔄 Context too long, compressed history and retrying...`,
+      });
+      const { result } = yield* this.callOnceWithDiag(sessionId, messages, toolDefs, abortSignal, this.config.llmProvider, false);
+      if (result !== null) return result;
+    }
+
+    // 重试主 Provider
+    for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      if (abortSignal.aborted) return null;
+
+      const delay = Math.min(initialDelay * Math.pow(backoffFactor, attempt - 1), maxDelay);
+      const providerName = this.config.llmProvider.getModel().provider || 'primary';
+
+      yield this.config.createEvent(sessionId, {
+        type: 'retry',
+        attempt,
+        maxRetries,
+        delay,
+        error: `LLM call failed, retrying...`,
+        provider: providerName,
+      });
+
+      await sleep(delay);
+      if (abortSignal.aborted) return null;
+
+      const { result } = yield* this.callOnceWithDiag(sessionId, messages, toolDefs, abortSignal, this.config.llmProvider, false);
+      if (result !== null) return result;
+    }
+
+    // 主 Provider 重试耗尽，尝试 fallback
+    if (this.config.fallbackProvider) {
+      const fallbackName = this.config.fallbackProvider.getModel().provider || 'fallback';
+      console.log(`[LLMCaller] Primary provider exhausted retries, switching to fallback: ${fallbackName}`);
+
+      yield this.config.createEvent(sessionId, {
+        type: 'retry',
+        attempt: maxRetries + 1,
+        maxRetries,
+        delay: 0,
+        error: `Switching to fallback provider: ${fallbackName}`,
+        provider: fallbackName,
+      });
+
+      const { result } = yield* this.callOnceWithDiag(sessionId, messages, toolDefs, abortSignal, this.config.fallbackProvider, true);
+      if (result !== null) return result;
+    }
+
+    // 所有尝试失败
+    const errorMsg = 'All LLM providers failed after retries';
+    await this.config.runHooks('on_error', { sessionId, iteration: 0, error: errorMsg, recoverable: false });
+    yield this.config.createEvent(sessionId, { type: 'error', error: errorMsg, recoverable: false });
+    return null;
+  }
+
+  /** 是否为“上下文过长”错误 */
+  private isContextTooLongError(err: any): boolean {
+    const msg = (err?.message || '').toLowerCase();
+    return msg.includes('too long') || msg.includes('input length') ||
+      msg.includes('context length') || msg.includes('too many tokens') ||
+      msg.includes('maximum context') || msg.includes('max_tokens');
+  }
+
+  /** 单次 LLM 调用（流式），带诊断信息 */
+  private async *callOnceWithDiag(
+    sessionId: string,
+    messages: Message[],
+    toolDefs: ToolDefinition[],
+    abortSignal: AbortSignal,
+    provider: LLMProvider,
+    isFallback: boolean,
+  ): AsyncGenerator<AgentEvent, { result: Message | null; contextTooLong: boolean }> {
+    try {
+      // Hook: before_ll_call（仅主 Provider 首次调用时触发）
+      if (!isFallback) {
+        await this.config.runHooks('before_ll_call', {
+          sessionId,
+          iteration: 0,
+          messages,
+          tools: toolDefs,
+        });
+      }
+
+      // 使用流式 API
+      const stream = provider.chatStream({
+        messages,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        toolChoice: toolDefs.length > 0 ? 'auto' : undefined,
+        abortSignal,
+      });
+
+      // 累积流式数据
+      let contentParts: string[] = [];
+      let reasoningParts: string[] = [];
+      const toolCallsMap = new Map<number, { id: string; name: string; args: string }>();
+      let role: 'system' | 'user' | 'assistant' | 'tool' = 'assistant';
+      let chunkUsage: TokenUsage | undefined;
+      let toolStreamingLastEmit = 0;
+
+      for await (const chunk of stream) {
+        if (abortSignal.aborted) break;
+
+        if (chunk.usage) {
+          chunkUsage = chunk.usage;
+        }
+
+        const delta = chunk.delta;
+
+        if (delta.reasoning_content) {
+          reasoningParts.push(delta.reasoning_content);
+          yield this.config.createEvent(sessionId, { type: 'thinking', content: delta.reasoning_content });
+        }
+
+        if (delta.content) {
+          contentParts.push(delta.content);
+          yield this.config.createEvent(sessionId, { type: 'message', content: delta.content, delta: true });
+        }
+
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls as any[]) {
+            const idx = tc.index ?? 0;
+            if (!toolCallsMap.has(idx)) {
+              toolCallsMap.set(idx, { id: '', name: '', args: '' });
+            }
+            const entry = toolCallsMap.get(idx)!;
+            if (tc.id) entry.id = tc.id;
+            if (tc.function?.name) entry.name = tc.function.name;
+            if (tc.function?.arguments) entry.args += tc.function.arguments;
+          }
+          const totalLen = Array.from(toolCallsMap.values()).reduce((s, e) => s + e.args.length, 0);
+          const threshold = Math.max(toolStreamingLastEmit * 2, 500);
+          if (totalLen - toolStreamingLastEmit >= threshold) {
+            toolStreamingLastEmit = totalLen;
+            const names = Array.from(toolCallsMap.values()).map(e => e.name || 'tool').join(', ');
+            yield this.config.createEvent(sessionId, {
+              type: 'thinking',
+              content: `⏳ Generating ${names} parameters (${totalLen} chars)...`,
+            });
+          }
+        }
+
+        if (delta.role) role = delta.role;
+      }
+
+      const fullContent = contentParts.join('') || null;
+      const fullReasoning = reasoningParts.join('') || null;
+      const toolCalls: ToolCall[] = [];
+
+      const sortedEntries = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]);
+      for (const [, entry] of sortedEntries) {
+        if (entry.id && entry.name) {
+          toolCalls.push({
+            id: entry.id,
+            type: 'function',
+            function: { name: entry.name, arguments: entry.args },
+          });
+        }
+      }
+
+      const assistant: Message = {
+        role,
+        content: fullContent,
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        ...(fullReasoning ? { reasoning_content: fullReasoning } : {}),
+      };
+
+      if (!fullContent && toolCalls.length === 0) {
+        return { result: null, contextTooLong: false };
+      }
+
+      return { result: assistant, contextTooLong: false };
+    } catch (err: any) {
+      const contextTooLong = this.isContextTooLongError(err);
+      console.warn(`[LLMCaller] LLM call failed (${isFallback ? 'fallback' : 'primary'})${contextTooLong ? ' [CONTEXT_TOO_LONG]' : ''}:`, err?.message || err);
+      return { result: null, contextTooLong };
+    }
+  }
+
+  /** 单次 LLM 调用（流式），返回 assistant message 或 null（保留向后兼容） */
+  private async *callOnce(
+    sessionId: string,
+    messages: Message[],
+    toolDefs: ToolDefinition[],
+    abortSignal: AbortSignal,
+    provider: LLMProvider,
+    isFallback: boolean,
+  ): AsyncGenerator<AgentEvent, Message | null> {
+    try {
+      // Hook: before_ll_call（仅主 Provider 首次调用时触发）
+      if (!isFallback) {
+        await this.config.runHooks('before_ll_call', {
+          sessionId,
+          iteration: 0,
+          messages,
+          tools: toolDefs,
+        });
+      }
+
+      // 使用流式 API
+      const stream = provider.chatStream({
+        messages,
+        tools: toolDefs.length > 0 ? toolDefs : undefined,
+        toolChoice: toolDefs.length > 0 ? 'auto' : undefined,
+        abortSignal,
+      });
+
+      // 累积流式数据
+      let contentParts: string[] = [];
+      let reasoningParts: string[] = [];
+      const toolCallsMap = new Map<number, { id: string; name: string; args: string }>();
+      let role: 'system' | 'user' | 'assistant' | 'tool' = 'assistant';
+      let chunkUsage: TokenUsage | undefined;
+      let toolStreamingLastEmit = 0; // 工具参数流式生成进度追踪
+
+      for await (const chunk of stream) {
+        if (abortSignal.aborted) break;
+
+        if (chunk.usage) {
+          chunkUsage = chunk.usage;
+        }
+
+        const delta = chunk.delta;
+
+        if (delta.reasoning_content) {
+          reasoningParts.push(delta.reasoning_content);
+          yield this.config.createEvent(sessionId, { type: 'thinking', content: delta.reasoning_content });
+        }
+
+        if (delta.content) {
+          contentParts.push(delta.content);
+          yield this.config.createEvent(sessionId, { type: 'message', content: delta.content, delta: true });
+        }
+
+        if (delta.tool_calls) {
+          for (const tc of delta.tool_calls as any[]) {
+            const idx = tc.index ?? 0;
+            if (!toolCallsMap.has(idx)) {
+              toolCallsMap.set(idx, { id: '', name: '', args: '' });
+            }
+            const entry = toolCallsMap.get(idx)!;
+            if (tc.id) entry.id = tc.id;
+            if (tc.function?.name) entry.name = tc.function.name;
+            if (tc.function?.arguments) entry.args += tc.function.arguments;
+          }
+          // 工具参数流式生成时，定期发出 thinking 事件让 UI 有可见进度
+          const totalLen = Array.from(toolCallsMap.values()).reduce((s, e) => s + e.args.length, 0);
+          const threshold = Math.max(toolStreamingLastEmit * 2, 500);
+          if (totalLen - toolStreamingLastEmit >= threshold) {
+            toolStreamingLastEmit = totalLen;
+            const names = Array.from(toolCallsMap.values()).map(e => e.name || 'tool').join(', ');
+            yield this.config.createEvent(sessionId, {
+              type: 'thinking',
+              content: `⏳ Generating ${names} parameters (${totalLen} chars)...`,
+            });
+          }
+        }
+
+        if (delta.role) role = delta.role;
+      }
+
+      // 组装完整 assistant message
+      const fullContent = contentParts.join('') || null;
+      const fullReasoning = reasoningParts.join('') || null;
+      const toolCalls: ToolCall[] = [];
+
+      const sortedEntries = Array.from(toolCallsMap.entries()).sort((a, b) => a[0] - b[0]);
+      for (const [, entry] of sortedEntries) {
+        if (entry.id && entry.name) {
+          toolCalls.push({
+            id: entry.id,
+            type: 'function',
+            function: { name: entry.name, arguments: entry.args },
+          });
+        }
+      }
+
+      const assistant: Message = {
+        role,
+        content: fullContent,
+        ...(toolCalls.length > 0 ? { tool_calls: toolCalls } : {}),
+        ...(fullReasoning ? { reasoning_content: fullReasoning } : {}),
+      };
+
+      if (!fullContent && toolCalls.length === 0) {
+        return null; // 空响应，由重试逻辑处理
+      }
+
+      return assistant;
+    } catch (err: any) {
+      console.warn(`[LLMCaller] LLM call failed (${isFallback ? 'fallback' : 'primary'}):`, err?.message || err);
+      return null;
+    }
+  }
+}
+
+/** 辅助：异步延迟 */
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}