foliko 1.0.86 → 1.1.0

package/src/core/agent-chat.js

@@ -7,6 +7,23 @@ const { EventEmitter } = require('../utils/event-emitter');
 const { logger } = require('../utils/logger');
 const { generateText, stepCountIs } = require('ai');
 const { prepareMessagesForAPI } = require('../utils');
+const fs = require('fs/promises');
+
+/**
+ * 从消息中提取 toolCallId（兼容两种格式）
+ * 格式1: msg.toolCallId (旧格式)
+ * 格式2: msg.content[0].toolCallId (AI SDK CoreMessage 格式)
+ * @param {Object} msg - 消息对象
+ * @returns {string|null}
+ */
+function extractToolCallId(msg) {
+  if (msg.toolCallId) return msg.toolCallId;
+  if (Array.isArray(msg.content) && msg.content.length > 0) {
+    const firstContent = msg.content[0];
+    if (firstContent && firstContent.toolCallId) return firstContent.toolCallId;
+  }
+  return null;
+}
 
 // 模型上下文限制表（留 15-20% 余量给 system prompt 和输出）
 const MODEL_CONTEXT_LIMITS = {
@@ -96,7 +113,8 @@ class AgentChatHandler extends EventEmitter {
     this.providerOptions = config.providerOptions || {};
 
     this._systemPrompt = config.systemPrompt || 'You are a helpful assistant.';
-    this._messages = [];
+    // this._messages = [];  // 移除共享消息存储！改用 Per-Session
+    this._sessionMessageStores = new Map(); // sessionId → { messages: [], historyLoaded: false, compressionState: {} }
     this._tools = new Map();
     this._maxSteps = 20; // 降低默认步骤数，减少上下文消耗
 
@@ -123,10 +141,62 @@ class AgentChatHandler extends EventEmitter {
 
     // Session 历史存储配置
     this._sessionHistoryKey = config.sessionHistoryKey || 'chat_history';
+
+    // Per-Session 队列管理
+    this._sessionQueues = new Map(); // sessionId -> Queue of {message, options, resolve, reject}
+    this._processingSessions = new Set(); // sessionId -> processing flag
+
+    // Session Memory prepareStep（从 memory 插件获取）
+    this._sessionMemoryPrepareStep = null;
+    if (agent?.framework) {
+      const memoryPlugin = agent.framework.pluginManager.get('memory');
+      if (memoryPlugin?.instance?.getPrepareStep) {
+        this._sessionMemoryPrepareStep = memoryPlugin.instance.getPrepareStep();
+        logger.debug('Session memory prepareStep loaded');
+      }
+    }
   }
 
   /**
-   * 从 session 存储加载聊天历史
+   * 获取 Per-Session 的消息存储
+   * @param {string} sessionId - 会话 ID
+   * @returns {Object} 消息存储对象
+   * @private
+   */
+  _getSessionMessageStore(sessionId) {
+    if (!sessionId) {
+      // 无 session 的单次请求，使用临时存储
+      return { messages: [], historyLoaded: false, compressionState: {}, save: () => {} };
+    }
+
+    if (!this._sessionMessageStores.has(sessionId)) {
+      // 自动从 session 加载消息
+      const savedMessages = this._loadHistoryFromSession(sessionId);
+      this._sessionMessageStores.set(sessionId, {
+        sessionId, // 保存 sessionId 引用
+        messages: savedMessages,
+        historyLoaded: true, // 已加载
+        compressionState: {
+          lastCompressedAt: null,
+          lastTokenCount: 0,
+          count: 0,
+        },
+        save: () => {
+          // 简洁的保存方法
+          if (this.agent?.framework) {
+            const sessionCtx = this.agent.framework.getOrCreateSessionContext(sessionId);
+            if (sessionCtx) {
+              sessionCtx.replaceMessages(this._sessionMessageStores.get(sessionId).messages);
+            }
+          }
+        },
+      });
+    }
+    return this._sessionMessageStores.get(sessionId);
+  }
+
+  /**
+   * 从 SessionContext 加载聊天历史
    * @param {string} sessionId - 会话 ID
    * @returns {Array} 消息数组
    * @private
@@ -135,10 +205,10 @@ class AgentChatHandler extends EventEmitter {
     if (!sessionId || !this.agent?.framework) return [];
 
     try {
-      const sessionPlugin = this.agent.framework.pluginManager.get('session');
-      if (!sessionPlugin) return [];
+      const sessionCtx = this.agent.framework.getOrCreateSessionContext(sessionId);
+      if (!sessionCtx) return [];
 
-      const messages = sessionPlugin.getHistory(sessionId);
+      const messages = sessionCtx.getMessages();
       return messages || [];
     } catch (err) {
       // 忽略加载错误
@@ -147,34 +217,84 @@ class AgentChatHandler extends EventEmitter {
   }
 
   /**
-   * 保存聊天历史到 session 存储
+   * 保存聊天历史到 SessionContext
    * @param {string} sessionId - 会话 ID
    * @param {Array} messages - 消息数组
    * @private
    */
   _saveHistoryToSession(sessionId, messages) {
-    if (!sessionId || !this.agent?.framework || !messages || messages.length === 0) return;
+    if (!sessionId || !this.agent?.framework || !messages) return;
 
     try {
-      const sessionPlugin = this.agent.framework.pluginManager.get('session');
-      if (!sessionPlugin) return;
-
-      // 获取 session 中已有消息数量，避免重复添加
-      const existingHistory = sessionPlugin.getHistory(sessionId);
-      const existingCount = existingHistory.length;
+      const sessionCtx = this.agent.framework.getOrCreateSessionContext(sessionId);
+      if (!sessionCtx) return;
 
-      // 只添加新消息（避免重复添加已加载的历史）
-      const simpleMessages = messages;
-
-      const newMessages = simpleMessages.slice(existingCount);
-      for (const msg of newMessages) {
-        sessionPlugin.addMessage(sessionId, msg);
-      }
+      // 清理消息格式后整体替换
+      const cleanedMessages = prepareMessagesForAPI(messages);
+      sessionCtx.replaceMessages(cleanedMessages);
     } catch (err) {
       // 忽略保存错误
     }
   }
 
+  /**
+   * 将消息加入队列（Per-Session）
+   * @param {string} sessionId - 会话 ID
+   * @param {string|Object} message - 消息
+   * @param {Object} options - 选项
+   * @returns {Promise}
+   */
+  enqueue(sessionId, message, options = {}) {
+    if (!this._sessionQueues.has(sessionId)) {
+      this._sessionQueues.set(sessionId, []);
+    }
+    const queue = this._sessionQueues.get(sessionId);
+
+    if (this._processingSessions.has(sessionId)) {
+      // 已在处理中，加入队列
+      return new Promise((resolve, reject) => {
+        queue.push({ message, options, resolve, reject });
+      });
+    }
+
+    // 直接处理
+    return this._processWithSession(sessionId, message, options);
+  }
+
+  /**
+   * 处理单个 session 的消息
+   * @param {string} sessionId - 会话 ID
+   * @param {string|Object} message - 消息
+   * @param {Object} options - 选项
+   * @returns {Promise}
+   * @private
+   */
+  async _processWithSession(sessionId, message, options) {
+    this._processingSessions.add(sessionId);
+    try {
+      return await this._doChat(message, options);
+    } finally {
+      this._processingSessions.delete(sessionId);
+      // 处理队列中的下一条
+      setImmediate(() => this._drainQueue(sessionId));
+    }
+  }
+
+  /**
+   * 消费队列中的下一条消息
+   * @param {string} sessionId - 会话 ID
+   * @private
+   */
+  _drainQueue(sessionId) {
+    const queue = this._sessionQueues.get(sessionId);
+    if (!queue || queue.length === 0) return;
+
+    const item = queue.shift();
+    this._processWithSession(sessionId, item.message, item.options)
+      .then(item.resolve)
+      .catch(item.reject);
+  }
+
   /**
    * 静态方法：保留接口兼容性（无实际作用）
    */
@@ -232,16 +352,6 @@ class AgentChatHandler extends EventEmitter {
     return total;
   }
 
-  /**
-   * 检查是否需要压缩上下文
-   * @returns {boolean}
-   * @private
-   */
-  _shouldCompress() {
-    const totalTokens = this._countMessagesTokens(this._messages);
-    return totalTokens > this._maxContextTokens * this._compressionThreshold;
-  }
-
   /**
    * 计算工具定义的 token 数（估算）
    * @returns {number}
@@ -266,44 +376,36 @@ class AgentChatHandler extends EventEmitter {
     return total;
   }
 
-  /**
-   * 检查是否需要压缩（包括工具定义）
-   * @returns {boolean}
-   * @private
-   */
-  _shouldCompressWithTools() {
-    const messagesTokens = this._countMessagesTokens(this._messages);
-    const toolsTokens = this._countToolsTokens();
-    const systemPromptTokens = this._countTokens(this._systemPrompt);
-    const total = messagesTokens + toolsTokens + systemPromptTokens;
-
-    // 如果总token数超过上下文限制的 85%，就压缩
-    return total > this._maxContextTokens * 0.85;
-  }
-
   /**
    * 压缩上下文消息（智能摘要模式，支持超时控制）
    * 策略：
    * 1. 如果启用了智能摘要且有 AI 客户端，对早期消息进行 AI 总结
    * 2. 否则使用简单裁剪 + 标记
    * 3. 支持超时控制，防止压缩阻塞太久
+   * @param {string} sessionId - 会话 ID（用于压缩后同步）
+   * @param {Array} messages - 消息数组引用
+   * @param {Object} messageStore - 消息存储对象
    * @private
    */
-  async _compressContext() {
+  async _compressContext(sessionId, messages, messageStore) {
     // 如果已经有压缩在进行，返回现有的 Promise
     if (this._compressionInProgress && this._compressionPromise) {
       logger.debug('Compression already in progress, waiting for it...');
       return this._compressionPromise;
     }
 
-    if (this._messages.length <= this._keepRecentMessages) {
+    if (messages.length <= this._keepRecentMessages) {
       return;
     }
 
     this._compressionInProgress = true;
 
     // 创建压缩 Promise，带超时控制
-    this._compressionPromise = this._executeCompressionWithTimeout().finally(() => {
+    this._compressionPromise = this._executeCompressionWithTimeout(
+      sessionId,
+      messages,
+      messageStore
+    ).finally(() => {
       this._compressionInProgress = false;
       this._compressionPromise = null;
     });
@@ -313,15 +415,21 @@ class AgentChatHandler extends EventEmitter {
 
   /**
    * 执行压缩（带超时）
+   * @param {string} sessionId - 会话 ID
+   * @param {Array} messages - 消息数组引用
+   * @param {Object} messageStore - 消息存储对象
    * @private
    */
-  async _executeCompressionWithTimeout() {
+  async _executeCompressionWithTimeout(sessionId, messages, messageStore) {
     try {
-      return await Promise.race([this._doCompress(), this._createTimeoutPromise()]);
+      return await Promise.race([
+        this._doCompress(sessionId, messages, messageStore),
+        this._createTimeoutPromise(),
+      ]);
     } catch (err) {
       logger.warn('Compression failed:', err.message);
       // 压缩失败时使用简单的截断策略
-      this._simpleCompress();
+      this._simpleCompress(sessionId, messages, messageStore);
     }
   }
 
@@ -358,11 +466,14 @@ class AgentChatHandler extends EventEmitter {
 
   /**
    * 执行实际压缩逻辑
+   * @param {string} sessionId - 会话 ID
+   * @param {Array} messages - 消息数组引用
+   * @param {Object} messageStore - 消息存储对象
    * @private
    */
-  async _doCompress() {
-    const systemMessages = this._messages.filter((m) => m.role === 'system');
-    const otherMessages = this._messages.filter((m) => m.role !== 'system');
+  async _doCompress(sessionId, messages, messageStore) {
+    const systemMessages = messages.filter((m) => m.role === 'system');
+    const otherMessages = messages.filter((m) => m.role !== 'system');
 
     // 保留最近的 N 条非系统消息
     const recentMessages = otherMessages.slice(-this._keepRecentMessages);
@@ -390,23 +501,117 @@ class AgentChatHandler extends EventEmitter {
       content: summaryContent,
     };
 
-    this._messages = [...systemMessages, summary, ...recentMessages].filter(
-      (item) => item.role !== 'tool'
-    );
+    // 构建保留的消息，确保 tool call 和 tool result 配对不被分离
+    const assistantToolCalls = new Map(); // toolCallId -> assistant message index
+    const toolResults = new Map(); // toolCallId -> tool result indices
+
+    // 第一遍：找出所有 tool call 和它们的 results
+    for (let i = 0; i < recentMessages.length; i++) {
+      const msg = recentMessages[i];
+      if (msg.role === 'assistant' && msg.content) {
+        const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+        for (const item of content) {
+          if (item.type === 'tool-call' && item.toolCallId) {
+            assistantToolCalls.set(item.toolCallId, i);
+          }
+        }
+      }
+      if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        // 遍历 tool message 中的所有 tool-results
+        for (const item of msg.content) {
+          if (item && item.type === 'tool-result' && item.toolCallId) {
+            if (!toolResults.has(item.toolCallId)) {
+              toolResults.set(item.toolCallId, []);
+            }
+            toolResults.get(item.toolCallId).push(i);
+          }
+        }
+      }
+    }
+
+    // 第二遍：找出哪些 tool call 没有对应的 result（需要保留）
+    const orphanToolCalls = new Set();
+    for (const [toolCallId, assistantIdx] of assistantToolCalls) {
+      if (!toolResults.has(toolCallId)) {
+        orphanToolCalls.add(toolCallId);
+      }
+    }
+
+    // 过滤时保留：有 result 的 tool call，以及没有 result 的 tool call（但要附带其 result）
+    const indicesToKeep = new Set();
+    for (let i = 0; i < recentMessages.length; i++) {
+      const msg = recentMessages[i];
+      if (msg.role === 'tool') {
+        // 保留所有 tool result（它们是必要的）
+        indicesToKeep.add(i);
+      } else if (msg.role === 'assistant') {
+        // 检查这个 assistant 消息是否有 tool call
+        let hasToolCall = false;
+        if (msg.content) {
+          const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+          for (const item of content) {
+            if (item.type === 'tool-call' && item.toolCallId) {
+              hasToolCall = true;
+              break;
+            }
+          }
+        }
+        if (hasToolCall) {
+          indicesToKeep.add(i);
+        } else if (i >= recentMessages.length - 3) {
+          // 保留最近几条 assistant 消息（它们可能包含重要上下文）
+          indicesToKeep.add(i);
+        }
+      } else {
+        // user, system 等角色默认保留
+        indicesToKeep.add(i);
+      }
+    }
+
+    // 如果有孤儿的 tool call（没有 result），保留该 assistant 消息
+    for (const [toolCallId, assistantIdx] of assistantToolCalls) {
+      if (!toolResults.has(toolCallId)) {
+        indicesToKeep.add(assistantIdx);
+      }
+    }
+
+    // 按索引排序并重建消息数组
+    const sortedIndices = Array.from(indicesToKeep).sort((a, b) => a - b);
+    const filteredRecentMessages = sortedIndices.map((i) => recentMessages[i]);
+
+    // 直接修改传入的 messages 数组
+    messages.length = 0;
+    messages.push(...systemMessages, summary, ...filteredRecentMessages);
+
+    // 更新压缩状态
     this._compressionCount++;
-    const totalTokens = this._countMessagesTokens(this._messages);
+    if (messageStore.compressionState) {
+      messageStore.compressionState.count++;
+      messageStore.compressionState.lastCompressedAt = Date.now();
+      messageStore.compressionState.lastTokenCount = this._countMessagesTokens(messages);
+    }
+
+    const totalTokens = this._countMessagesTokens(messages);
     logger.info(
-      `Context compressed (${this._compressionCount} times). Messages: ${this._messages.length}, Est. tokens: ${totalTokens}`
+      `Context compressed (${this._compressionCount} times). Messages: ${messages.length}, Est. tokens: ${totalTokens}`
     );
+
+    // 压缩后立即同步到 session
+    if (sessionId) {
+      this._saveHistoryToSession(sessionId, messages);
+    }
   }
 
   /**
    * 简单压缩（当 AI 压缩失败时使用）
+   * @param {string} sessionId - 会话 ID
+   * @param {Array} messages - 消息数组引用
+   * @param {Object} messageStore - 消息存储对象
    * @private
    */
-  _simpleCompress() {
-    const systemMessages = this._messages.filter((m) => m.role === 'system');
-    const otherMessages = this._messages.filter((m) => m.role !== 'system');
+  _simpleCompress(sessionId, messages, messageStore) {
+    const systemMessages = messages.filter((m) => m.role === 'system');
+    const otherMessages = messages.filter((m) => m.role !== 'system');
     const recentMessages = otherMessages.slice(-this._keepRecentMessages);
     const compressedCount = otherMessages.length - this._keepRecentMessages;
 
@@ -417,14 +622,103 @@ class AgentChatHandler extends EventEmitter {
       content: summaryContent,
     };
 
-    this._messages = [...systemMessages, summary, ...recentMessages].filter(
-      (item) => item.role !== 'tool'
-    );
+    // 构建保留的消息，确保 tool call 和 tool result 配对不被分离
+    const assistantToolCalls = new Map(); // toolCallId -> assistant message index
+    const toolResults = new Map(); // toolCallId -> tool result indices
+
+    // 第一遍：找出所有 tool call 和它们的 results
+    for (let i = 0; i < recentMessages.length; i++) {
+      const msg = recentMessages[i];
+      if (msg.role === 'assistant' && msg.content) {
+        const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+        for (const item of content) {
+          if (item.type === 'tool-call' && item.toolCallId) {
+            assistantToolCalls.set(item.toolCallId, i);
+          }
+        }
+      }
+      if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        // 遍历 tool message 中的所有 tool-results
+        for (const item of msg.content) {
+          if (item && item.type === 'tool-result' && item.toolCallId) {
+            if (!toolResults.has(item.toolCallId)) {
+              toolResults.set(item.toolCallId, []);
+            }
+            toolResults.get(item.toolCallId).push(i);
+          }
+        }
+      }
+    }
+
+    // 第二遍：找出哪些 tool call 没有对应的 result（需要保留）
+    const orphanToolCalls = new Set();
+    for (const [toolCallId, assistantIdx] of assistantToolCalls) {
+      if (!toolResults.has(toolCallId)) {
+        orphanToolCalls.add(toolCallId);
+      }
+    }
+
+    // 过滤时保留：有 result 的 tool call，以及没有 result 的 tool call
+    const indicesToKeep = new Set();
+    for (let i = 0; i < recentMessages.length; i++) {
+      const msg = recentMessages[i];
+      if (msg.role === 'tool') {
+        // 保留所有 tool result
+        indicesToKeep.add(i);
+      } else if (msg.role === 'assistant') {
+        let hasToolCall = false;
+        if (msg.content) {
+          const content = Array.isArray(msg.content) ? msg.content : [msg.content];
+          for (const item of content) {
+            if (item.type === 'tool-call' && item.toolCallId) {
+              hasToolCall = true;
+              break;
+            }
+          }
+        }
+        if (hasToolCall) {
+          indicesToKeep.add(i);
+        } else if (i >= recentMessages.length - 3) {
+          // 保留最近几条 assistant 消息
+          indicesToKeep.add(i);
+        }
+      } else {
+        // user, system 等角色默认保留
+        indicesToKeep.add(i);
+      }
+    }
+
+    // 如果有孤儿的 tool call（没有 result），保留该 assistant 消息
+    for (const [toolCallId, assistantIdx] of assistantToolCalls) {
+      if (!toolResults.has(toolCallId)) {
+        indicesToKeep.add(assistantIdx);
+      }
+    }
+
+    // 按索引排序并重建消息数组
+    const sortedIndices = Array.from(indicesToKeep).sort((a, b) => a - b);
+    const filteredRecentMessages = sortedIndices.map((i) => recentMessages[i]);
+
+    // 直接修改传入的 messages 数组
+    messages.length = 0;
+    messages.push(...systemMessages, summary, ...filteredRecentMessages);
+
+    // 更新压缩状态
     this._compressionCount++;
+    if (messageStore.compressionState) {
+      messageStore.compressionState.count++;
+      messageStore.compressionState.lastCompressedAt = Date.now();
+      messageStore.compressionState.lastTokenCount = this._countMessagesTokens(messages);
+    }
 
     logger.info(
-      `Context simple compressed (${this._compressionCount} times). Messages: ${this._messages.length}`
+      `Context simple compressed (${this._compressionCount} times). Messages: ${messages.length}`
     );
+
+    // 压缩后立即同步到 session
+    if (sessionId) {
+      this._saveHistoryToSession(sessionId, messages);
+    }
   }
 
   /**
@@ -608,23 +902,34 @@ ${truncatedContent}${truncatedNote}
    * @param {string} sessionId - 可选，指定 session 则同时清除 session 中的历史
    */
   clearHistory(sessionId) {
-    this._messages = [];
-    this._compressionCount = 0;
-
-    // 同时清除 session 中的历史
-    if (sessionId && this.agent?.framework) {
-      try {
-        const sessionPlugin = this.agent.framework.pluginManager.get('session');
-        if (sessionPlugin) {
-          const session = sessionPlugin.getSession(sessionId);
-          if (session) {
-            session.messages = [];
+    if (sessionId) {
+      // 清除 Per-Session 消息存储
+      const messageStore = this._sessionMessageStores.get(sessionId);
+      if (messageStore) {
+        messageStore.messages = [];
+        messageStore.historyLoaded = false;
+        messageStore.compressionState = {
+          lastCompressedAt: null,
+          lastTokenCount: 0,
+          count: 0,
+        };
+      }
+      // 清除 SessionContext 中的历史
+      if (this.agent?.framework) {
+        try {
+          const sessionCtx = this.agent.framework.getSessionContext(sessionId);
+          if (sessionCtx) {
+            sessionCtx.clearMessages();
           }
+        } catch (err) {
+          // 忽略错误
         }
-      } catch (err) {
-        // 忽略错误
       }
+    } else {
+      // 清除所有 Per-Session 消息存储
+      this._sessionMessageStores.clear();
     }
+    this._compressionCount = 0;
     return this;
   }
 
@@ -653,26 +958,30 @@ ${truncatedContent}${truncatedNote}
   }
 
   /**
-   * 发送消息（非流式）
+   * 发送消息（非流式）- 使用队列机制
    * @param {string|Object} message - 消息
    * @param {Object} options - 选项
    */
   async chat(message, options = {}) {
     const sessionId = options.sessionId || null;
-    const context = { sessionId, isStream: false };
+    return this.enqueue(sessionId, message, options);
+  }
+
+  /**
+   * 执行实际聊天逻辑
+   * @param {string|Object} message - 消息
+   * @param {Object} options - 选项
+   * @private
+   */
+  async _doChat(message, options = {}) {
+    const sessionId = options.sessionId || null;
     const framework = this.agent.framework;
-    const self = this; // 保存引用用于回调
 
-    try {
-      // 从 session 加载聊天历史
-      if (sessionId) {
-        const savedMessages = this._loadHistoryFromSession(sessionId);
-        if (savedMessages.length > 0) {
-          this._messages = savedMessages;
-          logger.info(`Loaded ${savedMessages.length} messages from session ${sessionId}`);
-        }
-      }
+    // 获取 Per-Session 的消息存储（自动从 session 加载）
+    const messageStore = this._getSessionMessageStore(sessionId);
+    const messages = messageStore.messages;
 
+    try {
       // 关键：每次 chat 调用时刷新系统提示词，确保包含最新的工具/技能描述
       // 解决上下文过长时 LLM 不调用工具的问题
       this._systemPrompt = this.agent._buildSystemPrompt();
@@ -681,11 +990,10 @@ ${truncatedContent}${truncatedNote}
 
       const userMessage =
         typeof message === 'string' ? { role: 'user', content: message } : message;
-      //console.log('System Prompt:', this._systemPrompt);
-      this._messages.push(userMessage);
+      messages.push(userMessage);
 
       // 检查是否需要压缩上下文（包括工具定义）
-      const messagesTokens = this._countMessagesTokens(this._messages);
+      const messagesTokens = this._countMessagesTokens(messages);
       const toolsTokens = this._countToolsTokens();
       const systemPromptTokens = this._countTokens(this._systemPrompt);
       const totalTokens = messagesTokens + toolsTokens + systemPromptTokens;
@@ -695,55 +1003,75 @@ ${truncatedContent}${truncatedNote}
         logger.info(
           `Context large (${totalTokens}/${this._maxContextTokens} tokens = msgs:${messagesTokens} + tools:${toolsTokens} + sys:${systemPromptTokens}), compressing...`
         );
-        // 使用带超时控制的压缩
-        await this._compressContext();
+        // 使用带超时控制的压缩（传入 messages 引用）
+        await this._compressContext(sessionId, messages, messageStore);
       }
 
       const maxSteps = options.maxSteps || this._maxSteps;
       const tools = this._getAITools(tool);
 
+      // 准备传给 agent 的消息
+      const prepareStepChainStream = async ({ stepNumber, messages }) => {
+        try {
+          // 1. 验证消息格式
+          if (!Array.isArray(messages)) {
+            logger.warn('prepareStep received non-array messages');
+            return messages;
+          }
+
+          // 2. 消息数量超过阈值才修剪
+          if (messages.length <= 50) {
+            return messages;
+          }
+
+          // 3. 保留配对完整的消息
+          const pruned = this._prepareMessagesForAI(messages);
+          return pruned;
+        } catch (err) {
+          logger.error('prepareStep error:', err.message);
+          return messages; // 出错时返回原消息
+        }
+      };
+
       if (!this._aiClient) {
         throw new Error('AI client not configured.');
       }
 
-      // 准备传给 agent 的消息
-      // ToolLoopAgent 会自动处理消息格式，不需要手动 prune
+      // 不使用 prepareStep，消息格式已在 _saveHistoryToSession 中处理
       const agent = new ToolLoopAgent({
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
-        //stopWhen: stepCountIs(maxSteps),
-        prepareStep: async ({ stepNumber, messages }) =>
-          this._prepareStepForPruning(stepNumber, messages),
+        prepareStep: prepareStepChainStream,
       });
 
-      // 使用 runWithContext 让工具执行时能获取 sessionId
-      const result = await framework.runWithContext(context, async () => {
-        return agent.generate({ messages: this._messages, ...this.providerOptions });
+      // 使用 runInSession 让工具执行时能获取 sessionId（Per-Session 隔离）
+      const result = await framework.runInSession(sessionId, {}, async () => {
+        return agent.generate({ messages, ...this.providerOptions });
       });
 
-      this._messages.push(...result.response.messages);
+      messages.push(...result.response.messages);
+
+      // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
+      const userMsg = messages[messages.length - result.response.messages.length - 1];
+      this.emit('message', { userMessage: userMsg, assistantResponse: result.text });
 
       // 生成后检查：如果消息太长，下次需要压缩
-      const afterTokens = this._countMessagesTokens(this._messages);
+      const afterTokens = this._countMessagesTokens(messages);
       if (afterTokens > this._maxContextTokens * 0.8) {
         logger.info(`After generation: ${afterTokens} tokens, will compress on next turn`);
       }
 
-      // 保存聊天历史到 session
-      if (sessionId) {
-        this._saveHistoryToSession(sessionId, this._messages);
-      }
-
       return {
         success: true,
         message: result.text || '',
         stepCount: result.stepCount || 1,
       };
-    } catch (err) {
-      this.emit('error', { error: err.message });
-      // 抛出错误而不是返回错误响应，让 Agent 能捕获
-      throw err;
+    } finally {
+      // 校验并修复消息中的不完整工具调用
+      this._validateToolCalls(messages);
+      // 确保保存聊天历史到 session（无论成功还是失败）
+      messageStore.save();
     }
   }
 
@@ -754,19 +1082,13 @@ ${truncatedContent}${truncatedNote}
    */
   async *chatStream(message, options = {}) {
     const sessionId = options.sessionId || null;
-    const context = { sessionId, isStream: true };
     const framework = this.agent.framework;
 
-    try {
-      //从 session 加载聊天历史
-      if (sessionId) {
-        const savedMessages = this._loadHistoryFromSession(sessionId);
-        if (savedMessages.length > 0) {
-          this._messages = savedMessages;
-          logger.info(`Loaded ${savedMessages.length} messages from session ${sessionId}`);
-        }
-      }
+    // 获取 Per-Session 的消息存储
+    const messageStore = this._getSessionMessageStore(sessionId);
+    const messages = messageStore.messages;
 
+    try {
       // 关键：每次 chat 调用时刷新系统提示词，确保包含最新的工具/技能描述
       // 解决上下文过长时 LLM 不调用工具的问题
       this._systemPrompt = this.agent._buildSystemPrompt();
@@ -775,23 +1097,21 @@ ${truncatedContent}${truncatedNote}
 
       const userMessage =
         typeof message === 'string' ? { role: 'user', content: message } : message;
-      //console.log('System Prompt:', this._systemPrompt);
-      this._messages.push(userMessage);
+      messages.push(userMessage);
 
       // 检查是否需要压缩上下文（包括工具定义）
-      const messagesTokens = this._countMessagesTokens(this._messages);
+      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.7; // 降低到 70%
-      //console.log(messagesTokens,toolsTokens,systemPromptTokens,totalTokens,this._maxContextTokens)
       // 对于流式调用，如果上下文太大，先压缩再开始
       if (totalTokens > limit) {
         logger.info(
           `Context large (${totalTokens}/${this._maxContextTokens} tokens), compressing...`
         );
         // 流式调用时等待压缩完成（使用带超时控制的压缩）
-        await this._compressContext();
+        await this._compressContext(sessionId, messages, messageStore);
       }
 
       const maxSteps = options.maxSteps || this._maxSteps;
@@ -801,20 +1121,39 @@ ${truncatedContent}${truncatedNote}
       }
 
       // 准备传给 agent 的消息
-      // ToolLoopAgent 会自动处理消息格式，不需要手动 prune
+      const prepareStepChainStream = async ({ stepNumber, messages }) => {
+        try {
+          // 1. 验证消息格式
+          if (!Array.isArray(messages)) {
+            logger.warn('prepareStep received non-array messages');
+            return messages;
+          }
+
+          // 2. 消息数量超过阈值才修剪
+          if (messages.length <= 50) {
+            return messages;
+          }
+
+          // 3. 保留配对完整的消息
+          const pruned = this._prepareMessagesForAI(messages);
+          return pruned;
+        } catch (err) {
+          logger.error('prepareStep error:', err.message);
+          return messages; // 出错时返回原消息
+        }
+      };
+
       const agent = new ToolLoopAgent({
         model: this._aiClient,
         instructions: this._systemPrompt,
         tools: tools,
-        //stopWhen: stepCountIs(maxSteps),
-        prepareStep: async ({ stepNumber, messages }) =>
-          this._prepareStepForPruning(stepNumber, messages),
+        prepareStep: prepareStepChainStream,
       });
 
-      // 使用 runWithContext 让工具执行时能获取 sessionId（支持并行）
-      const result = await framework.runWithContext(context, async () => {
+      // 使用 runInSession 让工具执行时能获取 sessionId（Per-Session 隔离）
+      const result = await framework.runInSession(sessionId, {}, async () => {
         return agent.stream({
-          messages: this._messages,
+          messages,
           ...this.providerOptions,
         });
       });
@@ -842,18 +1181,106 @@ ${truncatedContent}${truncatedNote}
       }
 
       const finishMessages = (await result.response).messages;
-      this._messages.push(...finishMessages);
+      messages.push(...finishMessages);
 
-      // 保存聊天历史到 session（使用实际传给 agent 的消息一致）
-      if (sessionId) {
-        this._saveHistoryToSession(sessionId, this._messages);
-      }
+      // 触发 agent:message 事件，让 memory 插件可以自动提取记忆
+      const userMsg = messages[messages.length - finishMessages.length - 1];
+      this.emit('message', { userMessage: userMsg, assistantResponse: fullText });
     } catch (err) {
       this.emit('error', { error: err.message });
       yield { type: 'error', error: err.message };
+    } finally {
+      // 校验并修复消息中的不完整工具调用
+      this._validateToolCalls(messages);
+      // 确保保存聊天历史到 session（无论成功还是失败）
+      messageStore.save();
     }
   }
 
+  /**
+   * 为 AI SDK prepareStep 准备消息
+   * 确保 tool call 和 tool result 正确配对
+   * @param {Array} messages - 消息列表
+   * @returns {Array} 过滤后的消息数组
+   * @private
+   */
+  _prepareMessagesForAI(messages) {
+    if (messages.length <= 10) {
+      return messages;
+    }
+
+    // 收集所有 assistant 的 tool-call
+    const assistantToolCalls = new Map(); // toolCallId -> message index
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.role === 'assistant' && Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type === 'tool-call' && item.toolCallId) {
+            assistantToolCalls.set(item.toolCallId, i);
+          }
+        }
+      }
+    }
+
+    // 收集配对的 tool results
+    const pairedToolResults = new Set(); // 保留的 tool result indices
+    for (let i = 0; i < messages.length; i++) {
+      const msg = messages[i];
+      if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        for (const item of msg.content) {
+          if (item.type === 'tool-result' && item.toolCallId) {
+            if (assistantToolCalls.has(item.toolCallId)) {
+              pairedToolResults.add(i);
+            }
+          }
+        }
+      }
+    }
+
+    // 过滤：保留最近的消息，但确保 tool call/result 配对完整
+    const recentCount = Math.max(20, messages.length - 10);
+    const minIndexToKeep = messages.length - recentCount;
+
+    const result = [];
+    for (let i = minIndexToKeep; i < messages.length; i++) {
+      const msg = messages[i];
+
+      if (msg.role === 'tool') {
+        // 只保留有配对的 tool messages
+        if (pairedToolResults.has(i)) {
+          result.push(msg);
+        }
+      } else if (msg.role === 'assistant') {
+        // 检查是否有未配对的 tool-call
+        if (Array.isArray(msg.content)) {
+          const hasUnpairedToolCall = msg.content.some(
+            (item) => item.type === 'tool-call' && !assistantToolCalls.has(item.toolCallId)
+          );
+          if (hasUnpairedToolCall) {
+            // 过滤掉未配对的 tool-call
+            const filteredContent = msg.content.filter((item) => {
+              if (item.type === 'tool-call') {
+                return assistantToolCalls.has(item.toolCallId);
+              }
+              return true;
+            });
+            if (filteredContent.length > 0) {
+              result.push({ ...msg, content: filteredContent });
+            }
+          } else {
+            result.push(msg);
+          }
+        } else {
+          result.push(msg);
+        }
+      } else {
+        result.push(msg);
+      }
+    }
+
+    return result;
+  }
+
   /**
    * 修剪消息确保配对的 tool call/result 不被拆分
    * @param {number} stepNumber - 当前步骤号
@@ -880,11 +1307,16 @@ ${truncatedContent}${truncatedNote}
           }
         }
       }
-      if (msg.role === 'tool' && msg.toolCallId) {
-        if (!toolResultIndices.has(msg.toolCallId)) {
-          toolResultIndices.set(msg.toolCallId, []);
+      if (msg.role === 'tool' && Array.isArray(msg.content)) {
+        // 遍历 tool message 中的所有 tool-results
+        for (const item of msg.content) {
+          if (item && item.type === 'tool-result' && item.toolCallId) {
+            if (!toolResultIndices.has(item.toolCallId)) {
+              toolResultIndices.set(item.toolCallId, []);
+            }
+            toolResultIndices.get(item.toolCallId).push(i);
+          }
         }
-        toolResultIndices.get(msg.toolCallId).push(i);
       }
     }
 
@@ -917,6 +1349,49 @@ ${truncatedContent}${truncatedNote}
     return { messages: pruned };
   }
 
+  /**
+   * 校验并修复消息中的工具调用参数
+   * 移除不完整的 JSON（如只有 "{" ）的工具调用
+   * @param {Array} messages - 消息列表
+   * @private
+   */
+  _validateToolCalls(messages) {
+    let fixedCount = 0;
+
+    for (const msg of messages) {
+      if (msg.role !== 'assistant' || !Array.isArray(msg.content)) {
+        continue;
+      }
+
+      for (const item of msg.content) {
+        if (item.type !== 'tool-call') {
+          continue;
+        }
+
+        const input = item.input;
+        if (typeof input !== 'string') {
+          continue;
+        }
+
+        // 检查 input 是否是有效的 JSON（不是不完整的）
+        const trimmed = input.trim();
+        if (trimmed === '{' || trimmed === '' || !trimmed.startsWith('{')) {
+          // 不完整的 JSON，移除这个 tool-call
+          item.type = 'text';
+          item.text = `（工具调用 ${item.toolName} 参数不完整，已跳过）`;
+          delete item.toolCallId;
+          delete item.toolName;
+          delete item.input;
+          fixedCount++;
+        }
+      }
+    }
+
+    if (fixedCount > 0) {
+      logger.info(`Fixed ${fixedCount} incomplete tool calls`);
+    }
+  }
+
   /**
    * 获取 AI SDK 格式的工具
    * AI SDK 6.x 需要对象形式 { toolName: tool }
@@ -943,7 +1418,10 @@ ${truncatedContent}${truncatedNote}
           try {
             const result = await toolDef.execute(cleanedArgs, this.agent.framework);
             this.emit('tool-result', { name: toolName, args: cleanedArgs, result });
-            return result;
+            if (result !== null && typeof result === 'object') {
+              return JSON.stringify(result);
+            }
+            return String(result);
           } catch (err) {
             this.emit('tool-error', { name: toolName, args: cleanedArgs, error: err.message });
             return { error: err.message };
@@ -1001,43 +1479,12 @@ ${truncatedContent}${truncatedNote}
     return cleaned;
   }
 
-  /**
-   * 清理消息格式
-   * @private
-   */
-  _cleanMessages(messages) {
-    return messages.map((msg) => {
-      if (!msg || typeof msg !== 'object') {
-        return { role: 'user', content: '' };
-      }
-
-      const cleaned = {
-        role: msg.role || 'user',
-      };
-
-      if (Array.isArray(msg.content)) {
-        cleaned.content = msg.content;
-      } else if (typeof msg.content === 'string') {
-        cleaned.content = msg.content;
-      } else if (typeof msg.content === 'object' && msg.content !== null) {
-        // 对象类型的 content（如 tool result），转为字符串
-        cleaned.content =
-          typeof msg.content === 'object' && msg.content.content !== undefined
-            ? String(msg.content.content)
-            : JSON.stringify(msg.content);
-      } else {
-        cleaned.content = msg.text || msg.input || '';
-      }
-
-      return cleaned;
-    });
-  }
-
   /**
    * 销毁
    */
   destroy() {
-    this._messages = [];
+    this._sessionMessageStores.clear();
+    this._sessionMessageStores = new Map();
     this._tools.clear();
     this._encoder = null;
     this.removeAllListeners();