foliko 1.1.11 → 1.1.13

package/src/core/agent-chat.js

@@ -6,25 +6,10 @@
 const { EventEmitter } = require('../utils/event-emitter');
 const { logger } = require('../utils/logger');
 const { generateText, stepCountIs, isLoopFinished } = require('ai');
-const { prepareMessagesForAPI } = require('../utils');
+const { prepareMessagesForAPI, cleanResponse } = require('../utils');
+const { ChatQueueManager } = require('../utils/chat-queue');
 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 = {
   // DeepSeek
@@ -96,102 +81,6 @@ const _globalTokenizer = new SimpleTokenizer();
 // 压缩超时时间（毫秒）
 const COMPRESSION_TIMEOUT = 120000;
 
-/**
- * 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 result = await this.sendMessage(task);
-      if (result.type === 'error') {
-        task.reject(new Error(result.error));
-        if (task.onError) {
-          await task.onError(new Error(result.error), ctx);
-        }
-      } else {
-        task.resolve(result.text);
-        if (task.onComplete) {
-          await task.onComplete(result.text, 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 = '';
-
-    try {
-      for await (const chunk of this.chatHandler.chatStream(message, { sessionId })) {
-        // 检查错误类型的 chunk
-        if (chunk.type === 'error') {
-          return { type: 'error', error: chunk.error, text: fullText };
-        }
-        fullText += chunk.text || '';
-        if (onChunk) {
-          onChunk(chunk);
-        }
-      }
-    } catch (err) {
-      return { type: 'error', error: err.message, text: fullText };
-    }
-
-    return { type: 'complete', text: fullText };
-  }
-}
-
 class AgentChatHandler extends EventEmitter {
   /**
    * @param {Agent} agent - Agent 实例
@@ -243,8 +132,20 @@ 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);
+    // 初始化队列管理器
+    this.queueManager = new ChatQueueManager({
+      maxConcurrent: config.maxConcurrent || 1,
+      retryAttempts: config.retryAttempts || 3,
+      retryDelay: config.retryDelay || 1000,
+    });
+
+    // 转发队列事件到 AgentChatHandler
+    this.forwardQueueEvents();
+
+    // 可选：启用队列日志
+    // if (config.enableQueueLogging) {
+    //   this.enableQueueLogging();
+    // }
 
     // Session Memory prepareStep（从 memory 插件获取）
     this._sessionMemoryPrepareStep = null;
@@ -257,6 +158,334 @@ class AgentChatHandler extends EventEmitter {
     }
   }
 
+  /**
+   * 转发队列事件到自身，方便外部监听
+   */
+  forwardQueueEvents() {
+    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 指向 AgentChatHandler
+        this.emit(eventName, data);
+      });
+    });
+
+    // Session 事件作用域管理
+    this._sessionScopes = new Map(); // sessionId -> Set<{event, handler}>
+  }
+
+  /**
+   * 创建 Session 作用域的事件监听器
+   * 所有通过返回对象注册的事件监听器都只接收属于指定 sessionId 的事件
+   * @param {string} sessionId - Session ID
+   * @returns {Object} { on, once, off, removeAllListeners }
+   */
+  createSessionScope(sessionId) {
+    const scope = this;
+    const handlers = new Set(); // 记录这个 scope 注册的所有 handler
+
+    // 创建包装 handler，自动过滤 sessionId
+    const wrapHandler = (handler) => {
+      return (data) => {
+        // 检查 data 中的 sessionId
+        if (data && data.sessionId !== sessionId) {
+          return; // 不是当前 scope 的 session，跳过
+        }
+        handler(data);
+      };
+    };
+
+    const wrappedHandlers = new WeakMap(); // original -> wrapped
+
+    return {
+      /**
+       * 监听事件（自动过滤 sessionId）
+       */
+      on(event, handler) {
+        const wrapped = wrapHandler(handler);
+        wrappedHandlers.set(handler, wrapped);
+        handlers.add({ event, handler, wrapped });
+        scope.on(event, wrapped);
+        return this;
+      },
+
+      /**
+       * 监听一次性事件
+       */
+      once(event, handler) {
+        const wrapped = wrapHandler(handler);
+        wrappedHandlers.set(handler, wrapped);
+        handlers.add({ event, handler, wrapped });
+        scope.once(event, wrapped);
+        return this;
+      },
+
+      /**
+       * 取消监听（精确移除）
+       */
+      off(event, handler) {
+        const wrapped = wrappedHandlers.get(handler);
+        if (wrapped) {
+          scope.off(event, wrapped);
+          wrappedHandlers.delete(handler);
+        }
+        // 从 handlers 中移除
+        for (const item of handlers) {
+          if (item.event === event && item.handler === handler) {
+            handlers.delete(item);
+            break;
+          }
+        }
+        return this;
+      },
+
+      /**
+       * 移除当前 scope 注册的所有监听器
+       */
+      removeAllListeners() {
+        for (const { event, wrapped } of handlers) {
+          scope.off(event, wrapped);
+        }
+        handlers.clear();
+        return this;
+      },
+
+      /**
+       * 获取当前绑定的 sessionId
+       */
+      getSessionId() {
+        return sessionId;
+      },
+    };
+  }
+
+  /**
+   * 启用队列日志（可选）
+   */
+  enableQueueLogging() {
+    this.queueManager.on('queue:added', (data) => {
+      console.log(`[Queue] Request ${data.requestId} added. Queue length: ${data.queueLength}`);
+    });
+
+    this.queueManager.on('queue:processing', (data) => {
+      console.log(
+        `[Queue] Processing ${data.requestId}, Active: ${data.activeCount}, Remaining: ${data.remaining}`
+      );
+    });
+
+    this.queueManager.on('queue:completed', (data) => {
+      console.log(`[Queue] Request ${data.requestId} completed in ${data.duration}ms`);
+    });
+
+    this.queueManager.on('queue:failed', (data) => {
+      console.error(`[Queue] Request ${data.requestId} failed: ${data.error}`);
+    });
+
+    this.queueManager.on('queue:empty', () => {
+      console.log('[Queue] Queue is empty');
+    });
+  }
+
+  /**
+   * 发送消息（带队列）
+   */
+  async sendMessage(message, options = {}) {
+    const sessionId = options.sessionId || this.getDefaultSessionId();
+    const requestId = this.generateRequestId();
+
+    this.emit('message:start', {
+      requestId,
+      sessionId,
+      message,
+      timestamp: Date.now(),
+    });
+
+    try {
+      const result = await this.queueManager.enqueue(requestId, sessionId, message, {
+        ...options,
+        executeFunction: this.chatStream.bind(this),
+      });
+
+      this.emit('message:complete', {
+        ...result,
+        requestId,
+        sessionId,
+        duration: Date.now() - result.startTime,
+      });
+
+      return result;
+    } catch (error) {
+      this.emit('message:error', {
+        requestId,
+        sessionId,
+        error: error.message,
+      });
+      throw error;
+    }
+  }
+
+  /**
+   * 流式发送消息（带队列，支持实时yield）
+   */
+  async *sendMessageStream(message, options = {}) {
+    const sessionId = options.sessionId || this.getDefaultSessionId();
+    const requestId = this.generateRequestId();
+
+    // 用于存储流式数据
+    const chunkQueue = [];
+    let streamCompleted = false;
+    let streamError = null;
+    let resolveNext = null;
+
+    // 监听流式数据
+    const chunkHandler = (data) => {
+      if (data.requestId === requestId) {
+        //chunkQueue.push(data.chunk);
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+      }
+    };
+
+    const completeHandler = (data) => {
+      if (data.requestId === requestId) {
+        streamCompleted = true;
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+      }
+    };
+
+    const errorHandler = (data) => {
+      if (data.requestId === requestId) {
+        streamError = new Error(data.error);
+        if (resolveNext) {
+          resolveNext();
+          resolveNext = null;
+        }
+      }
+    };
+
+    // 注册事件监听
+    this.on('stream:chunk', chunkHandler);
+    this.on('queue:completed', completeHandler);
+    this.on('queue:failed', errorHandler);
+
+    // 启动队列任务（不等待完成）
+    const queuePromise = this.queueManager
+      .enqueue(requestId, sessionId, message, {
+        ...options,
+        executeFunction: this.chatStream.bind(this),
+      })
+      .catch((err) => {
+        if (!streamError) {
+          streamError = err;
+        }
+      });
+
+    try {
+      // 实时 yield 流式数据
+      while (!streamCompleted && !streamError) {
+        if (chunkQueue.length > 0) {
+          yield chunkQueue.shift();
+        } else {
+          await new Promise((resolve) => {
+            resolveNext = resolve;
+          });
+        }
+      }
+
+      if (streamError) {
+        throw streamError;
+      }
+
+      // 等待队列完成，获取完整结果
+      const result = await queuePromise;
+      this.emit('message:complete', { ...result, requestId, sessionId });
+    } finally {
+      // 清理事件监听
+      this.off('stream:chunk', chunkHandler);
+      this.off('queue:completed', completeHandler);
+      this.off('queue:failed', errorHandler);
+    }
+  }
+
+  /**
+   * 批量发送消息
+   */
+  async sendBatch(messages, options = {}) {
+    const promises = messages.map((msg, index) => {
+      return this.sendMessage(msg, {
+        ...options,
+        priority: options.priorities?.[index] || 0,
+      });
+    });
+
+    this.emit('batch:start', { count: messages.length });
+
+    const results = await Promise.allSettled(promises);
+
+    this.emit('batch:complete', {
+      total: results.length,
+      fulfilled: results.filter((r) => r.status === 'fulfilled').length,
+      rejected: results.filter((r) => r.status === 'rejected').length,
+    });
+
+    return results;
+  }
+
+  /**
+   * 取消会话的所有请求
+   */
+  cancelSession(sessionId) {
+    const count = this.queueManager.removeSessionRequests(sessionId);
+    this.emit('session:cancelled', { sessionId, count });
+    return count;
+  }
+
+  /**
+   * 获取队列状态
+   */
+  getQueueStatus() {
+    return this.queueManager.getStatus();
+  }
+
+  /**
+   * 清空队列
+   */
+  clearQueue() {
+    const count = this.queueManager.clear();
+    this.emit('queue:cleared-manually', { count });
+    return count;
+  }
+
+  /**
+   * 生成请求ID
+   */
+  generateRequestId() {
+    return `req_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * 获取默认会话ID
+   */
+  getDefaultSessionId() {
+    return 'default_session';
+  }
+
   /**
    * 获取 Per-Session 的消息存储
    * @param {string} sessionId - 会话 ID
@@ -543,64 +772,6 @@ class AgentChatHandler extends EventEmitter {
     }
   }
 
-  /**
-   * 估算消息列表的 token 数（不带消息结构的简单估算）
-   * 用于快速检查
-   * @param {Array} messages
-   * @returns {number}
-   * @private
-   */
-  _roughEstimateMessagesTokens(messages) {
-    let total = 0;
-    for (const msg of messages) {
-      if (!msg) continue;
-      if (typeof msg.content === 'string') {
-        total += this._countTokens(msg.content);
-      } else if (Array.isArray(msg.content)) {
-        for (const part of msg.content) {
-          if (part && part.text) {
-            total += this._countTokens(String(part.text));
-          }
-        }
-      }
-    }
-    return total;
-  }
-
-  /**
-   * 基于 API usage 和新消息估算计算当前上下文 token 数
-   * 参考 Claude Code 的 tokenCountWithEstimation 实现
-   * @param {Array} messages - 消息数组
-   * @param {Object} lastUsage - 上一次 API 返回的 usage
-   * @param {number} baseMessageCount - 基准消息数量（usage 对应时）
-   * @returns {number} 估算的总 token 数
-   * @private
-   */
-  _tokenCountWithEstimation(messages, lastUsage, baseMessageCount = 0) {
-    // 如果有真实的 usage 数据，使用它作为基准
-    if (lastUsage && typeof lastUsage === 'object') {
-      const inputTokens = lastUsage.inputTokens || 0;
-      const outputTokens = lastUsage.outputTokens || 0;
-      const cacheReadTokens = lastUsage.inputTokenDetails?.cacheReadTokens || 0;
-      const cacheWriteTokens = lastUsage.inputTokenDetails?.cacheWriteTokens || 0;
-
-      // 计算已有消息的真实 token 数
-      const baseTokens = inputTokens + cacheReadTokens + outputTokens;
-
-      // 估算新增消息的 token 数
-      if (messages.length > baseMessageCount) {
-        const newMessages = messages.slice(baseMessageCount);
-        const newMessagesTokens = this._countMessagesTokens(newMessages);
-        return baseTokens + newMessagesTokens;
-      }
-
-      return baseTokens;
-    }
-
-    // 没有 usage 数据，使用纯估算
-    return this._countMessagesTokens(messages);
-  }
-
   /**
    * 更新 messageStore 的 lastUsage
    * @param {Object} messageStore
@@ -1274,33 +1445,6 @@ ${truncatedContent}${truncatedNote}
     return this.enqueue(sessionId, message, options);
   }
 
-  /**
-   * 继续完成之前的响应
-   * 当流式响应提前结束时，调用此方法设置 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 - 消息
@@ -1419,7 +1563,6 @@ ${truncatedContent}${truncatedNote}
       }
 
       const tools = this._getAITools(tool);
-
       const agent = new ToolLoopAgent({
         model: this._aiClient,
         instructions: this._systemPrompt,
@@ -1441,28 +1584,19 @@ ${truncatedContent}${truncatedNote}
 
       return {
         success: true,
-        message: result.text || '',
+        message: cleanResponse(result.text || ''),
         stepCount: result.stepCount || 1,
       };
     } catch (err) {
+      console.log(err);
       const errorMsg = err.message || String(err);
-      const isTransientError =
-        errorMsg.includes('Invalid JSON response') ||
-        errorMsg.includes('负载较高') ||
-        errorMsg.includes('Failed after') ||
-        err.name === 'AI_RetryError' ||
-        err.name === 'AI_APICallError';
 
-      if (isTransientError) {
-        return {
-          success: false,
-          message: 'AI 服务暂时不可用，请稍后重试。',
-          error: errorMsg,
-          stepCount: 0,
-        };
-      }
-
-      throw err;
+      return {
+        success: false,
+        message: 'AI 服务暂时不可用，请稍后重试。',
+        error: errorMsg,
+        stepCount: 0,
+      };
     } finally {
       const messageStore = this._getSessionMessageStore(sessionId);
       messageStore.save();

package/src/core/agent.js

@@ -107,6 +107,7 @@ class Agent extends EventEmitter {
 
     this._chatHandler = null;
     this._tools = new Map();
+    this._skipSyncTools = config.skipSyncTools || false;
     this._status = 'idle';
 
     // 子Agent管理
@@ -1074,7 +1075,10 @@ class Agent extends EventEmitter {
         enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
       }
 
-      this._syncTools();
+      // 子agent跳过工具同步，使用createSubAgent时已配置的工具
+      if (!this._skipSyncTools) {
+        this._syncTools();
+      }
 
       // 通过 handler 的 enqueue 处理（自动排队）
       const result = await this._chatHandler.chat(enhancedMessage, options);
@@ -1134,7 +1138,10 @@ class Agent extends EventEmitter {
         enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
       }
 
-      this._syncTools();
+      // 子agent跳过工具同步，使用createSubAgent时已配置的工具
+      if (!this._skipSyncTools) {
+        this._syncTools();
+      }
 
       yield* this._chatHandler.chatStream(enhancedMessage, options);
       this._status = 'idle';
@@ -1148,14 +1155,15 @@ class Agent extends EventEmitter {
     }
   }
 
+  createSessionScope(sessionid) {
+    return this._chatHandler.createSessionScope(sessionid);
+  }
+
   /**
-   * 继续对话（使用队列机制）
-   * @param {string} prompt - 继续提示
-   * @param {string} sessionId - 会话ID
-   * @param {Object} options - 选项 { onChunk, onComplete, onError }
+   * 发送消息（带队列）
    */
-  continue(prompt, sessionId, options = {}) {
-    return this._chatHandler.continue(prompt, sessionId, options);
+  async sendMessage(message, options = {}) {
+    return this._chatHandler.sendMessage(message, options);
   }
 
   /**

package/src/core/framework.js

@@ -614,6 +614,7 @@ class Framework extends EventEmitter {
       name: `subagent_${name}`,
       role: role,
       systemPrompt: role, // 使用 role 作为 systemPrompt
+      skipSyncTools: true, // 子agent跳过工具同步，使用createSubAgent时已配置的工具
       ...(llmConfig || {}), // 如果提供了独立LLM配置，合并
     };
 
@@ -634,7 +635,6 @@ class Framework extends EventEmitter {
         });
       }
     }
-
     // 从父Agent继承工具
     if (this._mainAgent) {
       const parentToolsDefs = this._mainAgent.getTools();
@@ -643,9 +643,12 @@ class Framework extends EventEmitter {
         for (const toolDef of parentToolsDefs) {
           agent.registerTool(toolDef);
         }
-      } else if (Array.isArray(parentTools) && parentTools.length > 0) {
+      } else if (Array.isArray(parentTools)) {
         // 指定了要继承的工具列表
-        for (const toolName of parentTools) {
+        const filteredTools = parentTools.filter((toolName) =>
+          parentToolsDefs.some((def) => def.name === toolName)
+        );
+        for (const toolName of filteredTools) {
           const toolDef = parentToolsDefs.find((t) => t.name === toolName);
           if (toolDef) {
             agent.registerTool(toolDef);