foliko 1.1.7 → 1.1.9

package/src/core/agent-chat.js

@@ -96,6 +96,87 @@ const _globalTokenizer = new SimpleTokenizer();
 // 压缩超时时间（毫秒）
 const COMPRESSION_TIMEOUT = 30000;
 
+/**
+ * ChatStreamQueue - 流式消息队列
+ * 按顺序处理消息，每条消息使用 chatStream 流式输出
+ */
+class ChatStreamQueue {
+  constructor(chatHandler) {
+    this.chatHandler = chatHandler;
+    this.queue = []; // 消息队列
+    this.isProcessing = false;
+  }
+
+  // 添加消息到队列，返回 Promise
+  enqueue(message, options = {}) {
+    const { onChunk, onComplete, onError, sessionId } = options;
+
+    return new Promise((resolve, reject) => {
+      this.queue.push({
+        message,
+        sessionId,
+        onChunk,
+        onComplete,
+        onError,
+        resolve,
+        reject,
+      });
+      this.process();
+    });
+  }
+
+  // 推送消息到队列（供回调中使用）
+  push(message, options = {}) {
+    return this.enqueue(message, options);
+  }
+
+  // 按顺序处理
+  async process() {
+    if (this.isProcessing || this.queue.length === 0) return;
+
+    this.isProcessing = true;
+    const task = this.queue.shift();
+
+    // 创建 push 上下文，传递给回调
+    const ctx = {
+      push: (msg, opts = {}) => {
+        this.push(msg, { ...task.options, ...opts });
+      },
+    };
+
+    try {
+      const fullText = await this.sendMessage(task);
+      task.resolve(fullText);
+      if (task.onComplete) {
+        await task.onComplete(fullText, ctx);
+      }
+    } catch (error) {
+      task.reject(error);
+      if (task.onError) {
+        await task.onError(error, ctx);
+      }
+    } finally {
+      this.isProcessing = false;
+      this.process(); // 处理下一个
+    }
+  }
+
+  // 发送消息，使用 chatStream 流式输出
+  async sendMessage(task) {
+    const { message, sessionId, onChunk } = task;
+    let fullText = '';
+
+    for await (const chunk of this.chatHandler.chatStream(message, { sessionId })) {
+      fullText += chunk.text || '';
+      if (onChunk) {
+        onChunk(chunk);
+      }
+    }
+
+    return fullText;
+  }
+}
+
 class AgentChatHandler extends EventEmitter {
   /**
    * @param {Agent} agent - Agent 实例
@@ -147,6 +228,9 @@ class AgentChatHandler extends EventEmitter {
     this._sessionQueues = new Map(); // sessionId -> Queue of {message, options, resolve, reject}
     this._processingSessions = new Set(); // sessionId -> processing flag
 
+    // 流式消息队列（用于 continue）
+    this._chatStreamQueue = new ChatStreamQueue(this);
+
     // Session Memory prepareStep（从 memory 插件获取）
     this._sessionMemoryPrepareStep = null;
     if (agent?.framework) {
@@ -1176,191 +1260,184 @@ ${truncatedContent}${truncatedNote}
   }
 
   /**
-   * 执行实际聊天逻辑
+   * 继续完成之前的响应
+   * 当流式响应提前结束时，调用此方法设置 continue 标志
+   * @param {string} prompt - 继续时的提示文本
+   * @param {string} sessionId - 会话 ID
+   * @param {Object} options - 选项 { onChunk, onComplete, onError }
+   */
+  continue(prompt, sessionId = null, options = {}) {
+    const queue = this._chatStreamQueue;
+    const finalOptions = { sessionId, ...options };
+
+    // enqueue 返回 Promise
+    const promise = queue.enqueue(
+      prompt || '请继续完成你的回答，输出之前的完整内容。',
+      finalOptions
+    );
+
+    // 返回包含 push 方法的上下文
+    return {
+      push: (msg, opts = {}) => {
+        queue.push(msg, { sessionId, ...opts });
+      },
+      then: promise.then.bind(promise),
+      catch: promise.catch.bind(promise),
+    };
+  }
+
+  /**
+   * 准备聊天会话：刷新系统提示词、添加用户消息、压缩上下文
    * @param {string|Object} message - 消息
-   * @param {Object} options - 选项
+   * @param {string} sessionId - 会话 ID
+   * @returns {Object} - { messageStore, messages, tools, maxSteps }
    * @private
    */
-  async _doChat(message, options = {}) {
-    const sessionId = options.sessionId || null;
-    const framework = this.agent.framework;
-
-    // 获取 Per-Session 的消息存储（自动从 session 加载）
+  async _prepareSession(message, sessionId) {
     const messageStore = this._getSessionMessageStore(sessionId);
     const messages = messageStore.messages;
 
-    try {
-      // 关键：每次 chat 调用时刷新系统提示词，确保包含最新的工具/技能描述
-      // 解决上下文过长时 LLM 不调用工具的问题
-      this._systemPrompt = this.agent._buildSystemPrompt();
-      // 动态导入 AI SDK
-      const { tool, ToolLoopAgent } = await this._importAI();
+    // 刷新系统提示词
+    this._systemPrompt = this.agent._buildSystemPrompt();
 
-      const userMessage =
-        typeof message === 'string' ? { role: 'user', content: message } : message;
-      messages.push(userMessage);
-
-      // 检查是否需要压缩上下文（包括工具定义）
-      const messagesTokens = this._countMessagesTokens(messages);
-      const toolsTokens = this._countToolsTokens();
-      const systemPromptTokens = this._countTokens(this._systemPrompt);
-      const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
-      const limit = this._maxContextTokens * 0.5; // 降低到 50%，更早压缩，防止 context window 超限
-
-      if (totalTokens > limit) {
-        logger.info(
-          `Context large (${totalTokens}/${this._maxContextTokens} tokens = msgs:${messagesTokens} + tools:${toolsTokens} + sys:${systemPromptTokens}), compressing...`
-        );
-        // 使用带超时控制的压缩（传入 messages 引用）
-        await this._compressContext(sessionId, messages, messageStore);
-        // 压缩后验证消息配对（防止 orphaned tool result）
-        const validatedMessages = this._validateMessagesPairing(messages);
-        if (validatedMessages.length !== messages.length) {
-          messages.length = 0;
-          messages.push(...validatedMessages);
-        }
-      }
+    // 添加用户消息
+    const userMessage = typeof message === 'string' ? { role: 'user', content: message } : message;
+    messages.push(userMessage);
 
-      const maxSteps = options.maxSteps || this._maxSteps;
-      const tools = this._getAITools(tool);
+    // 检查上下文大小，必要时压缩
+    const messagesTokens = this._countMessagesTokens(messages);
+    const toolsTokens = this._countToolsTokens();
+    const systemPromptTokens = this._countTokens(this._systemPrompt);
+    const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
+    const limit = this._maxContextTokens * 0.5;
 
-      // 验证消息配对（防止 API 调用时报 orphaned tool result 错误）
-      const validatedMessages = this._validateMessagesPairing(messages);
-      if (validatedMessages.length !== messages.length) {
+    if (totalTokens > limit) {
+      logger.info(
+        `Context large (${totalTokens}/${this._maxContextTokens} tokens), compressing...`
+      );
+      await this._compressContext(sessionId, messages, messageStore);
+      const validated = this._validateMessagesPairing(messages);
+      if (validated.length !== messages.length) {
         messages.length = 0;
-        messages.push(...validatedMessages);
+        messages.push(...validated);
       }
+    }
 
-      // 验证并修复消息中的不完整工具调用（在 API 调用前执行，防止开始聊天的时候就报错）
-      this._validateToolCalls(messages);
-
-      // 最终检查：在 API 调用前再次验证 token 数
-      const finalMessagesTokens = this._countMessagesTokens(messages);
-      const finalToolsTokens = this._countToolsTokens();
-      const finalSystemPromptTokens = this._countTokens(this._systemPrompt);
-      const finalTotalTokens = finalMessagesTokens + finalToolsTokens + finalSystemPromptTokens;
-      const finalLimit = this._maxContextTokens * 0.5;
-
-      // logger.info(
-      //   `[API Call Check] messages=${messages.length}, tokens=(${finalMessagesTokens}+${finalToolsTokens}+${finalSystemPromptTokens}=${finalTotalTokens}) vs limit=${finalLimit}`
-      // );
-
-      // 如果仍然超过限制，强制压缩
-      if (finalTotalTokens > finalLimit) {
-        logger.warn(`[API Call Check] Still over limit after validation, forcing compression`);
-        await this._compressContext(sessionId, messages, messageStore);
-        const compressedMessages = this._validateMessagesPairing(messages);
-        messages.length = 0;
-        messages.push(...compressedMessages);
-        const afterTokens = this._countMessagesTokens(messages);
-        logger.info(
-          `[After Forced Compression] messages=${messages.length}, tokens=${afterTokens}`
-        );
-      }
+    // 验证消息配对
+    const validatedMessages = this._validateMessagesPairing(messages);
+    if (validatedMessages.length !== messages.length) {
+      messages.length = 0;
+      messages.push(...validatedMessages);
+    }
 
-      // 准备传给 agent 的消息
-      const prepareStepChainStream = async ({ stepNumber, messages: inputMessages }) => {
-        try {
-          // 1. 验证消息格式
-          if (!Array.isArray(inputMessages)) {
-            logger.warn('prepareStep received non-array messages');
-            return { messages: inputMessages };
-          }
+    // 验证工具调用
+    this._validateToolCalls(messages);
 
-          // 2. 修复不完整的工具调用（input 只有 { 或其他无效值）
-          this._validateToolCalls(inputMessages);
+    // 最终 token 检查
+    const finalTokens =
+      this._countMessagesTokens(messages) +
+      this._countToolsTokens() +
+      this._countTokens(this._systemPrompt);
+    if (finalTokens > this._maxContextTokens * 0.5) {
+      logger.warn('Still over limit after validation, forcing compression');
+      await this._compressContext(sessionId, messages, messageStore);
+      const compressed = this._validateMessagesPairing(messages);
+      messages.length = 0;
+      messages.push(...compressed);
+    }
 
-          // 3. 验证消息配对并更新 inputMessages（防止 API 报 orphaned tool result 错误）
-          const pairedMessages = this._validateMessagesPairing(inputMessages);
-          if (pairedMessages.length !== inputMessages.length) {
-            logger.debug(
-              `prepareStep pairing: ${inputMessages.length} -> ${pairedMessages.length}`
-            );
-          }
-          // 重要：用配对验证后的结果替换 inputMessages
-          inputMessages.length = 0;
-          inputMessages.push(...pairedMessages);
+    const maxSteps = this._maxSteps;
 
-          // 4. Token 数检查：超过限制才修剪
-          const tokenCount = this._countMessagesTokens(inputMessages);
-          const tokenLimit = this._maxContextTokens * 0.75; // 75% 阈值，保留缓冲空间
-          if (inputMessages.length <= 30 && tokenCount <= tokenLimit) {
-            return { messages: inputMessages }; // 消息少且 token 未超限，不修剪
-          }
+    return { messageStore, messages, maxSteps };
+  }
 
-          // 5. 保留配对完整的消息（使用 AI SDK 标准格式）
-          const pruned = this._prepareMessagesForAI(inputMessages);
-          logger.debug(`prepareStep pruned: ${inputMessages.length} -> ${pruned.length} messages`);
+  /**
+   * 创建 prepareStep 函数（供 AI SDK 调用）
+   * @returns {Function}
+   * @private
+   */
+  _createPrepareStep() {
+    return async ({ stepNumber, messages: inputMessages }) => {
+      try {
+        if (!Array.isArray(inputMessages)) {
+          return { messages: inputMessages };
+        }
 
-          // 6. 返回 AI SDK 6.x 要求的格式
-          return { messages: pruned };
-        } catch (err) {
-          logger.error('prepareStep error:', err.message);
+        this._validateToolCalls(inputMessages);
+        const pairedMessages = this._validateMessagesPairing(inputMessages);
+        if (pairedMessages.length !== inputMessages.length) {
+          inputMessages.length = 0;
+          inputMessages.push(...pairedMessages);
+        }
+
+        const tokenCount = this._countMessagesTokens(inputMessages);
+        const tokenLimit = this._maxContextTokens * 0.75;
+        if (inputMessages.length <= 30 && tokenCount <= tokenLimit) {
           return { messages: inputMessages };
         }
-      };
+
+        const pruned = this._prepareMessagesForAI(inputMessages);
+        return { messages: pruned };
+      } catch (err) {
+        logger.error('prepareStep error:', err.message);
+        return { messages: inputMessages };
+      }
+    };
+  }
+
+  /**
+   * 执行实际聊天逻辑
+   * @param {string|Object} message - 消息
+   * @param {Object} options - 选项
+   * @private
+   */
+  async _doChat(message, options = {}) {
+    const sessionId = options.sessionId || null;
+    const framework = this.agent.framework;
+
+    try {
+      const { tool, ToolLoopAgent } = await this._importAI();
+      const { messageStore, messages, maxSteps } = await this._prepareSession(message, sessionId);
 
       if (!this._aiClient) {
         throw new Error('AI client not configured.');
       }
 
-      // 不使用 prepareStep，消息格式已在 _saveHistoryToSession 中处理
+      const tools = this._getAITools(tool);
+
       const agent = new ToolLoopAgent({
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
-        prepareStep: prepareStepChainStream,
+        prepareStep: this._createPrepareStep(),
       });
 
-      // 使用 runInSession 让工具执行时能获取 sessionId（Per-Session 隔离）
       const result = await framework.runInSession(sessionId, {}, async () => {
         return agent.generate({ messages, ...this.providerOptions });
       });
 
-      // 捕获 API 返回的 usage 用于更准确的 token 估算
       if (result.usage) {
         this._updateMessageStoreUsage(messageStore, result.usage);
-        logger.debug(
-          `API usage: input=${result.usage.inputTokens}, output=${result.usage.outputTokens}`
-        );
       }
 
       messages.push(...result.response.messages);
-
-      // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
       const userMsg = messages[messages.length - result.response.messages.length - 1];
       this.emit('message', { content: result.text, sessionId: sessionId, userMessage: userMsg });
 
-      // 生成后检查：如果消息太长，下次需要压缩
-      const afterTokens = this._countMessagesTokens(messages);
-      if (afterTokens > this._maxContextTokens * 0.5) {
-        logger.info(`After generation: ${afterTokens} tokens, will compress on next turn`);
-      }
-
       return {
         success: true,
         message: result.text || '',
         stepCount: result.stepCount || 1,
       };
     } catch (err) {
-      // 捕获 AI API 瞬时错误（如 Invalid JSON response、服务负载过高等）
       const errorMsg = err.message || String(err);
-      const causeMsg = err.cause?.message || String(err.cause) || '';
-      const fullMsg = errorMsg + causeMsg;
-
       const isTransientError =
-        fullMsg.includes('Invalid JSON response') ||
-        fullMsg.includes('负载较高') ||
-        fullMsg.includes('Failed after') ||
-        fullMsg.includes('timeout') ||
-        fullMsg.includes('retry') ||
+        errorMsg.includes('Invalid JSON response') ||
+        errorMsg.includes('负载较高') ||
+        errorMsg.includes('Failed after') ||
         err.name === 'AI_RetryError' ||
         err.name === 'AI_APICallError';
 
-      logger.warn(
-        `[AgentChat] Error caught in _doChat: msg="${errorMsg}", name=${err.name}, isTransient=${isTransientError}`
-      );
-
       if (isTransientError) {
         return {
           success: false,
@@ -1370,15 +1447,9 @@ ${truncatedContent}${truncatedNote}
         };
       }
 
-      // 未知错误，打印调试信息后继续抛出
-      logger.error(
-        `[AgentChat] Unknown error in _doChat: ${err.message}, name: ${err.name}, cause: ${err.cause?.message || err.cause}`
-      );
       throw err;
     } finally {
-      // 校验并修复消息中的不完整工具调用
-      this._validateToolCalls(messages);
-      // 确保保存聊天历史到 session（无论成功还是失败）
+      const messageStore = this._getSessionMessageStore(sessionId);
       messageStore.save();
     }
   }
@@ -1392,144 +1463,30 @@ ${truncatedContent}${truncatedNote}
     const sessionId = options.sessionId || null;
     const framework = this.agent.framework;
 
-    // 获取 Per-Session 的消息存储
-    const messageStore = this._getSessionMessageStore(sessionId);
-    const messages = messageStore.messages;
-
     try {
-      // 关键：每次 chat 调用时刷新系统提示词，确保包含最新的工具/技能描述
-      // 解决上下文过长时 LLM 不调用工具的问题
-      this._systemPrompt = this.agent._buildSystemPrompt();
-      // 动态导入 AI SDK
       const { tool, ToolLoopAgent } = await this._importAI();
-      // await fs.writeFile('system.md', this._systemPrompt);
-      const userMessage =
-        typeof message === 'string' ? { role: 'user', content: message } : message;
-      messages.push(userMessage);
-
-      // 检查是否需要压缩上下文（包括工具定义）
-      const messagesTokens = this._countMessagesTokens(messages);
-      const toolsTokens = this._countToolsTokens();
-      const systemPromptTokens = this._countTokens(this._systemPrompt);
-      const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
-      const limit = this._maxContextTokens * 0.5; // 降低到 50%，更早压缩，防止 context window 超限
-      // 对于流式调用，如果上下文太大，先压缩再开始
-      if (totalTokens > limit) {
-        logger.info(
-          `Context large (${totalTokens}/${this._maxContextTokens} tokens), compressing...`
-        );
-        // 流式调用时等待压缩完成（使用带超时控制的压缩）
-        await this._compressContext(sessionId, messages, messageStore);
-        // 压缩后验证消息配对（防止 orphaned tool result）
-        const validatedMessages = this._validateMessagesPairing(messages);
-        if (validatedMessages.length !== messages.length) {
-          messages.length = 0;
-          messages.push(...validatedMessages);
-        }
-      }
+      const { messageStore, messages } = await this._prepareSession(message, sessionId);
 
-      const maxSteps = options.maxSteps || this._maxSteps;
-      const tools = this._getAITools(tool);
       if (!this._aiClient) {
         throw new Error('AI client not configured.');
       }
 
-      // 验证消息配对（防止 API 调用时报 orphaned tool result 错误）
-      const validatedMessages = this._validateMessagesPairing(messages);
-      if (validatedMessages.length !== messages.length) {
-        messages.length = 0;
-        messages.push(...validatedMessages);
-      }
-
-      // 验证并修复消息中的不完整工具调用（在 API 调用前执行，防止开始聊天的时候就报错）
-      this._validateToolCalls(messages);
-
-      // 最终检查：在 API 调用前再次验证 token 数
-      const finalMessagesTokens = this._countMessagesTokens(messages);
-      const finalToolsTokens = this._countToolsTokens();
-      const finalSystemPromptTokens = this._countTokens(this._systemPrompt);
-      const finalTotalTokens = finalMessagesTokens + finalToolsTokens + finalSystemPromptTokens;
-      const finalLimit = this._maxContextTokens * 0.5;
-
-      logger.info(
-        `[API Call Check (stream)] messages=${messages.length}, tokens=(${finalMessagesTokens}+${finalToolsTokens}+${finalSystemPromptTokens}=${finalTotalTokens}) vs limit=${finalLimit}`
-      );
-
-      // 如果仍然超过限制，强制压缩
-      if (finalTotalTokens > finalLimit) {
-        logger.warn(`[API Call Check (stream)] Still over limit, forcing compression`);
-        await this._compressContext(sessionId, messages, messageStore);
-        const compressedMessages = this._validateMessagesPairing(messages);
-        messages.length = 0;
-        messages.push(...compressedMessages);
-        const afterTokens = this._countMessagesTokens(messages);
-        logger.info(
-          `[After Forced Compression (stream)] messages=${messages.length}, tokens=${afterTokens}`
-        );
-      }
-
-      // 准备传给 agent 的消息 (流式版本)
-      const prepareStepChainStream = async ({ stepNumber, messages: inputMessages }) => {
-        try {
-          // 1. 验证消息格式
-          if (!Array.isArray(inputMessages)) {
-            logger.warn('prepareStep received non-array messages');
-            return { messages: inputMessages };
-          }
-
-          // 2. 修复不完整的工具调用（input 只有 { 或其他无效值）
-          this._validateToolCalls(inputMessages);
-
-          // 3. 验证消息配对并更新 inputMessages（防止 API 报 orphaned tool result 错误）
-          const pairedMessages = this._validateMessagesPairing(inputMessages);
-          if (pairedMessages.length !== inputMessages.length) {
-            logger.debug(
-              `prepareStep pairing: ${inputMessages.length} -> ${pairedMessages.length}`
-            );
-          }
-          // 重要：用配对验证后的结果替换 inputMessages
-          inputMessages.length = 0;
-          inputMessages.push(...pairedMessages);
-
-          // 4. Token 数检查：超过限制才修剪
-          const tokenCount = this._countMessagesTokens(inputMessages);
-          const tokenLimit = this._maxContextTokens * 0.75; // 75% 阈值，保留缓冲空间
-          if (inputMessages.length <= 30 && tokenCount <= tokenLimit) {
-            return { messages: inputMessages }; // 消息少且 token 未超限，不修剪
-          }
-
-          // 5. 保留配对完整的消息（使用 AI SDK 标准格式）
-          const pruned = this._prepareMessagesForAI(inputMessages);
-          logger.debug(`prepareStep pruned: ${inputMessages.length} -> ${pruned.length} messages`);
-
-          // 6. 返回 AI SDK 6.x 要求的格式
-          return { messages: pruned };
-        } catch (err) {
-          logger.error('prepareStep error:', err.message);
-          return { messages: inputMessages };
-        }
-      };
+      const tools = this._getAITools(tool);
 
       const agent = new ToolLoopAgent({
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
         stopWhen: isLoopFinished(),
-        prepareStep: prepareStepChainStream,
+        prepareStep: this._createPrepareStep(),
       });
 
-      // 使用 runInSession 让工具执行时能获取 sessionId（Per-Session 隔离）
       const result = await framework.runInSession(sessionId, {}, async () => {
-        return agent.stream({
-          messages,
-          ...this.providerOptions,
-        });
+        return agent.stream({ messages, ...this.providerOptions });
       });
 
       const stream = result.fullStream;
       let fullText = '';
-
-      // 流式迭代器
       const iterator = stream[Symbol.asyncIterator] ? stream : stream.fullStream;
 
       for await (const part of iterator || stream) {
@@ -1538,7 +1495,8 @@ ${truncatedContent}${truncatedNote}
           fullText += text;
           yield { type: 'text', text };
         } else if (part.type === 'reasoning') {
-          this.emit('thinking', { content: part.text });
+          // this.emit('thinking', { content: part.text });
+          yield { type: 'thinking', text: part.text };
         } else if (part.type === 'tool-call') {
           yield { type: 'tool-call', toolName: part.toolName, input: part.input };
         } else if (part.type === 'tool-result') {
@@ -1550,49 +1508,30 @@ ${truncatedContent}${truncatedNote}
 
       const finishMessages = (await result.response).messages;
       messages.push(...finishMessages);
-      // 捕获 API 返回的 usage 用于更准确的 token 估算
       const usage = await result.totalUsage;
       if (usage) {
-        try {
-          this._updateMessageStoreUsage(messageStore, usage);
-          logger.debug(
-            `API usage (stream): input=${usage.inputTokens}, output=${usage.outputTokens}`
-          );
-        } catch (e) {
-          logger.debug('Failed to capture stream usage:', e.message);
-        }
+        this._updateMessageStoreUsage(messageStore, usage);
       }
 
-      // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
       const userMsg = messages[messages.length - finishMessages.length - 1];
       this.emit('message', { content: fullText, sessionId: sessionId, userMessage: userMsg });
     } catch (err) {
-      // 捕获 AI API 瞬时错误
       const errorMsg = err.message || String(err);
-      const causeMsg = err.cause?.message || String(err.cause) || '';
-      const fullMsg = errorMsg + causeMsg;
-
       const isTransientError =
-        fullMsg.includes('Invalid JSON response') ||
-        fullMsg.includes('负载较高') ||
-        fullMsg.includes('Failed after') ||
-        fullMsg.includes('timeout') ||
-        fullMsg.includes('retry') ||
+        errorMsg.includes('Invalid JSON response') ||
+        errorMsg.includes('负载较高') ||
         err.name === 'AI_RetryError' ||
         err.name === 'AI_APICallError';
 
       if (isTransientError) {
-        logger.warn(`[AgentChat] Transient AI error in stream: ${errorMsg}`);
         yield { type: 'error', error: 'AI 服务暂时不可用，请稍后重试。' };
       } else {
-        logger.error(`[AgentChat] Stream error: ${err.message}, name: ${err.name}`);
+        logger.error(`[AgentChat] Stream error: ${err.message}`);
         this.emit('error', { error: err.message });
         yield { type: 'error', error: err.message };
       }
     } finally {
-      // 校验并修复消息中的不完整工具调用
-      this._validateToolCalls(messages);
-      // 确保保存聊天历史到 session（无论成功还是失败）
+      const messageStore = this._getSessionMessageStore(sessionId);
       messageStore.save();
     }
   }