foliko 1.1.13 → 1.1.14

package/src/core/agent.js

@@ -6,6 +6,7 @@
 const { EventEmitter } = require('../utils/event-emitter');
 const { AgentChatHandler } = require('./agent-chat');
 const { SystemPromptBuilder } = require('./system-prompt-builder');
+const { NotificationManager } = require('./notification-manager');
 const { zodSchemaToMarkdown, zodSchemaToTable } = require('@chnak/zod-to-markdown');
 const { zodSchema } = require('ai');
 const os = require('os');
@@ -120,6 +121,9 @@ class Agent extends EventEmitter {
     // 处理后的 system prompt (带上下文)
     this.systemPrompt = this._buildSystemPrompt();
 
+    // 通知管理器
+    this._notificationManager = new NotificationManager(framework);
+
     // 初始化聊天处理器
     this._initChatHandler();
 
@@ -246,21 +250,26 @@ class Agent extends EventEmitter {
    * 构建工具描述（直接调用的工具）
    */
   _buildToolsDescription() {
-    if (this._tools.size === 0) {
+    const tools = this.framework.getTools();
+    if (!tools || tools.length === 0) {
       return '';
     }
 
     const directTools = [];
 
-    for (const [name, tool] of this._tools) {
+    for (const tool of tools) {
       if (!tool.description) continue;
 
       // MCP 和 ext 工具不在这里显示，它们通过专门的描述部分提供
-      if (name.startsWith('mcp_') || name.startsWith('ext_') || name.startsWith('workflow_')) {
+      if (
+        tool.name.startsWith('mcp_') ||
+        tool.name.startsWith('ext_') ||
+        tool.name.startsWith('workflow_')
+      ) {
         continue;
       }
 
-      directTools.push({ name, tool });
+      directTools.push({ name: tool.name, tool });
     }
 
     if (directTools.length === 0) {
@@ -610,45 +619,7 @@ class Agent extends EventEmitter {
       return '';
     }
 
-    // 使用数组收集 + join 模式优化字符串拼接
-    const lines = ['## 子 Agent 匹配表', ''];
-    lines.push('');
-    lines.push('> **提示**：根据任务类型选择最匹配的子 Agent 处理');
-    lines.push('');
-
-    // 动态从配置文件读取每个子Agent的核心能力
-    for (const plugin of allSubAgents) {
-      const name = plugin.name;
-      const role = plugin.role;
-      const goal = plugin.description || '';
-
-      // 优先使用 SubAgentConfigManager 获取详细信息
-      const config = this.framework._subAgentConfigManager?.get(name);
-      if (config) {
-        const agentDesc = config.getDescription();
-        const skills = config.getSkills();
-        let info = agentDesc || role || goal || '子代理';
-        if (skills && skills.length > 0) {
-          info += ` (技能: ${skills.join(', ')})`;
-        }
-        lines.push(`- **${name}**：${info}`);
-      } else {
-        // 回退到旧逻辑
-        lines.push(`- **${name}**：${role || goal || '子代理'}`);
-      }
-    }
-
-    // 通用规则
-    lines.push('');
-    lines.push('### 子 Agent 调用规则');
-    lines.push('');
-    lines.push('> **重要**：必须严格遵守以下规则');
-    lines.push('');
-    lines.push('1. 根据上述「子 Agent 匹配表」，将任务委托给最匹配的子 Agent 处理');
-    lines.push('2. 使用 `subagent_call` 工具并指定 `agentName` 来委托任务');
-    lines.push('3. 只有当没有匹配的子 Agent 时，才直接调用工具');
-
-    return lines.join('\n');
+    return subAgentManager._buildDescription();
   }
 
   /**
@@ -924,35 +895,38 @@ class Agent extends EventEmitter {
   }
 
   /**
-   * 注册工具到 Agent
+   * 注册工具到 Framework（统一入口）
    */
   registerTool(tool) {
-    this._tools.set(tool.name, tool);
-    this._invalidateSystemPromptCache();
+    // 注册到 framework（统一管理）
+    this.framework.registerTool(tool);
+    // 注册到 chatHandler
     if (this._chatHandler) {
       this._chatHandler.registerTool(tool);
     }
+    this._invalidateSystemPromptCache();
     this._refreshContext();
     return this;
   }
 
   /**
-   * 获取已注册工具
+   * 获取已注册工具（从 framework 获取）
    */
   getTools() {
-    return Array.from(this._tools.values());
+    return this.framework.getTools();
   }
 
   /**
-   * 同步框架中的工具到 Agent
+   * 同步框架中的工具到 ChatHandler
    * @private
    */
   _syncTools() {
-    if (this.framework.toolRegistry.size() > 0) {
-      for (const tool of this.framework.getTools()) {
-        if (!this._tools.has(tool.name)) {
-          this.registerTool(tool);
-        }
+    // 从 framework 获取工具并注册到 chatHandler
+    const tools = this.framework.getTools();
+    for (const tool of tools) {
+      // 直接注册到 chatHandler（registerTool 是幂等的）
+      if (this._chatHandler) {
+        this._chatHandler.registerTool(tool);
       }
     }
   }
@@ -988,74 +962,6 @@ class Agent extends EventEmitter {
     return this._subAgents;
   }
 
-  /**
-   * 获取待处理的调度通知并清除（下次不再重复显示）
-   */
-  _getAndClearSchedulerNotifications() {
-    try {
-      const scheduler = this.framework.pluginManager.get('scheduler');
-      if (scheduler && scheduler.instance && scheduler.instance.getPendingNotifications) {
-        const results = scheduler.instance.getPendingNotifications();
-        if (results.length > 0) {
-          // 使用常量替代硬编码数字
-          const notifications = results.slice(-AGENT_CONFIG.MAX_NOTIFICATIONS).reverse();
-          // 清除已发送的通知
-          if (scheduler.instance.clearDeliveredNotifications) {
-            scheduler.instance.clearDeliveredNotifications(notifications.length);
-          }
-          return notifications;
-        }
-      }
-    } catch (err) {
-      logger.warn('Agent', '获取调度通知失败', err.message);
-    }
-    return [];
-  }
-
-  /**
-   * 获取待处理的思考结果并清除
-   */
-  _getAndClearThinkNotifications() {
-    try {
-      const think = this.framework.pluginManager.get('think');
-      if (think && think.instance && think.instance.getPendingThoughts) {
-        const thoughts = think.instance.getPendingThoughts();
-        if (thoughts.length > 0) {
-          // 使用常量替代硬编码数字
-          return thoughts.slice(-AGENT_CONFIG.MAX_NOTIFICATIONS).reverse();
-        }
-      }
-    } catch (err) {
-      logger.warn('Agent', '获取思考通知失败', err.message);
-    }
-    return [];
-  }
-
-  /**
-   * 获取所有待处理的系统通知（调度 + 思考）
-   */
-  _getAllPendingNotifications() {
-    const notifications = [];
-
-    // 调度通知
-    const schedulerNotifs = this._getAndClearSchedulerNotifications();
-    for (const n of schedulerNotifs) {
-      notifications.push(
-        `【定时任务通知】\n任务: ${n.taskName || n.taskId}\n执行时间: ${n.executedAt}\n结果: ${n.result || n.action || '执行完成'}`
-      );
-    }
-
-    // 思考通知
-    const thinkNotifs = this._getAndClearThinkNotifications();
-    for (const t of thinkNotifs) {
-      notifications.push(
-        `【主动思考】\n模式: ${t.mode}\n主题: ${t.topic}\n结果: ${t.result || '思考完成'}`
-      );
-    }
-
-    return notifications;
-  }
-
   /**
    * 发送消息
    */
@@ -1068,12 +974,8 @@ class Agent extends EventEmitter {
     this.emit('status', { status: 'busy' });
 
     try {
-      // 检查是否有待处理的系统通知（调度 + 思考）
-      const notifications = this._getAllPendingNotifications();
-      let enhancedMessage = message;
-      if (notifications.length > 0) {
-        enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
-      }
+      // 使用 NotificationManager 增强消息
+      const enhancedMessage = this._notificationManager.enhanceMessage(message);
 
       // 子agent跳过工具同步，使用createSubAgent时已配置的工具
       if (!this._skipSyncTools) {
@@ -1131,12 +1033,8 @@ class Agent extends EventEmitter {
     this.emit('status', { status: 'busy' });
 
     try {
-      // 检查是否有待处理的系统通知（调度 + 思考）
-      const notifications = this._getAllPendingNotifications();
-      let enhancedMessage = message;
-      if (notifications.length > 0) {
-        enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
-      }
+      // 使用 NotificationManager 增强消息
+      const enhancedMessage = this._notificationManager.enhanceMessage(message);
 
       // 子agent跳过工具同步，使用createSubAgent时已配置的工具
       if (!this._skipSyncTools) {
@@ -1166,6 +1064,27 @@ class Agent extends EventEmitter {
     return this._chatHandler.sendMessage(message, options);
   }
 
+  /**
+   * 流式发送消息（带队列，支持实时yield）
+   */
+  async *sendMessageStream(message, options = {}) {
+    yield* this._chatHandler.sendMessageStream(message, options);
+  }
+
+  /**
+   * 批量发送消息
+   */
+  async sendBatch(messages, options = {}) {
+    return this._chatHandler.sendBatch(messages, options);
+  }
+
+  /**
+   * 取消会话的所有请求
+   */
+  cancelSession(sessionId) {
+    return this._chatHandler.cancelSession(sessionId);
+  }
+
   /**
    * 设置元数据
    */

package/src/core/chat-session.js

@@ -0,0 +1,423 @@
+/**
+ * ChatSession - 会话管理器
+ *
+ * 职责：
+ * 1. 管理 Per-Session 的消息存储
+ * 2. 会话消息历史加载/保存
+ * 3. 会话消息队列管理
+ * 4. SessionScope 事件作用域
+ */
+
+const { EventEmitter } = require('../utils/event-emitter');
+const { ChatQueueManager } = require('../utils/chat-queue');
+const { logger } = require('../utils/logger');
+
+/**
+ * Session 作用域的事件监听器
+ * 自动过滤只属于特定 sessionId 的事件
+ */
+class SessionScope extends EventEmitter {
+  /**
+   * @param {ChatSession} session - ChatSession 实例
+   * @param {string} sessionId - Session ID
+   */
+  constructor(session, sessionId) {
+    super();
+    this.session = session;
+    this.sessionId = sessionId;
+    this._handlers = new Set();
+  }
+
+  /**
+   * 注册事件监听器（自动过滤 sessionId）
+   * @param {string} event - 事件名
+   * @param {Function} handler - 处理函数
+   * @returns {this}
+   */
+  on(event, handler) {
+    const wrapped = (data) => {
+      if (data && data.sessionId !== this.sessionId) return;
+      handler(data);
+    };
+    this._handlers.add({ event, wrapped });
+    this.session.on(event, wrapped);
+    return this;
+  }
+
+  /**
+   * 注册一次性事件监听器
+   */
+  once(event, handler) {
+    const wrapped = (data) => {
+      if (data && data.sessionId !== this.sessionId) return;
+      handler(data);
+    };
+    this._handlers.add({ event, wrapped });
+    this.session.once(event, wrapped);
+    return this;
+  }
+
+  /**
+   * 移除事件监听器
+   */
+  off(event, handler) {
+    const toRemove = [];
+    for (const item of this._handlers) {
+      if (item.event === event && item.handler === handler) {
+        this.session.off(event, item.wrapped);
+        toRemove.push(item);
+      }
+    }
+    for (const item of toRemove) {
+      this._handlers.delete(item);
+    }
+    return this;
+  }
+
+  /**
+   * 移除所有这个 scope 注册的监听器
+   */
+  removeAllListeners() {
+    for (const { event, wrapped } of this._handlers) {
+      this.session.off(event, wrapped);
+    }
+    this._handlers.clear();
+    return this;
+  }
+
+  /**
+   * 获取当前 sessionId
+   */
+  getSessionId() {
+    return this.sessionId;
+  }
+}
+
+class ChatSession extends EventEmitter {
+  /**
+   * @param {Object} config - 配置
+   * @param {Function} [config.messageProcessor] - 消息处理器函数 (sessionId, message, options) => Promise
+   */
+  constructor(config = {}) {
+    super();
+
+    this.config = config;
+    this.agent = config.agent;
+
+    // 消息处理器
+    this._messageProcessor = config.messageProcessor;
+
+    // Session 消息存储 Map: sessionId -> { messages: [], historyLoaded: false, compressionState: {} }
+    this._sessionMessageStores = new Map();
+
+    // Session 队列: sessionId -> Queue of {message, options, resolve, reject}
+    this._sessionQueues = new Map();
+    this._processingSessions = new Set();
+
+    // Session 事件作用域 Map: sessionId -> Set<{event, handler}>
+    this._sessionScopes = new Map();
+
+    // 队列管理器
+    this.queueManager = new ChatQueueManager({
+      maxConcurrent: config.maxConcurrent || 1,
+      retryAttempts: config.retryAttempts || 3,
+      retryDelay: config.retryDelay || 1000,
+    });
+
+    this._setupQueueEvents();
+  }
+
+  /**
+   * 设置消息处理器
+   * @param {Function} processor - (sessionId, message, options) => Promise
+   */
+  setMessageProcessor(processor) {
+    this._messageProcessor = processor;
+  }
+
+  /**
+   * 设置队列事件转发
+   * @private
+   */
+  _setupQueueEvents() {
+    const events = [
+      'queue:added',
+      'queue:processing',
+      'queue:completed',
+      'queue:failed',
+      'queue:retry',
+      'queue:empty',
+      'queue:cleared',
+      'queue:session-removed',
+      'stream:chunk',
+    ];
+
+    events.forEach((eventName) => {
+      this.queueManager.on(eventName, (data) => {
+        this.emit(eventName, data);
+      });
+    });
+  }
+
+  /**
+   * 获取或创建 SessionScope
+   * @param {string} sessionId - Session ID
+   * @returns {SessionScope}
+   */
+  createSessionScope(sessionId) {
+    return new SessionScope(this, sessionId);
+  }
+
+  /**
+   * 获取会话消息存储
+   * @param {string} sessionId - Session ID
+   * @returns {Object} messageStore
+   */
+  getSessionMessageStore(sessionId) {
+    if (!sessionId) {
+      sessionId = 'default';
+    }
+
+    if (!this._sessionMessageStores.has(sessionId)) {
+      const store = {
+        messages: [],
+        historyLoaded: false,
+        usage: null,
+        compressionState: {
+          count: 0,
+          lastCompressedAt: null,
+          lastTokenCount: 0,
+          pendingCompression: false,
+        },
+        save: () => {
+          this.saveHistory(sessionId, store.messages);
+        },
+      };
+      this._sessionMessageStores.set(sessionId, store);
+    }
+
+    return this._sessionMessageStores.get(sessionId);
+  }
+
+  /**
+   * 加载会话历史
+   * @param {string} sessionId - Session ID
+   * @returns {Array} 消息数组
+   */
+  loadHistory(sessionId) {
+    if (!sessionId) return [];
+
+    const messageStore = this.getSessionMessageStore(sessionId);
+    if (messageStore.historyLoaded) {
+      return messageStore.messages;
+    }
+
+    // 从 SessionContext 加载
+    if (this.agent?.framework) {
+      const sessionCtx = this.agent.framework._sessionContexts?.get(sessionId);
+      if (sessionCtx) {
+        const messages = sessionCtx.getMessages();
+        if (messages && messages.length > 0) {
+          messageStore.messages = messages;
+          messageStore.historyLoaded = true;
+          logger.debug(`Loaded ${messages.length} messages for session ${sessionId}`);
+        }
+      }
+    }
+
+    return messageStore.messages;
+  }
+
+  /**
+   * 保存会话历史
+   * @param {string} sessionId - Session ID
+   * @param {Array} messages - 消息数组
+   */
+  saveHistory(sessionId, messages) {
+    if (!sessionId || !messages) return;
+
+    const messageStore = this.getSessionMessageStore(sessionId);
+
+    // 保存到 SessionContext
+    if (this.agent?.framework) {
+      const sessionCtx = this.agent.framework._sessionContexts?.get(sessionId);
+      if (sessionCtx) {
+        sessionCtx.replaceMessages(messages);
+      }
+    }
+
+    messageStore.historyLoaded = true;
+  }
+
+  /**
+   * 添加消息到会话
+   * @param {string} sessionId - Session ID
+   * @param {Object} message - 消息
+   */
+  addMessage(sessionId, message) {
+    const store = this.getSessionMessageStore(sessionId);
+    store.messages.push(message);
+  }
+
+  /**
+   * 入队消息
+   * @param {string} sessionId - Session ID
+   * @param {Object} message - 消息
+   * @param {Object} options - 选项
+   * @returns {Promise}
+   */
+  enqueue(sessionId, message, options = {}) {
+    if (!this._sessionQueues.has(sessionId)) {
+      this._sessionQueues.set(sessionId, []);
+    }
+
+    return new Promise((resolve, reject) => {
+      const item = {
+        message,
+        options,
+        resolve,
+        reject,
+        timestamp: Date.now(),
+        executeFunction: options.executeFunction,
+      };
+      this._sessionQueues.get(sessionId).push(item);
+      this.emit('queue:added', {
+        sessionId,
+        message,
+        queueSize: this._sessionQueues.get(sessionId).length,
+      });
+
+      // 触发队列处理
+      this._processNext(sessionId);
+    });
+  }
+
+  /**
+   * 处理队列中的下一条消息
+   * @param {string} sessionId - Session ID
+   * @private
+   */
+  async _processNext(sessionId) {
+    if (this._processingSessions.has(sessionId)) {
+      return;
+    }
+
+    const queue = this._sessionQueues.get(sessionId);
+    if (!queue || queue.length === 0) {
+      this.emit('queue:empty', { sessionId });
+      return;
+    }
+
+    this._processingSessions.add(sessionId);
+    this.emit('queue:processing', { sessionId });
+
+    const item = queue.shift();
+    try {
+      // 如果有 executeFunction，使用流式处理
+      if (item.executeFunction) {
+        const chunks = [];
+        const stream = item.executeFunction(item.message, { ...item.options, sessionId });
+
+        for await (const chunk of stream) {
+          chunks.push(chunk);
+          this.emit('stream:chunk', {
+            sessionId,
+            chunk,
+            accumulated: chunks.length,
+          });
+        }
+
+        const fullText = chunks
+          .filter((a) => a.type === 'text')
+          .map((item) => item.text)
+          .join('');
+
+        item.resolve({ text: fullText, chunks });
+      } else {
+        const result = await this._processMessage(sessionId, item.message, item.options);
+        item.resolve(result);
+      }
+    } catch (err) {
+      item.reject(err);
+    } finally {
+      this._processingSessions.delete(sessionId);
+      // 处理下一条
+      setImmediate(() => this._processNext(sessionId));
+    }
+  }
+
+  /**
+   * 处理单条消息（子类实现）
+   * @param {string} sessionId - Session ID
+   * @param {Object} message - 消息
+   * @param {Object} options - 选项
+   * @returns {Promise}
+   * @protected
+   */
+  async _processMessage(sessionId, message, options) {
+    // 如果设置了处理器，使用处理器
+    if (this._messageProcessor) {
+      return this._messageProcessor(sessionId, message, options);
+    }
+    // 否则使用 agent 的处理逻辑
+    if (this.agent?._chatHandler) {
+      return this.agent._chatHandler._processMessage(sessionId, message, options);
+    }
+    throw new Error('No message processor set');
+  }
+
+  /**
+   * 取消会话队列
+   * @param {string} sessionId - Session ID
+   */
+  cancelSession(sessionId) {
+    const queue = this._sessionQueues.get(sessionId);
+    if (queue) {
+      queue.forEach((item) => {
+        item.reject(new Error('Session cancelled'));
+      });
+      queue.length = 0;
+    }
+    this._processingSessions.delete(sessionId);
+    this.emit('queue:session-removed', { sessionId });
+  }
+
+  /**
+   * 获取队列状态
+   * @param {string} sessionId - Session ID
+   * @returns {Object}
+   */
+  getQueueStatus(sessionId) {
+    const queue = this._sessionQueues.get(sessionId) || [];
+    return {
+      sessionId,
+      size: queue.length,
+      processing: this._processingSessions.has(sessionId),
+    };
+  }
+
+  /**
+   * 清空队列
+   * @param {string} sessionId - Session ID
+   */
+  clearQueue(sessionId) {
+    const queue = this._sessionQueues.get(sessionId);
+    if (queue) {
+      queue.forEach((item) => {
+        item.reject(new Error('Queue cleared'));
+      });
+      queue.length = 0;
+    }
+    this.emit('queue:cleared', { sessionId });
+  }
+
+  /**
+   * 生成请求 ID
+   * @returns {string}
+   */
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).slice(2, 9)}`;
+  }
+}
+
+module.exports = { ChatSession, SessionScope };