foliko 1.1.4 → 1.1.6

package/.agent/test-agent.js

@@ -0,0 +1,35 @@
+const fs = require("fs");
+const path = require("path");
+
+const agentsDir = path.join(".", "agents");
+const files = fs.readdirSync(agentsDir);
+console.log("子Agent文件:", files);
+
+const { SubAgentConfigManager } = require("../src/core/sub-agent-config.js");
+const configManager = new SubAgentConfigManager(agentsDir);
+
+// 需要调用 loadAll() 来加载配置
+configManager.loadAll();
+
+const configs = configManager.getAll();
+console.log("\n加载的子Agent配置:", configs.map(c => c.getName()));
+
+// 测试 getAllConfigs
+const configs2 = configManager.getAllConfigs();
+console.log("getAllConfigs():", configs2.size, "个");
+configs2.forEach((config, name) => {
+    console.log(`  - ${name}: valid=${config.isValid()}`);
+});
+
+// 测试 orchestrator-demo
+const demoConfig = configManager.get("orchestrator-demo");
+if (demoConfig) {
+    console.log("\norchestrator-demo 配置:");
+    console.log("  名称:", demoConfig.getName());
+    console.log("  描述:", demoConfig.getDescription());
+    console.log("  技能:", demoConfig.getSkills());
+    console.log("  工具:", demoConfig.getTools());
+    console.log("  模型:", demoConfig.getModel());
+} else {
+    console.log("\n未找到 orchestrator-demo 配置");
+}

package/cli/src/commands/chat.js

