foliko 1.1.4 → 1.1.6

package/src/core/coordinator-manager.js

@@ -0,0 +1,341 @@
+/**
+ * CoordinatorManager - Coordinator模式管理器
+ * 管理Worker的创建、消息传递、生命周期
+ */
+
+const { EventEmitter } = require('../utils/event-emitter');
+const { WorkerAgent } = require('./worker-agent');
+const { logger } = require('../utils/logger');
+
+const log = logger.child('CoordinatorManager');
+
+/**
+ * Worker上下文
+ */
+class WorkerContext {
+  constructor(config) {
+    this.workerId = config.workerId;
+    this.name = config.name;
+    this.coordinatorId = config.coordinatorId;
+    this.task = config.task;
+    this.status = 'pending'; // pending, running, completed, error, stopped
+    this.agent = config.agent;
+    this.tools = config.tools || [];
+    this.createdAt = new Date();
+    this.updatedAt = new Date();
+    this.result = null;
+    this.error = null;
+  }
+
+  update(status, result = null, error = null) {
+    this.status = status;
+    this.result = result;
+    this.error = error;
+    this.updatedAt = new Date();
+  }
+}
+
+/**
+ * CoordinatorManager - 管理所有Worker
+ */
+class CoordinatorManager extends EventEmitter {
+  /**
+   * @param {Framework} framework - 框架实例
+   */
+  constructor(framework) {
+    super();
+    this.framework = framework;
+    this._workers = new Map(); // workerId -> WorkerContext
+    this._nameIndex = new Map(); // name -> workerId
+    this._coordinatorAgent = null; // Coordinator Agent实例
+  }
+
+  /**
+   * 设置Coordinator Agent
+   * @param {Agent} agent - Coordinator Agent实例
+   */
+  setCoordinatorAgent(agent) {
+    this._coordinatorAgent = agent;
+  }
+
+  /**
+   * 获取Coordinator Agent
+   */
+  getCoordinatorAgent() {
+    return this._coordinatorAgent;
+  }
+
+  /**
+   * 创建Worker
+   * @param {Object} config - Worker配置
+   * @param {string} config.name - Worker名称（唯一）
+   * @param {string} config.task - 初始任务
+   * @param {string} [config.systemPrompt] - 可选系统提示
+   * @param {string[]} [config.tools] - 可用工具列表
+   * @returns {Promise<{workerId: string, status: string}>}
+   */
+  async createWorker(config) {
+    const { name, task, systemPrompt, tools } = config;
+
+    // 检查名称唯一性
+    if (this._nameIndex.has(name)) {
+      throw new Error(`Worker with name '${name}' already exists`);
+    }
+
+    // 生成workerId
+    const workerId = `worker_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`;
+
+    // 获取AI配置
+    const aiPlugin = this.framework.pluginManager.get('ai');
+    const aiConfig = aiPlugin ? aiPlugin.getConfig() : {};
+
+    // 构建系统提示
+    let finalSystemPrompt = systemPrompt;
+    if (!finalSystemPrompt) {
+      finalSystemPrompt = WorkerAgent.defaultPrompt();
+    }
+
+    // 创建WorkerAgent
+    const agentConfig = {
+      workerId,
+      coordinatorId: this._coordinatorAgent?.name || 'unknown',
+      name: `worker_${name}`,
+      task,
+      systemPrompt: finalSystemPrompt,
+      tools: tools || [],
+      model: aiConfig.model,
+      provider: aiConfig.provider,
+      apiKey: aiConfig.apiKey,
+      baseURL: aiConfig.baseURL,
+    };
+
+    const workerAgent = new WorkerAgent(this.framework, agentConfig);
+
+    // 创建WorkerContext
+    const context = new WorkerContext({
+      workerId,
+      name,
+      coordinatorId: this._coordinatorAgent?.name || 'unknown',
+      task,
+      agent: workerAgent,
+      tools: tools || [],
+    });
+
+    // 保存
+    this._workers.set(workerId, context);
+    this._nameIndex.set(name, workerId);
+
+    // 监听Worker事件
+    workerAgent.on('message', (msg) => {
+      this._handleWorkerMessage(workerId, msg);
+    });
+
+    workerAgent.on('stopped', () => {
+      this._handleWorkerStopped(workerId);
+    });
+
+    // 发送初始任务
+    context.status = 'running';
+    this.emit('worker:created', { workerId, name, status: 'running' });
+    this.emit('worker:started', { workerId, name, task });
+
+    // 异步执行任务（不等待完成）
+    this._runWorkerTask(workerId, task);
+
+    return { workerId, status: 'running' };
+  }
+
+  /**
+   * 异步执行Worker任务
+   * @private
+   */
+  async _runWorkerTask(workerId, task) {
+    const context = this._workers.get(workerId);
+    if (!context) return;
+
+    try {
+      const result = await context.agent.runTask(task);
+      context.update('completed', result);
+
+      // 生成通知
+      const notification = this._generateCompletionNotification(workerId, 'completed', result);
+      this.emit('worker:completed', { workerId, name: context.name, result, notification });
+    } catch (err) {
+      context.update('error', null, err.message);
+      const notification = this._generateCompletionNotification(
+        workerId,
+        'error',
+        null,
+        err.message
+      );
+      this.emit('worker:error', { workerId, name: context.name, error: err.message, notification });
+    }
+  }
+
+  /**
+   * 处理Worker消息
+   * @private
+   */
+  _handleWorkerMessage(workerId, msg) {
+    const context = this._workers.get(workerId);
+    if (!context) return;
+
+    this.emit('worker:message', { workerId, name: context.name, message: msg });
+
+    // 转发给Coordinator（如果有）
+    if (this._coordinatorAgent) {
+      this._coordinatorAgent.emit('worker:message', { workerId, name: context.name, message: msg });
+    }
+  }
+
+  /**
+   * 处理Worker停止
+   * @private
+   */
+  _handleWorkerStopped(workerId) {
+    const context = this._workers.get(workerId);
+    if (!context) return;
+
+    context.update('stopped');
+    this.emit('worker:stopped', { workerId, name: context.name });
+
+    // 清理索引
+    this._nameIndex.delete(context.name);
+  }
+
+  /**
+   * 发送消息给Worker（继续执行）
+   * @param {string} workerName - Worker名称
+   * @param {string} message - 消息内容
+   * @returns {Promise<Object>} 处理结果
+   */
+  async sendToWorker(workerName, message) {
+    const workerId = this._nameIndex.get(workerName);
+    if (!workerId) {
+      throw new Error(`Worker '${workerName}' not found`);
+    }
+
+    const context = this._workers.get(workerId);
+    if (!context) {
+      throw new Error(`Worker context not found for '${workerName}'`);
+    }
+
+    if (context.status === 'stopped') {
+      throw new Error(`Worker '${workerName}' has been stopped`);
+    }
+
+    this.emit('worker:resumed', { workerId, name: workerName, message });
+
+    try {
+      const result = await context.agent.sendMessage(message);
+      return result;
+    } catch (err) {
+      context.update('error', null, err.message);
+      throw err;
+    }
+  }
+
+  /**
+   * 停止Worker
+   * @param {string} workerName - Worker名称
+   * @param {string} [reason] - 停止原因
+   * @returns {Object} 停止结果
+   */
+  stopWorker(workerName, reason = null) {
+    const workerId = this._nameIndex.get(workerName);
+    if (!workerId) {
+      throw new Error(`Worker '${workerName}' not found`);
+    }
+
+    const context = this._workers.get(workerId);
+    if (!context) {
+      throw new Error(`Worker context not found for '${workerName}'`);
+    }
+
+    context.agent.stop();
+    context.update('stopped');
+
+    const notification = this._generateCompletionNotification(workerId, 'stopped', null, reason);
+    this.emit('worker:stopped', {
+      workerId,
+      name: workerName,
+      reason,
+      notification,
+    });
+
+    // 清理索引
+    this._nameIndex.delete(workerName);
+
+    return { workerId, name: workerName, status: 'stopped', reason };
+  }
+
+  /**
+   * 获取Worker状态
+   * @param {string} workerName - Worker名称
+   * @returns {Object|null} Worker信息
+   */
+  getWorker(workerName) {
+    const workerId = this._nameIndex.get(workerName);
+    if (!workerId) return null;
+
+    const context = this._workers.get(workerId);
+    if (!context) return null;
+
+    return {
+      workerId: context.workerId,
+      name: context.name,
+      status: context.status,
+      task: context.task,
+      result: context.result,
+      error: context.error,
+      createdAt: context.createdAt,
+      updatedAt: context.updatedAt,
+    };
+  }
+
+  /**
+   * 列出所有Worker
+   * @returns {Array} Worker列表
+   */
+  listWorkers() {
+    const workers = [];
+    for (const [workerId, context] of this._workers) {
+      // 跳过已停止的
+      if (context.status === 'stopped') continue;
+
+      workers.push({
+        workerId: context.workerId,
+        name: context.name,
+        status: context.status,
+        task: context.task,
+        createdAt: context.createdAt,
+        updatedAt: context.updatedAt,
+      });
+    }
+    return workers;
+  }
+
+  /**
+   * 生成完成通知XML
+   * @private
+   */
+  _generateCompletionNotification(workerId, status, result, error = null) {
+    return WorkerAgent.formatNotification(workerId, status, result, error);
+  }
+
+  /**
+   * 销毁所有Worker
+   */
+  destroy() {
+    for (const [workerId, context] of this._workers) {
+      if (context.status !== 'stopped') {
+        context.agent.stop();
+      }
+    }
+    this._workers.clear();
+    this._nameIndex.clear();
+    this._coordinatorAgent = null;
+  }
+}
+
+module.exports = { CoordinatorManager, WorkerContext };

