foliko 1.1.13 → 1.1.14

package/src/core/framework.js

@@ -9,6 +9,7 @@ const { EventEmitter } = require('../utils/event-emitter');
 const { PluginManager } = require('./plugin-manager');
 const { ToolRegistry } = require('./tool-registry');
 const { Agent } = require('./agent');
+const { Subagent } = require('./subagent');
 const { SubAgentConfigManager } = require('./sub-agent-config');
 const { ContextManager } = require('./context-manager');
 const { SessionContext } = require('./session-context');
@@ -25,10 +26,9 @@ if (!module.paths.includes(frameworkNodeModules)) {
 // 现有的 AsyncLocalStorage（保持向后兼容）
 const asyncLocalStorage = new AsyncLocalStorage();
 
-// 新增：三层 AsyncLocalStorage
+// 新增：两层 AsyncLocalStorage
 const requestStorage = new AsyncLocalStorage(); // Request 级别
 const sessionStorage = new AsyncLocalStorage(); // Session 级别
-const agentStorage = new AsyncLocalStorage(); // Agent 级别
 
 class Framework extends EventEmitter {
   /**
@@ -498,30 +498,7 @@ class Framework extends EventEmitter {
   }
 
   // ============================================================================
-  // 分层上下文系统 - Agent Context
-  // ============================================================================
-
-  /**
-   * 获取当前 Agent 上下文
-   * @returns {Object|null}
-   */
-  getAgentContext() {
-    return agentStorage.getStore()?.agentContext || null;
-  }
-
-  /**
-   * 在 Agent 上下文中执行函数
-   * @param {string} agentId - Agent ID
-   * @param {Object} context - Agent 上下文
-   * @param {Function} fn - 异步函数
-   * @returns {Promise}
-   */
-  runWithAgentContext(agentId, context, fn) {
-    return agentStorage.run({ agentId, ...context }, fn);
-  }
-
-  // ============================================================================
-  // 组合上下文
+  // 分层上下文系统 - 组合上下文
   // ============================================================================
 
   /**
@@ -589,45 +566,40 @@ class Framework extends EventEmitter {
   }
 
   /**
-   * 创建子Agent（具有独立工具集的轻量级Agent）
+   * 创建子Agent（轻量级，单次任务）
    * @param {Object} config - 子Agent配置
    * @param {string} config.name - 子Agent名称
-   * @param {string} config.role - 角色描述（用于智能选择）
-   * @param {string} [config.description] - 供主Agent理解的描述）
+   * @param {string} [config.role] - 角色描述
+   * @param {string} [config.description] - 描述
+   * @param {string} [config.systemPrompt] - 直接指定的系统提示词（优先使用）
    * @param {Object} [config.tools] - 自定义工具 { name: toolDef }
-   * @param {string[]} [config.parentTools] - 从父Agent继承的工具名称列表）
+   * @param {string[]} [config.parentTools] - 从父Agent继承的工具名称列表
    * @param {Object} [config.llmConfig] - 独立LLM配置
-   * @returns {Agent} 创建的子Agent
+   * @returns {Subagent} 创建的子Agent
    */
   createSubAgent(config) {
     const {
       name,
       role,
       description = '',
+      systemPrompt: providedPrompt,
       tools = {},
-      parentTools, // 如果不传，默认继承主agent所有工具
+      parentTools = [], // 如果不传，默认继承主agent所有工具
       llmConfig = null,
     } = config;
 
-    // 构建子Agent配置
-    const agentConfig = {
-      name: `subagent_${name}`,
-      role: role,
-      systemPrompt: role, // 使用 role 作为 systemPrompt
-      skipSyncTools: true, // 子agent跳过工具同步，使用createSubAgent时已配置的工具
-      ...(llmConfig || {}), // 如果提供了独立LLM配置，合并
-    };
-
-    // 合并 AI 插件配置
-    const merged = this._mergeAIConfig(agentConfig);
+    // 获取 AI 配置
+    const aiPlugin = this.pluginManager.get('ai');
+    const aiConfig = aiPlugin ? aiPlugin.getConfig() : {};
+    const mergedAIConfig = { ...aiConfig, ...(llmConfig || {}) };
 
-    // 创建 Agent
-    const agent = new Agent(this, merged);
+    // 构建工具列表
+    const toolList = [];
 
-    // 注册自定义工具
+    // 添加自定义工具
     for (const [toolName, toolDef] of Object.entries(tools)) {
       if (toolDef && typeof toolDef === 'object') {
-        agent.registerTool({
+        toolList.push({
           name: toolName,
           description: toolDef.description || '',
           inputSchema: toolDef.inputSchema,
@@ -635,31 +607,86 @@ class Framework extends EventEmitter {
         });
       }
     }
-    // 从父Agent继承工具
+
+    // 创建 Subagent
+    // 如果提供了 systemPrompt 则直接使用，否则让 Subagent 动态构建
+    const subagent = new Subagent({
+      name: `subagent_${name}`,
+      role: role || name,
+      description: description,
+      systemPrompt: providedPrompt,
+      model: mergedAIConfig.model || 'deepseek-chat',
+      provider: mergedAIConfig.provider || 'deepseek',
+      apiKey: mergedAIConfig.apiKey,
+      baseURL: mergedAIConfig.baseURL,
+      providerOptions: {
+        maxOutputTokens: mergedAIConfig.maxOutputTokens || 8192,
+        temperature: mergedAIConfig.temperature || 0.3,
+      },
+      tools: toolList,
+      parentTools: parentTools,
+      framework: this, // 传递 framework 引用用于动态构建系统提示词
+    });
+
+    this._agents.push(subagent);
+    this.emit('agent:created', subagent);
+    return subagent;
+  }
+
+  /**
+   * 构建子Agent的系统提示词
+   * @private
+   */
+  _buildSubAgentSystemPrompt(role, description, tools) {
+    const lines = [];
+    const roleName = role || '助手';
+    const descText = description || '';
+
+    // 1. 角色定义
+    lines.push(`你是 ${roleName}。`);
+    if (descText) {
+      lines.push(descText);
+    }
+    lines.push('');
+
+    // 2. 主Agent的系统提示词（基础部分）
     if (this._mainAgent) {
-      const parentToolsDefs = this._mainAgent.getTools();
-      if (parentTools === undefined) {
-        // 如果没有指定 parentTools，默认继承所有工具
-        for (const toolDef of parentToolsDefs) {
-          agent.registerTool(toolDef);
-        }
-      } else if (Array.isArray(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);
-          }
-        }
+      const mainPrompt = this._mainAgent._originalPrompt;
+      if (mainPrompt) {
+        lines.push('## 主Agent的系统提示词');
+        lines.push(mainPrompt);
+        lines.push('');
       }
     }
 
-    this._agents.push(agent);
-    this.emit('agent:created', agent);
-    return agent;
+    // 3. 工具描述
+    if (tools && tools.length > 0) {
+      lines.push('## 可用工具');
+      lines.push('');
+      for (const tool of tools) {
+        const desc = tool.description || '无描述';
+        lines.push(`- **${tool.name}**: ${desc}`);
+      }
+      lines.push('');
+    }
+
+    // 4. 子Agent核心规则
+    lines.push(`## ${roleName} 核心规则
+
+1. **专注本职任务**：只完成与 ${roleName} 相关的任务，不要处理其他领域的请求。
+2. **必须先调用工具**：需要信息或操作时，必须调用工具获取真实结果，禁止直接编造。
+3. **结果导向**：基于工具返回结果回答，不重复工具内部实现细节。
+4. **多步骤任务**：复杂任务拆解为多个工具调用，逐步完成。
+5. **响应规范**：直接给出结论，不说"我需要..."等铺垫话术。
+
+## 禁止事项
+
+- 不调用工具就直接回答
+- 编造数据、文件、订单等信息
+- 处理本职外的任务
+- 回复含糊不清`);
+
+    return lines.join('\n');
   }
 
   /**

package/src/core/index.js

@@ -8,6 +8,11 @@ const { Plugin } = require('./plugin-base');
 const { PluginManager } = require('./plugin-manager');
 const { ToolRegistry } = require('./tool-registry');
 const { EventEmitter } = require('../utils/event-emitter');
+const { ChatSession } = require('./chat-session');
+const { ToolExecutor } = require('./tool-executor');
+const { ContextCompressor } = require('./context-compressor');
+const { NotificationManager } = require('./notification-manager');
+const { TokenCounter } = require('./token-counter');
 
 module.exports = {
   Framework,
@@ -16,4 +21,10 @@ module.exports = {
   PluginManager,
   ToolRegistry,
   EventEmitter,
+  // 新拆分的模块
+  ChatSession,
+  ToolExecutor,
+  ContextCompressor,
+  NotificationManager,
+  TokenCounter,
 };

package/src/core/notification-manager.js

@@ -0,0 +1,125 @@
+/**
+ * NotificationManager - 通知管理器
+ *
+ * 职责：
+ * 1. 收集待处理的调度通知
+ * 2. 收集待处理的思考通知
+ * 3. 格式化通知为可读文本
+ */
+
+const logger = {
+  warn: (context, message, ...args) => console.warn(`[WARN] [${context}] ${message}`, ...args),
+};
+
+/**
+ * 通知优先级常量
+ */
+const NOTIFICATION_CONFIG = {
+  MAX_NOTIFICATIONS: 5,
+};
+
+/**
+ * 格式化调度通知
+ * @param {Object} n - 调度通知对象
+ * @returns {string} 格式化后的文本
+ */
+function formatSchedulerNotification(n) {
+  return `【定时任务通知】\n任务: ${n.taskName || n.taskId}\n执行时间: ${n.executedAt}\n结果: ${n.result || n.action || '执行完成'}`;
+}
+
+/**
+ * 格式化思考通知
+ * @param {Object} t - 思考通知对象
+ * @returns {string} 格式化后的文本
+ */
+function formatThinkNotification(t) {
+  return `【主动思考】\n模式: ${t.mode}\n主题: ${t.topic}\n结果: ${t.result || '思考完成'}`;
+}
+
+class NotificationManager {
+  /**
+   * @param {Framework} framework - 框架实例
+   */
+  constructor(framework) {
+    this.framework = framework;
+  }
+
+  /**
+   * 获取待处理的调度通知并清除（下次不再重复显示）
+   * @returns {Array} 通知数组
+   */
+  getAndClearSchedulerNotifications() {
+    try {
+      const scheduler = this.framework.pluginManager.get('scheduler');
+      if (scheduler?.instance?.getPendingNotifications) {
+        const results = scheduler.instance.getPendingNotifications();
+        if (results.length > 0) {
+          const notifications = results.slice(-NOTIFICATION_CONFIG.MAX_NOTIFICATIONS).reverse();
+          if (scheduler.instance.clearDeliveredNotifications) {
+            scheduler.instance.clearDeliveredNotifications(notifications.length);
+          }
+          return notifications;
+        }
+      }
+    } catch (err) {
+      logger.warn('NotificationManager', '获取调度通知失败', err.message);
+    }
+    return [];
+  }
+
+  /**
+   * 获取待处理的思考结果并清除
+   * @returns {Array} 思考通知数组
+   */
+  getAndClearThinkNotifications() {
+    try {
+      const think = this.framework.pluginManager.get('think');
+      if (think?.instance?.getPendingThoughts) {
+        const thoughts = think.instance.getPendingThoughts();
+        if (thoughts.length > 0) {
+          return thoughts.slice(-NOTIFICATION_CONFIG.MAX_NOTIFICATIONS).reverse();
+        }
+      }
+    } catch (err) {
+      logger.warn('NotificationManager', '获取思考通知失败', err.message);
+    }
+    return [];
+  }
+
+  /**
+   * 获取所有待处理的系统通知（调度 + 思考）
+   * @returns {Array<string>} 格式化后的通知文本数组
+   */
+  getAllPendingNotifications() {
+    const notifications = [];
+
+    // 调度通知
+    const schedulerNotifs = this.getAndClearSchedulerNotifications();
+    for (const n of schedulerNotifs) {
+      notifications.push(formatSchedulerNotification(n));
+    }
+
+    // 思考通知
+    const thinkNotifs = this.getAndClearThinkNotifications();
+    for (const t of thinkNotifs) {
+      notifications.push(formatThinkNotification(t));
+    }
+
+    return notifications;
+  }
+
+  /**
+   * 将通知合并到消息中（用于 chat 输入）
+   * @param {string} message - 原始消息
+   * @returns {string} 增强后的消息
+   */
+  enhanceMessage(message) {
+    const notifications = this.getAllPendingNotifications();
+    if (notifications.length === 0) {
+      return message;
+    }
+    return `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
+  }
+}
+
+module.exports = { NotificationManager };

package/src/core/subagent.js

@@ -0,0 +1,295 @@
+/**
+ * Subagent 类
+ * 轻量级子 Agent，用于完成单次任务
+ * 不需要 session、上下文压缩等复杂功能
+ */
+
+const { EventEmitter } = require('../utils/event-emitter');
+const { cleanResponse } = require('../utils');
+const { generateText, tool, stepCountIs } = require('ai');
+const { z } = require('zod');
+
+class Subagent extends EventEmitter {
+  /**
+   * @param {Object} config - 配置
+   * @param {string} config.name - Subagent 名称
+   * @param {string} [config.role] - 角色描述
+   * @param {string} [config.description] - 描述
+   * @param {string} [config.systemPrompt] - 系统提示词（可选，如果不提供则在 chat 时动态构建）
+   * @param {string} [config.model] - 模型名称
+   * @param {string} [config.provider] - 提供者
+   * @param {string} [config.apiKey] - API 密钥
+   * @param {string} [config.baseURL] - base URL
+   * @param {Object} [config.providerOptions] - 提供者选项
+   * @param {Array|Object} [config.tools] - 工具定义
+   * @param {Object} [config.framework] - Framework 引用（用于动态构建系统提示词）
+   */
+  constructor(config = {}) {
+    super();
+
+    this.name = config.name || 'Subagent';
+    this.role = config.role || '助手';
+    this.description = config.description || '';
+    this.model = config.model || 'deepseek-chat';
+    this.provider = config.provider || 'deepseek';
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL;
+    this.providerOptions = config.providerOptions || {};
+    this.framework = config.framework || null;
+
+    this.defaulTools = ['ext_call', 'subagent_call'];
+
+    this.bindTools = {
+      read: 'read_file',
+      write: 'write_file',
+      edit: 'modify_file',
+      glob: 'read_directory',
+      grep: 'search_file',
+      bash: 'bash',
+    };
+    // 如果提供了 systemPrompt 则使用，否则标记为需要动态构建
+    this._customSystemPrompt = config.systemPrompt || null;
+    this.parentTools = config?.parentTools || [];
+    // 工具管理
+    this._tools = new Map();
+    this._registerTools(config.tools || []);
+
+    this.framework.once('framework:ready', () => {
+      const extExecutor = this.framework?.pluginManager?.get('extension-executor');
+      extExecutor._refreshAllAgentsExtPrompt(this.framework);
+    });
+  }
+
+  /**
+   * 注册工具
+   * @param {Array|Object} tools - 工具定义
+   */
+  _registerTools(tools) {
+    if (Array.isArray(tools)) {
+      for (const t of tools) {
+        if (t && t.name) {
+          this._tools.set(t.name, t);
+        }
+      }
+    } else if (tools && typeof tools === 'object') {
+      for (const [name, t] of Object.entries(tools)) {
+        if (t && typeof t.execute === 'function') {
+          this._tools.set(name, { name, ...t });
+        } else if (t) {
+          this._tools.set(name, t);
+        }
+      }
+    }
+  }
+
+  /**
+   * 添加工具
+   * @param {Object} toolDef - 工具定义 { name, description, inputSchema, execute }
+   */
+  addTool(toolDef) {
+    if (toolDef && toolDef.name) {
+      this._tools.set(toolDef.name, toolDef);
+    }
+    return this;
+  }
+
+  /**
+   * 获取所有工具
+   */
+  getTools() {
+    return Array.from(this._tools.values());
+  }
+
+  /**
+   * 获取 AI 提供者
+   */
+  _getAIProvider() {
+    const { createAI } = require('./provider');
+    return createAI({
+      provider: this.provider,
+      model: this.model,
+      apiKey: this.apiKey,
+      baseURL: this.baseURL,
+    });
+  }
+
+  /**
+   * 构建 AI 工具格式
+   */
+  _buildAITools() {
+    const tools = {};
+    // 从父Agent继承工具
+    const all_tools = this.framework.getTools();
+    this.parentTools = this.parentTools.map((key) => {
+      return this.bindTools[key.toLocaleLowerCase()] || key;
+    });
+    for (const toolName of this.parentTools) {
+      const toolDef = all_tools.find((t) => t.name === toolName);
+      if (toolDef) {
+        tools[toolDef.name] = toolDef;
+      }
+    }
+    const defaulTools = all_tools.filter((a) => this.defaulTools.includes(a.name));
+
+    defaulTools.map((tool) => {
+      tools[tool.name] = tool;
+    });
+    return { ...tools, ...this._tools };
+  }
+
+  /**
+   * 动态构建系统提示词
+   * @private
+   */
+  _buildSystemPrompt() {
+    const lines = [];
+    const roleName = this.role || '助手';
+    const descText = this.description || '';
+
+    // 1. 角色定义
+    lines.push(`你是 ${roleName}。`);
+    if (descText) {
+      lines.push(descText);
+    }
+    lines.push('');
+
+    // if(this._customSystemPrompt){
+    //   lines.push(this._customSystemPrompt)
+    // }
+
+    // 2. 主Agent的系统提示词
+    if (this.framework && this.framework._mainAgent) {
+      const mainPrompt = this.framework._mainAgent._originalPrompt;
+      if (mainPrompt) {
+        lines.push('## 主Agent的系统提示词');
+        lines.push(mainPrompt);
+        lines.push('');
+      }
+    }
+
+    // 3. 工具描述
+    const tools = this._buildAITools();
+
+    const toolKeys = Object.keys(tools);
+    if (toolKeys.length > 0) {
+      lines.push('## 可用工具');
+      lines.push('');
+      for (const key of toolKeys) {
+        const toolDef = tools[key];
+        const desc = toolDef.description || '无描述';
+        lines.push(`- **${toolDef.name}**: ${desc}`);
+      }
+      lines.push('');
+    }
+    const subagentManager = this.framework?.pluginManager?.get('subagent-manager');
+    lines.push(subagentManager._buildDescription());
+    lines.push('');
+    // 3.5 扩展插件工具描述
+    const extExecutor = this.framework?.pluginManager?.get('extension-executor');
+    const extDesc = extExecutor._buildExtensionsDescription();
+    if (extDesc) {
+      lines.push(extDesc);
+      lines.push('');
+    }
+
+    // 4. 子Agent核心规则
+    lines.push(`## ${roleName} 核心规则
+
+1. **专注本职任务**：只完成与 ${roleName} 相关的任务，不要处理其他领域的请求。
+2. **必须先调用工具**：需要信息或操作时，必须调用工具获取真实结果，禁止直接编造。
+3. **结果导向**：基于工具返回结果回答，不重复工具内部实现细节。
+4. **多步骤任务**：复杂任务拆解为多个工具调用，逐步完成。
+5. **响应规范**：直接给出结论，不说"我需要..."等铺垫话术。
+
+## 禁止事项
+
+- 不调用工具就直接回答
+- 编造数据、文件、订单等信息
+- 处理本职外的任务
+- 回复含糊不清`);
+
+    return lines.join('\n');
+  }
+
+  /**
+   * 执行任务
+   * @param {string} task - 任务描述
+   * @param {Object} [options] - 选项
+   * @param {number} [options.maxSteps] - 最大步数
+   * @param {AbortSignal} [options.signal] - 中止信号
+   * @returns {Promise<{success: boolean, message: string, steps: number}>}
+   */
+  async chat(task, options = {}) {
+    const maxSteps = options?.maxSteps || 30;
+    const aiProvider = this._getAIProvider();
+    const messages = [];
+    messages.push({ role: 'user', content: task });
+    try {
+      const tools = this._buildAITools();
+      const systemPrompt = this._buildSystemPrompt();
+      const result = await generateText({
+        model: aiProvider(this.model),
+        system: systemPrompt,
+        messages: messages,
+        tools: tools,
+        stopWhen: stepCountIs(maxSteps),
+        ...this.providerOptions,
+        abortSignal: options.signal,
+        onChunk: (chunk) => {
+          this.emit('chunk', chunk);
+        },
+      });
+      messages.push(...result.response.messages);
+      const full_text = cleanResponse(result.text);
+      this.emit('complete', { message: full_text, steps: result.steps?.length || 0 });
+      return {
+        success: true,
+        message: full_text,
+        steps: result.steps?.length || 0,
+      };
+    } catch (err) {
+      this.emit('error', { error: err.message });
+      return {
+        success: false,
+        message: '',
+        error: err.message,
+        steps: 0,
+      };
+    }
+  }
+
+  /**
+   * 设置角色（会清除自定义 systemPrompt）
+   * @param {string} role - 角色描述
+   */
+  setRole(role) {
+    this.role = role;
+    this._customSystemPrompt = null;
+  }
+
+  /**
+   * 设置描述
+   * @param {string} description - 描述
+   */
+  setDescription(description) {
+    this.description = description;
+  }
+
+  /**
+   * 设置系统提示词（会覆盖动态构建）
+   * @param {string} prompt - 系统提示词
+   */
+  setSystemPrompt(prompt) {
+    this._customSystemPrompt = prompt;
+  }
+
+  /**
+   * 销毁
+   */
+  destroy() {
+    this.removeAllListeners();
+    this._tools.clear();
+  }
+}
+
+module.exports = { Subagent };