@@ -63,7 +63,12 @@ function parseArgs(args) {
 
   for (let i = 0; i < args.length; i++) {
     const arg = args[i];
-    if (arg === '--model' && args[i + 1]) {
+    if (arg === '-c' || arg === '--continue' || arg === '--continuous') {
+      // 持续测试模式：传入 'sessionId:command1|command2|command3'
+      // 或 command1|command2|command3 (使用默认 sessionId)
+      options.continuous = true;
+      options.commandSequence = args[++i] || '';
+    } else if (arg === '--model' && args[i + 1]) {
       options.model = args[++i];
     } else if (arg === '--provider' && args[i + 1]) {
       options.provider = args[++i];
@@ -75,6 +80,10 @@ function parseArgs(args) {
       options.stream = true;
     } else if (arg === '--no-stream') {
       options.stream = false;
+    } else if (arg === '--clear') {
+      options.clearSession = true;
+    } else if (arg === '--session' && args[i + 1]) {
+      options.sessionId = args[++i];
     }
   }
 
@@ -86,6 +95,59 @@ function parseArgs(args) {
   return options;
 }
 
+/**
+ * 持续测试模式：自动发送多条消息进行测试
+ */
+async function runContinuousTest(agent, options) {
+  const sessionId = options.sessionId || 'cli_default';
+  const commands = options.commandSequence.split('|').filter((c) => c.trim());
+
+  if (commands.length === 0) {
+    console.log('错误：-c 参数需要提供命令序列，格式：command1|command2|command3');
+    process.exit(1);
+  }
+
+  console.log('=== 持续测试模式 ===');
+  console.log(`Session: ${sessionId}`);
+  console.log(`命令数量: ${commands.length}`);
+  console.log('');
+
+  const runWithContext = agent.framework?.runWithContext.bind(agent.framework);
+
+  for (let i = 0; i < commands.length; i++) {
+    const cmd = commands[i];
+    console.log(`\n[${i + 1}/${commands.length}] >>> ${cmd}`);
+    console.log('-'.repeat(50));
+
+    try {
+      let fullResponse = '';
+      await runWithContext({ sessionId }, async () => {
+        for await (const chunk of agent.chatStream(cmd, { sessionId })) {
+          if (chunk.type === 'text') {
+            fullResponse += chunk.text;
+            process.stdout.write(chunk.text);
+          } else if (chunk.type === 'tool-call') {
+            console.log(`\n[工具调用] ${chunk.toolName}  ${JSON.stringify(chunk.input)}`);
+          } else if (chunk.type === 'error') {
+            console.error(`\n[错误] ${chunk.error}`);
+          }
+        }
+      });
+      console.log('\n' + '-'.repeat(50));
+      console.log(`[完成] 回复长度: ${fullResponse.length}`);
+    } catch (err) {
+      console.error(`\n[执行错误] ${err.message}`);
+      // 继续执行下一条命令
+    }
+
+    // 命令间隔 1 秒
+    await new Promise((r) => setTimeout(r, 1000));
+  }
+
+  console.log('\n=== 测试完成 ===');
+  console.log(`共执行 ${commands.length} 条命令`);
+}
+
 /**
  * Chat 命令入口
  */
@@ -127,6 +189,12 @@ async function chatCommand(args) {
 - 禁止添加 -g 参数
 - 例如：npx skills add xxx 应该执行为 npx skills add xxx -a openclaw -y`);
 
+  // 持续测试模式
+  if (options.continuous) {
+    await runContinuousTest(agent, options);
+    return;
+  }
+
   // 初始化 UI
   const ui = new ChatUI(agent, { stream: options.stream });
 

package/cli/src/index.js

@@ -12,12 +12,21 @@ const path = require('path');
  */
 async function cli() {
   const args = process.argv.slice(2);
-  const command = args[0] || 'chat';
+  let command = args[0] || 'chat';
   const packageJsonPath = path.join(__dirname, '../../package.json');
 
+  // 如果第一个参数看起来像选项而不是命令，说明用户直接运行 "npm run chat -c ..."
+  // 把命令设为 'chat'，所有参数都传给 chat 命令
+  if (command && command.startsWith('-')) {
+    command = 'chat';
+  }
+
   switch (command) {
     case 'chat':
-      await chatCommand(args.slice(1));
+      // 如果第一个参数是选项（如 -c），args 已经是传给 chat 的参数
+      // 如果第一个参数是 'chat'，需要 slice(1) 去掉 'chat'
+      const chatArgs = args[0] === 'chat' ? args.slice(1) : args;
+      await chatCommand(chatArgs);
       break;
 
     case 'list':

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "foliko",
-  "version": "1.1.4",
+  "version": "1.1.6",
   "description": "简约的插件化 Agent 框架",
   "main": "src/index.js",
   "type": "commonjs",
@@ -54,7 +54,7 @@
     "@ai-sdk/openai-compatible": "^2.0.35",
     "@anthropic-ai/sdk": "^0.39.0",
     "@chnak/weixin-bot": "^1.2.7",
-    "@chnak/zod-to-markdown": "^1.0.1",
+    "@chnak/zod-to-markdown": "1.0.3",
     "@hono/node-server": "^1.19.11",
     "@larksuiteoapi/node-sdk": "^1.59.0",
     "@modelcontextprotocol/sdk": "^1.27.1",

package/plugins/coordinator-plugin.js

@@ -0,0 +1,282 @@
+/**
+ * Coordinator Plugin
+ * 提供Coordinator模式的工具集：
+ * - spawn_worker: 创建Worker
+ * - send_message_to_worker: 继续Worker
+ * - stop_worker: 停止Worker
+ * - list_workers: 列出Worker
+ */
+
+const { Plugin } = require('../src/core/plugin-base');
+const { z } = require('zod');
+const { logger } = require('../src/utils/logger');
+
+const log = logger.child('CoordinatorPlugin');
+
+class CoordinatorPlugin extends Plugin {
+  constructor(config = {}) {
+    super();
+    this.name = 'coordinator';
+    this.version = '1.0.0';
+    this.description = 'Coordinator模式插件，支持多Worker协作';
+    this.priority = 50;
+
+    this._framework = null;
+    this._coordinatorAgent = null;
+  }
+
+  install(framework) {
+    this._framework = framework;
+    return this;
+  }
+
+  start(framework) {
+    this._framework = framework;
+
+    // 初始化CoordinatorManager（如果尚未初始化）
+    if (!framework._coordinatorManager) {
+      // framework.initCoordinatorManager 会创建并设置
+    }
+
+    // 获取主Agent作为默认的Coordinator
+    const mainAgent = framework._mainAgent;
+    if (mainAgent) {
+      // 初始化CoordinatorManager并传入coordinatorAgent
+      framework.initCoordinatorManager(mainAgent);
+
+      // 注册Coordinator工具到主Agent
+      this.registerTools(mainAgent);
+
+      // 注册系统提示词部分，让Agent知道如何使用Coordinator模式
+      this._registerCoordinatorPrompt(mainAgent);
+
+      // 监听Worker事件用于生成通知
+      this._setupWorkerEventListeners(framework);
+
+      log.debug(' Coordinator plugin initialized with main agent');
+    }
+
+    return this;
+  }
+
+  /**
+   * 注册Coordinator模式提示词到Agent
+   * @private
+   */
+  _registerCoordinatorPrompt(agent) {
+    if (!agent || typeof agent.registerPromptPart !== 'function') {
+      return;
+    }
+
+    agent.registerPromptPart('coordinator-mode', 650, () => `
+【并行任务处理 - Coordinator 模式】
+当遇到可并行处理的任务时（如多主题搜索、多文件处理、多计算任务），使用以下工具：
+
+- spawn_worker: 创建独立Worker并行执行任务
+- send_message_to_worker: 向Worker发送消息继续执行
+- stop_worker: 停止Worker
+- list_workers: 查看所有Worker状态
+- get_worker: 查看单个Worker详情
+
+【使用场景】
+- "帮我搜索X、Y、Z" → 使用 spawn_worker 并行执行
+- "帮我同时处理这几个文件" → 使用 spawn_worker 并行执行
+- 需要主动查询Worker结果时 → 使用 get_worker / list_workers
+
+【重要】
+- spawn_worker 创建后立即返回，Worker在后台执行
+- 可同时创建多个Worker并行处理不同任务
+- Worker完成后生成 <task-notification> JSON 通知
+`);
+  }
+
+  /**
+   * 设置Worker事件监听器
+   * @private
+   */
+  _setupWorkerEventListeners(framework) {
+    const coordinatorManager = framework.getCoordinatorManager();
+    if (!coordinatorManager) return;
+
+    // 监听Worker完成事件
+    coordinatorManager.on('worker:completed', (data) => {
+      // 通知会被发送到Coordinator Agent的事件队列
+      framework.emit('coordinator:worker-completed', data);
+    });
+
+    // 监听Worker错误事件
+    coordinatorManager.on('worker:error', (data) => {
+      framework.emit('coordinator:worker-error', data);
+    });
+
+    // 监听Worker停止事件
+    coordinatorManager.on('worker:stopped', (data) => {
+      framework.emit('coordinator:worker-stopped', data);
+    });
+  }
+
+  /**
+   * 设置Coordinator Agent
+   * @param {Agent} agent - Coordinator Agent实例
+   */
+  setCoordinatorAgent(agent) {
+    this._coordinatorAgent = agent;
+  }
+
+  /**
+   * 注册Coordinator工具到指定Agent
+   * @param {Agent} agent - Agent实例
+   */
+  registerTools(agent) {
+    // spawn_worker - 创建Worker
+    agent.registerTool({
+      name: 'spawn_worker',
+      description: '创建一个独立的Worker Agent来执行任务。Worker会在后台异步执行，完成后通过事件通知。',
+      inputSchema: z.object({
+        worker_name: z.string().describe('Worker的唯一名称'),
+        task: z.string().describe('给Worker的初始任务描述'),
+        system_prompt: z.string().optional().describe('可选的系统提示词'),
+        tools: z.array(z.string()).optional().describe('Worker可用的工具名称列表'),
+      }),
+      execute: async (args, fw) => {
+        const coordinatorManager = fw.getCoordinatorManager();
+        if (!coordinatorManager) {
+          return { success: false, error: 'CoordinatorManager not initialized' };
+        }
+
+        try {
+          const result = await coordinatorManager.createWorker({
+            name: args.worker_name,
+            task: args.task,
+            systemPrompt: args.system_prompt,
+            tools: args.tools,
+          });
+
+          return {
+            success: true,
+            workerId: result.workerId,
+            status: result.status,
+            message: `Worker '${args.worker_name}' created and running`,
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
+      },
+    });
+
+    // send_message_to_worker - 继续Worker
+    agent.registerTool({
+      name: 'send_message_to_worker',
+      description: '向指定的Worker发送消息，继续其执行',
+      inputSchema: z.object({
+        worker_name: z.string().describe('Worker名称'),
+        message: z.string().describe('要发送给Worker的消息'),
+      }),
+      execute: async (args, fw) => {
+        const coordinatorManager = fw.getCoordinatorManager();
+        if (!coordinatorManager) {
+          return { success: false, error: 'CoordinatorManager not initialized' };
+        }
+
+        try {
+          const result = await coordinatorManager.sendToWorker(args.worker_name, args.message);
+          return {
+            success: true,
+            workerName: args.worker_name,
+            result: result.message || result,
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
+      },
+    });
+
+    // stop_worker - 停止Worker
+    agent.registerTool({
+      name: 'stop_worker',
+      description: '停止指定的Worker',
+      inputSchema: z.object({
+        worker_name: z.string().describe('Worker名称'),
+        reason: z.string().optional().describe('停止原因'),
+      }),
+      execute: async (args, fw) => {
+        const coordinatorManager = fw.getCoordinatorManager();
+        if (!coordinatorManager) {
+          return { success: false, error: 'CoordinatorManager not initialized' };
+        }
+
+        try {
+          const result = coordinatorManager.stopWorker(args.worker_name, args.reason);
+          return {
+            success: true,
+            ...result,
+          };
+        } catch (err) {
+          return { success: false, error: err.message };
+        }
+      },
+    });
+
+    // list_workers - 列出Worker
+    agent.registerTool({
+      name: 'list_workers',
+      description: '列出所有活跃的Worker',
+      inputSchema: z.object({}),
+      execute: async (args, fw) => {
+        const coordinatorManager = fw.getCoordinatorManager();
+        if (!coordinatorManager) {
+          return { success: false, error: 'CoordinatorManager not initialized' };
+        }
+
+        const workers = coordinatorManager.listWorkers();
+        return {
+          success: true,
+          count: workers.length,
+          workers,
+        };
+      },
+    });
+
+    // get_worker - 获取Worker详情
+    agent.registerTool({
+      name: 'get_worker',
+      description: '获取指定Worker的详细信息',
+      inputSchema: z.object({
+        worker_name: z.string().describe('Worker名称'),
+      }),
+      execute: async (args, fw) => {
+        const coordinatorManager = fw.getCoordinatorManager();
+        if (!coordinatorManager) {
+          return { success: false, error: 'CoordinatorManager not initialized' };
+        }
+
+        const worker = coordinatorManager.getWorker(args.worker_name);
+        if (!worker) {
+          return { success: false, error: `Worker '${args.worker_name}' not found` };
+        }
+
+        return {
+          success: true,
+          worker,
+        };
+      },
+    });
+
+    log.debug(' Coordinator tools registered');
+  }
+
+  reload(framework) {
+    this._framework = framework;
+  }
+
+  uninstall(framework) {
+    const coordinatorManager = framework.getCoordinatorManager();
+    if (coordinatorManager) {
+      coordinatorManager.destroy();
+    }
+    this._framework = null;
+    this._coordinatorAgent = null;
+  }
+}
+
+module.exports = { CoordinatorPlugin };

package/plugins/default-plugins.js

@@ -232,7 +232,7 @@ async function bootstrapDefaults(framework, config = {}) {
     'mcp-executor', 'extension-executor', 'shell-executor', 'python-executor', 'session', 'web',
     'audit', 'rules', 'scheduler', 'file-system', 'think', 'ambient',
     'python-plugin-loader', 'telegram', 'weixin', 'subagent-manager',
-    'memory'
+    'memory', 'coordinator'
   ])
 
   // 辅助函数：检查插件是否应该加载

package/plugins/extension-executor-plugin.js

@@ -133,15 +133,29 @@ class ExtensionExecutorPlugin extends Plugin {
       }),
       execute: async (args) => {
         const { plugin, tool, args: toolArgs = {} } = args;
-        log.info(` ext_call: plugin=${plugin}, tool=${tool}`);
+        log.info(` ext_call: plugin=${plugin}, tool=${tool}, args=${JSON.stringify(toolArgs)}`);
 
         const ext = this._extensions.get(plugin);
         if (!ext) {
+          // 触发错误事件
+          framework.emit('tool:error', {
+            name: `${plugin}:${tool}`,
+            args: toolArgs,
+            error: `扩展插件 '${plugin}' 不存在`,
+            source: 'extension'
+          });
           return { success: false, error: `扩展插件 '${plugin}' 不存在` };
         }
 
         const toolDef = ext.tools.find((t) => t.name === tool);
         if (!toolDef) {
+          // 触发错误事件
+          framework.emit('tool:error', {
+            name: `${plugin}:${tool}`,
+            args: toolArgs,
+            error: `扩展工具 '${tool}' 不存在`,
+            source: 'extension'
+          });
           return { success: false, error: `扩展工具 '${tool}' 不存在` };
         }
 
@@ -161,6 +175,18 @@ class ExtensionExecutorPlugin extends Plugin {
           // 统一 execute 签名为 (args, framework)
           const result = await toolDef.execute(toolArgs, framework);
 
+          // 检查结果是否为错误
+          if (result && result.success === false && result.error) {
+            // 触发扩展工具错误事件
+            framework.emit('tool:error', {
+              name: `${plugin}:${tool}`,
+              args: toolArgs,
+              error: result.error,
+              source: 'extension'
+            });
+            return result;
+          }
+
           // 触发扩展工具完成事件
           framework.emit('tool:result', {
             name: `${plugin}:${tool}`,