package/src/core/framework.js

@@ -13,6 +13,7 @@ const { SubAgentConfigManager } = require('./sub-agent-config');
 const { ContextManager } = require('./context-manager');
 const { SessionContext } = require('./session-context');
 const { SessionStorageAdapter, getDefaultAdapter } = require('./session-storage');
+const { CoordinatorManager } = require('./coordinator-manager');
 
 // 添加框架目录的 node_modules 到全局搜索路径
 // 让项目插件能 require 框架内置的包（如 zod）
@@ -70,6 +71,9 @@ class Framework extends EventEmitter {
       baseDir: '.agent/sessions',
     };
 
+    // Coordinator管理器（用于Coordinator模式）
+    this._coordinatorManager = null;
+
     // 事件转发 - ToolRegistry 事件
     this.toolRegistry.on('tool:registered', (tool) => {
       this.emit('tool:registered', tool);
@@ -738,10 +742,56 @@ class Framework extends EventEmitter {
     // 内置工具会在 Agent 创建时添加）
   }
 
+  // ============================================================================
+  // Coordinator 模式管理
+  // ============================================================================
+
+  /**
+   * 初始化Coordinator管理器
+   * @param {Agent} coordinatorAgent - Coordinator Agent实例
+   */
+  initCoordinatorManager(coordinatorAgent) {
+    if (!this._coordinatorManager) {
+      this._coordinatorManager = new CoordinatorManager(this);
+    }
+    this._coordinatorManager.setCoordinatorAgent(coordinatorAgent);
+    return this._coordinatorManager;
+  }
+
+  /**
+   * 获取Coordinator管理器
+   * @returns {CoordinatorManager|null}
+   */
+  getCoordinatorManager() {
+    return this._coordinatorManager;
+  }
+
+  /**
+   * 创建Worker（由coordinator-plugin调用）
+   * @param {Object} config - Worker配置
+   * @param {string} config.name - Worker名称
+   * @param {string} config.task - 初始任务
+   * @param {string} [config.systemPrompt] - 可选系统提示
+   * @param {string[]} [config.tools] - 可用工具列表
+   * @returns {Promise<{workerId: string, status: string}>}
+   */
+  async createWorker(config) {
+    if (!this._coordinatorManager) {
+      throw new Error('CoordinatorManager not initialized. Call initCoordinatorManager first.');
+    }
+    return this._coordinatorManager.createWorker(config);
+  }
+
   /**
    * 销毁框架
    */
   async destroy() {
+    // 销毁Coordinator管理器
+    if (this._coordinatorManager) {
+      this._coordinatorManager.destroy();
+      this._coordinatorManager = null;
+    }
+
     // 刷新所有 Session 存储
     if (this._sessionStorage) {
       await this._sessionStorage.flush();

package/src/core/plugin-base.js

@@ -176,34 +176,47 @@ class Plugin {
    * @param {string} [config.description] - 子Agent描述
    * @param {Object} [config.tools] - 自定义工具 { name: toolDef }
    * @param {string[]} [config.parentTools] - 从父Agent继承的工具名称
-   * @returns {SubAgentPlugin} 注册的子Agent插件实例
+   * @returns {Object} 注册的子Agent信息
    */
   registerSubAgent(config) {
     if (!this._framework) {
       throw new Error('Plugin not installed, call install(framework) first');
     }
 
-    // 动态导入避免循环依赖
-    const { SubAgentPlugin } = require('../../plugins/subagent-plugin');
+    // 获取 subagent-manager 插件
+    const subAgentManager = this._framework.pluginManager.get('subagent-manager');
 
-    const plugin = new SubAgentPlugin({
-      ...config,
-      // 确保子Agent能获取父Agent
-      _parentAgentGetter: () => {
-        // 尝试获取主Agent
-        if (this._framework._mainAgent) {
-          return this._framework._mainAgent;
-        }
-        const agents = this._framework._agents || [];
-        return agents.length > 0 ? agents[agents.length - 1] : null;
-      },
+    if (!subAgentManager) {
+      throw new Error('subagent-manager plugin not found');
+    }
+
+    // 创建子Agent实例
+    const agent = this._framework.createSubAgent({
+      name: config.name,
+      role: config.role,
+      goal: config.description || config.role,
+      tools: config.tools || {},
+      parentTools: config.parentTools || [],
     });
 
-    plugin.install(this._framework);
-    plugin.start(this._framework);
+    // 注册到 subagent-manager
+    subAgentManager.registerPlugin({
+      name: config.name,
+      role: config.role,
+      goal: config.description || config.role,
+      agent,
+      tools: config.tools || {},
+    });
+
+    // 保存引用以便后续清理
+    this._subAgents.push({
+      name: config.name,
+      agent,
+      plugin: null, // 兼容旧代码
+    });
 
     log.debug(` Registered subagent: ${config.name}`);
-    return plugin;
+    return { name: config.name, agent };
   }
 
   /**

package/src/core/sub-agent-config.js

@@ -239,12 +239,19 @@ class SubAgentConfigManager {
   }
 
   /**
-   * 获取所有配置
+   * 获取所有配置（Map 格式）
    */
   getAll() {
     return Array.from(this._configs.values());
   }
 
+  /**
+   * 获取所有配置（Map 格式，用于兼容性）
+   */
+  getAllConfigs() {
+    return this._configs;
+  }
+
   /**
    * 获取所有有效配置
    */

package/src/core/worker-agent.js

@@ -0,0 +1,176 @@
+/**
+ * WorkerAgent - 独立子Agent
+ * 用于Coordinator模式下的Worker，具有独立工具集
+ * 任务完成后通过事件通知Coordinator
+ */
+
+const { Agent } = require('./agent');
+const { EventEmitter } = require('../utils/event-emitter');
+
+class WorkerAgent extends Agent {
+  /**
+   * @param {Framework} framework - 框架实例
+   * @param {Object} config - 配置
+   * @param {string} config.workerId - Worker唯一ID
+   * @param {string} config.coordinatorId - Coordinator的agentId
+   * @param {string} [config.name] - Worker名称
+   * @param {string} [config.systemPrompt] - 系统提示
+   * @param {string[]} [config.tools] - 可用工具名称列表（为空则无工具）
+   */
+  constructor(framework, config) {
+    super(framework, {
+      name: config.name || `worker_${config.workerId}`,
+      systemPrompt: config.systemPrompt || WorkerAgent.defaultPrompt(),
+      model: config.model,
+      provider: config.provider,
+      apiKey: config.apiKey,
+      baseURL: config.baseURL,
+    });
+
+    this.workerId = config.workerId;
+    this.coordinatorId = config.coordinatorId;
+    this._status = 'idle'; // idle, running, completed, error, stopped
+    this._task = config.task || '';
+    this._availableTools = config.tools || [];
+
+    // 不从framework同步工具（Worker有独立工具集）
+    // 但如果指定了工具列表，只注册那些工具
+    if (this._availableTools.length > 0) {
+      this._applyToolFilter();
+    }
+
+    // 监听完成事件
+    this.on('message', (msg) => {
+      // 检查是否是最终响应（无更多工具调用）
+      if (msg.role === 'assistant' && !msg.toolCalls) {
+        this._status = 'completed';
+      }
+    });
+  }
+
+  /**
+   * 应用工具过滤（如果指定了tools列表）
+   * @private
+   */
+  _applyToolFilter() {
+    const allTools = Array.from(this._tools.values());
+    const allowedTools = new Set(this._availableTools);
+
+    // 移除不在允许列表中的工具
+    for (const [name, tool] of this._tools) {
+      if (!allowedTools.has(name)) {
+        this._tools.delete(name);
+      }
+    }
+
+    // 同步到chatHandler
+    if (this._chatHandler) {
+      this._chatHandler._tools = this._tools;
+    }
+  }
+
+  /**
+   * 获取Worker状态
+   */
+  getStatus() {
+    return this._status;
+  }
+
+  /**
+   * 设置状态
+   */
+  setStatus(status) {
+    this._status = status;
+  }
+
+  /**
+   * 执行初始任务
+   * @param {string} task - 任务描述
+   * @returns {Promise<Object>} 任务结果
+   */
+  async runTask(task) {
+    this._task = task;
+    this._status = 'running';
+
+    try {
+      const result = await this.chat(task);
+      this._status = 'completed';
+      return result;
+    } catch (err) {
+      this._status = 'error';
+      throw err;
+    }
+  }
+
+  /**
+   * 发送消息继续Worker
+   * @param {string} message - 继续消息
+   * @returns {Promise<Object>} 处理结果
+   */
+  async sendMessage(message) {
+    if (this._status === 'stopped') {
+      throw new Error(`Worker ${this.workerId} has been stopped`);
+    }
+
+    this._status = 'running';
+    try {
+      const result = await this.chat(message);
+      return result;
+    } catch (err) {
+      this._status = 'error';
+      throw err;
+    }
+  }
+
+  /**
+   * 停止Worker
+   */
+  stop() {
+    this._status = 'stopped';
+    if (this._chatHandler) {
+      this._chatHandler.destroy();
+    }
+    this.emit('stopped', { workerId: this.workerId });
+  }
+
+  /**
+   * 生成<task-notification> JSON
+   * @param {string} status - completed, error, stopped
+   * @param {string} result - 任务结果
+   * @param {string} [error] - 错误信息
+   * @returns {string} JSON字符串
+   */
+  static formatNotification(workerId, status, result, error = null) {
+    const notification = {
+      worker_id: workerId,
+      status: status,
+      timestamp: new Date().toISOString(),
+    };
+
+    if (error) {
+      notification.error = error;
+    } else if (result) {
+      notification.result = result;
+    }
+
+    return JSON.stringify(notification);
+  }
+
+  /**
+   * 默认系统提示
+   */
+  static defaultPrompt() {
+    return `你是一个独立的Worker Agent。
+你的职责：
+1. 接收并理解Coordinator分配的任务
+2. 使用你的工具集完成任务
+3. 返回完整的任务结果
+
+重要规则：
+- 任务完成或出错时，在响应末尾添加JSON格式的<task-notification>说明状态
+- 不要主动联系Coordinator，由Coordinator主动查询结果
+- 如果需要更多信息，等待Coordinator发送continue消息`;
+  }
+}
+
+module.exports = { WorkerAgent };