foliko 1.0.73 → 1.0.75

package/src/core/agent.js

@@ -3,9 +3,10 @@
  * 负责对话和推理
  */
 
-const { EventEmitter } = require('../utils/event-emitter')
-const { AgentChatHandler } = require('./agent-chat')
-const os = require('os')
+const { EventEmitter } = require('../utils/event-emitter');
+const { AgentChatHandler } = require('./agent-chat');
+const { SystemPromptBuilder } = require('./system-prompt-builder');
+const os = require('os');
 
 class Agent extends EventEmitter {
   /**
@@ -18,44 +19,99 @@ class Agent extends EventEmitter {
    * @param {boolean} [config.enableToolRouting=true] - 是否启用工具路由
    */
   constructor(framework, config = {}) {
-    super()
-
-    this.framework = framework
-    this.config = config
-
-    this.name = config.name || 'Agent'
-    this.model = config.model || 'deepseek-chat'
-    this.apiKey = config.apiKey
-    this.baseURL = config.baseURL
-    this.provider = config.provider || 'deepseek'
-    this.providerOptions = config.providerOptions || {}
-    this.providerOptions.maxOutputTokens=8192
+    super();
+
+    this.framework = framework;
+    this.config = config;
+
+    this.name = config.name || 'Agent';
+    this.model = config.model || 'deepseek-chat';
+    this.apiKey = config.apiKey;
+    this.baseURL = config.baseURL;
+    this.provider = config.provider || 'deepseek';
+    this.providerOptions = config.providerOptions || {};
+    this.providerOptions.maxOutputTokens = 8192;
+    this.providerOptions.temperature = 0.3; // 降低 temperature 减少生成错误 JSON 的概率
     // 原始 system prompt
-    this._originalPrompt = config.systemPrompt || '你是一个智能助手。当用户提出问题或任务时，你会主动分析需求，选择合适的工具来获取信息或执行操作。你善于将复杂任务拆解为多个步骤，通过工具协作完成。'
+    this._originalPrompt =
+      config.systemPrompt ||
+      '你是一个智能助手。当用户提出问题或任务时，你会主动分析需求，选择合适的工具来获取信息或执行操作。你善于将复杂任务拆解为多个步骤，通过工具协作完成。';
 
     // 共享提示模板
-    this._sharedPrompt = config.sharedPrompt || ''
+    this._sharedPrompt = config.sharedPrompt || '';
 
     // 元数据
-    const metadata = config.metadata || {}
-    this._metadata = new Map(Object.entries(metadata))
+    const metadata = config.metadata || {};
+    this._metadata = new Map(Object.entries(metadata));
 
-    this._chatHandler = null
-    this._tools = new Map()
-    this._status = 'idle'
+    this._chatHandler = null;
+    this._tools = new Map();
+    this._status = 'idle';
 
     // 子Agent管理
-    this._subAgents = new Map()
+    this._subAgents = new Map();
 
     // 消息队列（用于 pushMessage）
-    this._messageQueue = []
-    this._isProcessingQueue = false
+    this._messageQueue = [];
+    this._isProcessingQueue = false;
+
+    // System prompt 构建器
+    this._systemPromptBuilder = new SystemPromptBuilder();
+    this._registerDefaultPromptParts();
 
     // 处理后的 system prompt (带上下文)
-    this.systemPrompt = this._buildSystemPrompt()
+    this.systemPrompt = this._buildSystemPrompt();
 
     // 初始化聊天处理器
-    this._initChatHandler()
+    this._initChatHandler();
+  }
+
+  /**
+   * 注册默认的系统提示词部分
+   * @private
+   */
+  _registerDefaultPromptParts() {
+    // 1. 原始 system prompt (优先级 100)
+    this._systemPromptBuilder.register('original-prompt', 100, () => this._originalPrompt);
+
+    // 2. 共享提示模板 (优先级 200)
+    this._systemPromptBuilder.register('shared-prompt', 200, () => {
+      if (this._sharedPrompt) {
+        return this._replacePlaceholders(this._sharedPrompt);
+      }
+      return null;
+    });
+
+    // 3. 元数据 (优先级 300)
+    this._systemPromptBuilder.register('metadata', 300, () => {
+      if (this._metadata.size === 0) {
+        return null;
+      }
+      const metaParts = ['【元数据】'];
+      for (const [key, value] of this._metadata) {
+        if (typeof value === 'object') {
+          metaParts.push(`- ${key}: ${JSON.stringify(value)}`);
+        } else {
+          metaParts.push(`- ${key}: ${value}`);
+        }
+      }
+      return metaParts.join('\n');
+    });
+
+    // 4. 工具列表 (优先级 400)
+    this._systemPromptBuilder.register('tools', 400, () => this._buildToolsDescription());
+
+    // 5. 技能列表 (优先级 500)
+    this._systemPromptBuilder.register('skills', 500, () => this._buildSkillsDescription());
+
+    // 6. 子Agent列表 (优先级 600)
+    this._systemPromptBuilder.register('subagents', 600, () => this._buildSubAgentsDescription());
+
+    // 7. 系统能力 (优先级 700)
+    this._systemPromptBuilder.register('capabilities', 700, () => this._buildCapabilitiesDescription());
+
+    // 8. 工具调用核心规则 (优先级 1000)
+    this._systemPromptBuilder.register('tool-core-rules', 1000, () => this._getToolCoreRules());
   }
 
   /**
@@ -64,26 +120,26 @@ class Agent extends EventEmitter {
   _getMetadataValue(key) {
     // 优先从 metadata 获取
     if (this._metadata.has(key)) {
-      return this._metadata.get(key)
+      return this._metadata.get(key);
     }
 
     // 内置变量
     switch (key) {
       case 'WORK_DIR':
       case 'CWD':
-        return process.cwd()
+        return process.cwd();
       case 'HOME_DIR':
-        return os.homedir()
+        return os.homedir();
       case 'HOST_NAME':
-        return os.hostname()
+        return os.hostname();
       case 'PLATFORM':
-        return process.platform
+        return process.platform;
       case 'TIME':
-        return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' })
+        return new Date().toLocaleString('zh-CN', { timeZone: 'Asia/Shanghai' });
       case 'DATE':
-        return new Date().toISOString().split('T')[0]
+        return new Date().toISOString().split('T')[0];
       default:
-        return `{{${key}}}`
+        return `{{${key}}}`;
     }
   }
 
@@ -92,8 +148,8 @@ class Agent extends EventEmitter {
    */
   _replacePlaceholders(template) {
     return template.replace(/\{\{(\w+)\}\}/g, (match, key) => {
-      return this._getMetadataValue(key)
-    })
+      return this._getMetadataValue(key);
+    });
   }
 
   /**
@@ -101,155 +157,295 @@ class Agent extends EventEmitter {
    */
   _buildToolsDescription() {
     if (this._tools.size === 0) {
-      return ''
+      return '';
     }
 
-    let desc = '【可用工具】\n'
+    // 需要排除的子Agent相关工具（它们通过专门的子Agent部分提供）
+    // const excludedTools = new Set(['subagent_call', 'subagent_list', 'subagent_reload']);
+
+    let desc = '【可用工具】\n';
     for (const [name, tool] of this._tools) {
       // 跳过没有描述的工具（对LLM无帮助）
-      if (!tool.description) continue
-      desc += `- ${name}: ${tool.description}\n`
+      if (!tool.description) continue;
+      // // 跳过子Agent相关工具（通过专门的子Agent部分提供）
+      // if (excludedTools.has(name)) continue;
+      // // 跳过子Agent委托工具（通过专门的子Agent部分提供）
+      // if (this._subAgents.has(name)) continue;
+      desc += `- ${name}: ${tool.description}\n`;
     }
-    return desc.trim()
+    return desc.trim();
   }
 
   /**
    * 构建技能描述
    */
   _buildSkillsDescription() {
-    const skillManager = this.framework.pluginManager.get('skill-manager')
+    const skillManager = this.framework.pluginManager.get('skill-manager');
     if (!skillManager) {
-      return ''
+      return '';
     }
 
-    const skills = skillManager.getAllSkills()
+    const skills = skillManager.getAllSkills();
     if (!skills || skills.length === 0) {
-      return ''
+      return '';
     }
 
-    let desc = '【可用技能】\n'
+    let desc = '【可用技能】\n';
     for (const skill of skills) {
-      const name = skill.metadata?.name || skill.name || 'unknown'
-      const descText = skill.metadata?.description || ''
-      desc += `- ${name}: ${descText}\n`
+      const name = skill.metadata?.name || skill.name || 'unknown';
+      const descText = skill.metadata?.description || '';
+      desc += `- ${name}: ${descText}\n`;
     }
-    desc += '\n重要：当需要开发插件、执行专业任务时，必须先使用 loadSkill 工具加载对应技能，获取专业指导。'
-    return desc.trim()
+    desc +=
+      '\n重要：当需要开发插件、执行专业任务时，必须先使用 loadSkill 工具加载对应技能，获取专业指导。';
+    return desc.trim();
   }
 
   /**
    * 构建系统能力描述
    */
   _buildCapabilitiesDescription() {
-    const plugins = this.framework.pluginManager.getAll()
+    const plugins = this.framework.pluginManager.getAll();
     if (!plugins || plugins.length === 0) {
-      return ''
+      return '';
     }
 
     // 过滤出有描述的关键插件（排除内部插件）
-    const keyPlugins = plugins.filter(p => {
-      const name = p.name
+    const keyPlugins = plugins.filter((p) => {
+      const name = p.name;
       // 排除默认配置插件和内部插件
-      return name !== 'defaults' && name !== 'agent'
-    })
+      return name !== 'defaults' && name !== 'agent';
+    });
 
     if (keyPlugins.length === 0) {
-      return ''
+      return '';
     }
 
-    let desc = '【系统能力】\n'
+    let desc = '【系统能力】\n';
     for (const plugin of keyPlugins) {
-      const name = plugin.instance?.name || plugin.name || 'unknown'
-      const description = plugin.instance?.description || '无描述'
-      desc += `- ${name}: ${description}\n`
+      const name = plugin.instance?.name || plugin.name || 'unknown';
+      const description = plugin.instance?.description || '无描述';
+      desc += `- ${name}: ${description}\n`;
     }
 
-    return desc.trim()
+    return desc.trim();
   }
 
   /**
    * 构建子Agent描述
+   * 动态从配置文件读取每个子Agent的专业领域
    */
   _buildSubAgentsDescription() {
-    if (this._subAgents.size === 0) {
-      return ''
+    const subAgentManager = this.framework.pluginManager.get('subagent-manager');
+    if (!subAgentManager) {
+      return '';
+    }
+    const allSubAgents = subAgentManager.getAllSubAgents();
+    if (!allSubAgents || allSubAgents.length === 0) {
+      return '';
+    }
+
+    let desc = '【子 Agent 匹配表 - 优先使用】\n';
+
+    // 动态从配置文件读取每个子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(', ')})`;
+        }
+        desc += `  - ${name}: ${info}\n`;
+      } else {
+        // 回退到旧逻辑
+        desc += `  - ${name}: ${role || goal || '子代理'}\n`;
+      }
     }
 
-    let desc = '【子 Agent 分配规则 - 必须遵守】\n'
-    desc += '1. 每个子Agent有固定的专业领域，必须委托给对应的专家：\n'
-    for (const [name, { role, goal }] of this._subAgents) {
-      desc += `  - ${name}: ${role || goal || '子代理'}\n`
-    }
-    desc += '2. 你需要对任务进行拆分，传递给对应的子Agent执行。\n'
-    desc += '3. 多个不同类型的任务必须分别委托给不同的子Agent，每个子Agent只处理自己专业领域的任务。\n'
-    desc += '\n【可委托的子 Agent】\n'
-    for (const [name, { role, goal }] of this._subAgents) {
-      desc += `  - ${name}: ${role || goal || '子代理'}\n`
-    }
-    desc += '\n使用 subagent_call 工具并指定 agentName 来委托任务给相应子Agent。'
+    // 通用规则
+    desc += '\n【子Agent匹配规则 - 必须遵守】\n';
+    desc += '  - 根据上述【子 Agent 匹配表】，将任务委托给最匹配的子Agent处理\n';
+    desc += '  - 使用 subagent_call 工具并指定 agentName 来委托任务\n';
+    desc += '  - 只有当没有匹配的子Agent时，才直接调用工具\n';
 
-    return desc.trim()
+    return desc.trim();
   }
 
   /**
-   * 构建系统提示（带上下文）
+   * 从配置文件动态读取子Agent的核心能力
+   * 支持 .json 和 .md 格式
+   * @private
    */
-  _buildSystemPrompt() {
-    const parts = []
+  _getSubAgentCapabilities(name) {
+    try {
+      const fs = require('fs');
+      const path = require('path');
+      const agentsDir = path.join(process.cwd(), '.agent', 'agents');
+
+      // 尝试多种文件格式
+      const possiblePaths = [
+        path.join(agentsDir, `${name}.md`),
+        path.join(agentsDir, `${name}.json`),
+      ];
+
+      let filePath = null;
+      for (const p of possiblePaths) {
+        if (fs.existsSync(p)) {
+          filePath = p;
+          break;
+        }
+      }
 
-    // 1. 原始 system prompt
-    parts.push(this._originalPrompt)
+      if (!filePath) {
+        return null;
+      }
 
-    // 2. 共享提示模板（带占位符替换）
-    if (this._sharedPrompt) {
-      const replaced = this._replacePlaceholders(this._sharedPrompt)
-      parts.push(replaced)
-    }
+      const content = fs.readFileSync(filePath, 'utf-8');
 
-    // 3. 元数据
-    if (this._metadata.size > 0) {
-      const metaParts = ['【元数据】']
-      for (const [key, value] of this._metadata) {
-        if (typeof value === 'object') {
-          metaParts.push(`- ${key}: ${JSON.stringify(value)}`)
-        } else {
-          metaParts.push(`- ${key}: ${value}`)
-        }
+      // .json 格式
+      if (filePath.endsWith('.json')) {
+        const config = JSON.parse(content);
+        return this._extractCapabilitiesFromConfig(config);
       }
-      parts.push(metaParts.join('\n'))
-    }
 
-    // 4. 工具列表
-    const toolsDesc = this._buildToolsDescription()
-    if (toolsDesc) {
-      parts.push(toolsDesc)
+      // .md 格式（YAML front matter + markdown）
+      if (filePath.endsWith('.md')) {
+        return this._extractCapabilitiesFromMd(content);
+      }
+
+      return null;
+    } catch (e) {
+      return null;
     }
+  }
 
-    // 5. 技能列表
-    const skillsDesc = this._buildSkillsDescription()
-    if (skillsDesc) {
-      parts.push(skillsDesc)
+  /**
+   * 从 JSON 配置中提取核心能力
+   */
+  _extractCapabilitiesFromConfig(config) {
+    if (config.instructions) {
+      const match = config.instructions.match(/【核心能力】([\s\S]*?)(?=【|$)/);
+      if (match) {
+        const capabilities = match[1]
+          .split('\n')
+          .map((line) => line.replace(/^[·\-*]\s*/, '').trim())
+          .filter((line) => line && !line.startsWith('你是一个'))
+          .slice(0, 4)
+          .join('、');
+        return capabilities || config.description;
+      }
+      return config.description;
     }
+    return config.description || null;
+  }
 
-    // 6. 子Agent列表
-    const subAgentsDesc = this._buildSubAgentsDescription()
-    if (subAgentsDesc) {
-      parts.push(subAgentsDesc)
+  /**
+   * 从 .md 文件（YAML front matter）中提取核心能力
+   */
+  _extractCapabilitiesFromMd(mdContent) {
+    // 解析 YAML front matter
+    const frontMatterMatch = mdContent.match(/^---\n([\s\S]*?)\n---/);
+    if (!frontMatterMatch) {
+      return null;
     }
 
-    // 7. 系统能力
-    const capabilitiesDesc = this._buildCapabilitiesDescription()
-    if (capabilitiesDesc) {
-      parts.push(capabilitiesDesc)
+    const frontMatter = frontMatterMatch[1];
+    const config = {};
+
+    // 简单解析 YAML front matter
+    for (const line of frontMatter.split('\n')) {
+      const colonIndex = line.indexOf(':');
+      if (colonIndex > 0) {
+        const key = line.substring(0, colonIndex).trim();
+        let value = line.substring(colonIndex + 1).trim();
+        // 移除可能的引号
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+          value = value.slice(1, -1);
+        }
+        config[key] = value;
+      }
     }
+    // 从 description 字段提取能力
+    if (config.description) {
+      const desc = config.description;
+      // 按逗号/顿号分隔
+      const parts = desc.split(/[,，、]/).map(s => s.trim());
+      // 取第一部分（通常是最核心的能力描述）
+      const firstPart = parts[0];
+      // 如果第一部分太长（说明是句子），取前50个字符
+      if (firstPart.length > 50) {
+        return firstPart.substring(0, 50).trim() + '...';
+      }
+      // 如果有多个部分，取前3个
+      if (parts.length > 1) {
+        return parts.slice(0, 3).join('、');
+      }
+      return firstPart;
+    }
+
+    return null;
+  }
 
-    // 8. 工具调用核心规则（统一追加到所有 Agent）
-    const toolCoreRules = this._getToolCoreRules()
-    if (toolCoreRules) {
-      parts.push(toolCoreRules)
+  _buildSystemPrompt() {
+    // 如果没变脏，返回缓存
+    if (!this._systemPromptDirty && this._systemPromptCache !== null) {
+      return this._systemPromptCache;
     }
 
-    return parts.join('\n\n')
+    // 使用 builder 构建系统提示词
+    this._systemPromptCache = this._systemPromptBuilder.build();
+    this._systemPromptDirty = false;
+    return this._systemPromptCache;
+  }
+
+  /**
+   * 使 system prompt 缓存失效
+   * @private
+   */
+  _invalidateSystemPromptCache() {
+    this._systemPromptDirty = true;
+    // 同时使 builder 中所有部分失效
+    this._systemPromptBuilder.invalidateAll();
+  }
+
+  /**
+   * 注册自定义系统提示词部分（供插件使用）
+   * @param {string} name - 部分名称
+   * @param {number} priority - 优先级
+   * @param {Function} provider - 返回提示词内容的函数
+   */
+  registerPromptPart(name, priority, provider) {
+    this._systemPromptBuilder.register(name, priority, provider);
+    this._invalidateSystemPromptCache();
+    return this;
+  }
+
+  /**
+   * 注销系统提示词部分
+   * @param {string} name - 部分名称
+   */
+  unregisterPromptPart(name) {
+    this._systemPromptBuilder.unregister(name);
+    this._invalidateSystemPromptCache();
+    return this;
+  }
+
+  /**
+   * 使特定系统提示词部分失效
+   * @param {string} name - 部分名称
+   */
+  invalidatePromptPart(name) {
+    this._systemPromptBuilder.invalidate(name);
+    this._systemPromptDirty = true;
+    return this;
   }
 
   /**
@@ -258,12 +454,13 @@ class Agent extends EventEmitter {
    */
   _getToolCoreRules() {
     return `【工具调用核心规则】
-1. **必须先调用工具再回复**：当问题需要信息、操作或计算时，必须调用工具获取真实结果后才能回答。禁止在未调用工具的情况下直接给出答案。
-2. **禁止编造数据**：不许捏造用户、订单、任务、文件、内容等任何数据。所有数据必须通过工具获取。
-3. **工具优先**：可用工具列表会提供，格式为 toolName(toolArgs)。不确定用哪个工具时，优先调用可能相关的工具。
-4. **结果导向**：调用工具后，基于返回结果回答，不要重复工具的内部实现细节。
-5. **多步骤任务**：复杂任务拆解为多个工具调用，逐步完成，每步基于结果决定下一步。
-6. **子Agent委托**：当任务匹配子Agent专业领域时，使用 subagent_call 工具委托给对应子Agent处理。
+1. **子Agent优先**：任务匹配子Agent专业领域时，**必须优先使用** 使用 subagent_call 工具并指定 agentName 委托给对应子Agent处理，而不是直接调用工具。只有当没有匹配的子Agent时，才直接调用工具。
+2. **必须先调用工具再回复**：当问题需要信息、操作或计算时，必须调用工具获取真实结果后才能回答。禁止在未调用工具的情况下直接给出答案。
+3. **禁止编造数据**：不许捏造用户、订单、任务、文件、内容等任何数据。所有数据必须通过工具获取。
+4. **工具优先**：可用工具列表会提供，格式为 toolName(toolArgs)。不确定用哪个工具时，优先调用可能相关的工具。
+5. **结果导向**：调用工具后，基于返回结果回答，不要重复工具的内部实现细节。
+6. **多步骤任务**：复杂任务拆解为多个工具调用，逐步完成，每步基于结果决定下一步。
+
 
 【响应规范】
 - 直接给出结论或结果，不说"我需要..."、"我建议..."等铺垫话术
@@ -273,16 +470,16 @@ class Agent extends EventEmitter {
 【禁止事项】
 - 不调用工具就直接回答
 - 编造不存在的数据、文件、订单、用户等信息
-- 回复含糊不清，让用户无法确定答案是否正确`
+- 回复含糊不清，让用户无法确定答案是否正确`;
   }
 
   /**
    * 刷新上下文
    */
   _refreshContext() {
-    this.systemPrompt = this._buildSystemPrompt()
+    this.systemPrompt = this._buildSystemPrompt();
     if (this._chatHandler) {
-      this._chatHandler.setSystemPrompt(this.systemPrompt)
+      this._chatHandler.setSystemPrompt(this.systemPrompt);
     }
   }
 
@@ -291,10 +488,10 @@ class Agent extends EventEmitter {
    * @private
    */
   _initChatHandler() {
-    let aiClient = null
-    const aiPlugin = this.framework.pluginManager.get('ai')
+    let aiClient = null;
+    const aiPlugin = this.framework.pluginManager.get('ai');
     if (aiPlugin) {
-      aiClient = aiPlugin.getAIClient()
+      aiClient = aiPlugin.getAIClient();
     }
 
     this._chatHandler = new AgentChatHandler(this, {
@@ -307,52 +504,53 @@ class Agent extends EventEmitter {
       maxContextTokens: this.config.maxContextTokens,
       compressionThreshold: this.config.compressionThreshold,
       keepRecentMessages: this.config.keepRecentMessages,
-      enableSmartCompress: this.config.enableSmartCompress
-    })
+      enableSmartCompress: this.config.enableSmartCompress,
+    });
 
     if (aiClient) {
-      this._chatHandler.setAIClient(aiClient)
+      this._chatHandler.setAIClient(aiClient);
     }
 
     // 转发事件
-    this._chatHandler.on('message', (msg) => this.emit('message', msg))
-    this._chatHandler.on('chunk', (chunk) => this.emit('chunk', chunk))
-    this._chatHandler.on('tool-call', (tool) => this.emit('tool-call', tool))
-    this._chatHandler.on('tool-result', (result) => this.emit('tool-result', result))
-    this._chatHandler.on('error', (err) => this.emit('error', err))
+    this._chatHandler.on('message', (msg) => this.emit('message', msg));
+    this._chatHandler.on('chunk', (chunk) => this.emit('chunk', chunk));
+    this._chatHandler.on('tool-call', (tool) => this.emit('tool-call', tool));
+    this._chatHandler.on('tool-result', (result) => this.emit('tool-result', result));
+    this._chatHandler.on('error', (err) => this.emit('error', err));
 
-    this._syncTools()
+    this._syncTools();
   }
 
   /**
    * 设置系统提示
    */
   setSystemPrompt(prompt) {
-    this._originalPrompt = prompt
-    this.systemPrompt = this._buildSystemPrompt()
+    this._originalPrompt = prompt;
+    this.systemPrompt = this._buildSystemPrompt();
     if (this._chatHandler) {
-      this._chatHandler.setSystemPrompt(this.systemPrompt)
+      this._chatHandler.setSystemPrompt(this.systemPrompt);
     }
-    return this
+    return this;
   }
 
   /**
    * 注册工具到 Agent
    */
   registerTool(tool) {
-    this._tools.set(tool.name, tool)
+    this._tools.set(tool.name, tool);
+    this._invalidateSystemPromptCache();
     if (this._chatHandler) {
-      this._chatHandler.registerTool(tool)
+      this._chatHandler.registerTool(tool);
     }
-    this._refreshContext()
-    return this
+    this._refreshContext();
+    return this;
   }
 
   /**
    * 获取已注册工具
    */
   getTools() {
-    return Array.from(this._tools.values())
+    return Array.from(this._tools.values());
   }
 
   /**
@@ -363,7 +561,7 @@ class Agent extends EventEmitter {
     if (this.framework.toolRegistry.size() > 0) {
       for (const tool of this.framework.getTools()) {
         if (!this._tools.has(tool.name)) {
-          this.registerTool(tool)
+          this.registerTool(tool);
         }
       }
     }
@@ -377,25 +575,27 @@ class Agent extends EventEmitter {
    * @param {string} goal - 目标描述
    */
   registerSubAgent(name, agent, role, goal) {
-    this._subAgents.set(name, { agent, role, goal })
-    this._refreshContext()
-    return this
+    this._subAgents.set(name, { agent, role, goal });
+    this._invalidateSystemPromptCache();
+    this._refreshContext();
+    return this;
   }
 
   /**
    * 注销子Agent
    */
   unregisterSubAgent(name) {
-    this._subAgents.delete(name)
-    this._refreshContext()
-    return this
+    this._subAgents.delete(name);
+    this._invalidateSystemPromptCache();
+    this._refreshContext();
+    return this;
   }
 
   /**
    * 获取所有子Agent
    */
   getSubAgents() {
-    return this._subAgents
+    return this._subAgents;
   }
 
   /**
@@ -403,22 +603,22 @@ class Agent extends EventEmitter {
    */
   _getAndClearSchedulerNotifications() {
     try {
-      const scheduler = this.framework.pluginManager.get('scheduler')
+      const scheduler = this.framework.pluginManager.get('scheduler');
       if (scheduler && scheduler.instance && scheduler.instance.getPendingNotifications) {
-        const results = scheduler.instance.getPendingNotifications()
+        const results = scheduler.instance.getPendingNotifications();
         if (results.length > 0) {
-          const notifications = results.slice(-5).reverse() // 最多5条，最新的在前
+          const notifications = results.slice(-5).reverse(); // 最多5条，最新的在前
           // 清除已发送的通知
           if (scheduler.instance.clearDeliveredNotifications) {
-            scheduler.instance.clearDeliveredNotifications(notifications.length)
+            scheduler.instance.clearDeliveredNotifications(notifications.length);
           }
-          return notifications
+          return notifications;
         }
       }
     } catch (err) {
       // 忽略错误，避免影响主流程
     }
-    return []
+    return [];
   }
 
   /**
@@ -426,38 +626,42 @@ class Agent extends EventEmitter {
    */
   _getAndClearThinkNotifications() {
     try {
-      const think = this.framework.pluginManager.get('think')
+      const think = this.framework.pluginManager.get('think');
       if (think && think.instance && think.instance.getPendingThoughts) {
-        const thoughts = think.instance.getPendingThoughts()
+        const thoughts = think.instance.getPendingThoughts();
         if (thoughts.length > 0) {
-          return thoughts.slice(-5).reverse() // 最多5条，最新的在前
+          return thoughts.slice(-5).reverse(); // 最多5条，最新的在前
         }
       }
     } catch (err) {
       // 忽略错误，避免影响主流程
     }
-    return []
+    return [];
   }
 
   /**
    * 获取所有待处理的系统通知（调度 + 思考）
    */
   _getAllPendingNotifications() {
-    const notifications = []
+    const notifications = [];
 
     // 调度通知
-    const schedulerNotifs = this._getAndClearSchedulerNotifications()
+    const schedulerNotifs = this._getAndClearSchedulerNotifications();
     for (const n of schedulerNotifs) {
-      notifications.push(`【定时任务通知】\n任务: ${n.taskName || n.taskId}\n执行时间: ${n.executedAt}\n结果: ${n.result || n.action || '执行完成'}`)
+      notifications.push(
+        `【定时任务通知】\n任务: ${n.taskName || n.taskId}\n执行时间: ${n.executedAt}\n结果: ${n.result || n.action || '执行完成'}`
+      );
     }
 
     // 思考通知
-    const thinkNotifs = this._getAndClearThinkNotifications()
+    const thinkNotifs = this._getAndClearThinkNotifications();
     for (const t of thinkNotifs) {
-      notifications.push(`【主动思考】\n模式: ${t.mode}\n主题: ${t.topic}\n结果: ${t.result || '思考完成'}`)
+      notifications.push(
+        `【主动思考】\n模式: ${t.mode}\n主题: ${t.topic}\n结果: ${t.result || '思考完成'}`
+      );
     }
 
-    return notifications
+    return notifications;
   }
 
   /**
@@ -465,42 +669,42 @@ class Agent extends EventEmitter {
    */
   async chat(message, options = {}) {
     if (this._status === 'busy') {
-      throw new Error('Agent is busy')
+      throw new Error('Agent is busy');
     }
 
     if (this._status === 'error') {
-      this._status = 'idle'
+      this._status = 'idle';
     }
 
-    this._status = 'busy'
-    this.emit('status', { status: 'busy' })
+    this._status = 'busy';
+    this.emit('status', { status: 'busy' });
 
     try {
       // 检查是否有待处理的系统通知（调度 + 思考）
-      const notifications = this._getAllPendingNotifications()
-      let enhancedMessage = message
+      const notifications = this._getAllPendingNotifications();
+      let enhancedMessage = message;
       if (notifications.length > 0) {
-        enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`
+        enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
       }
 
-      this._syncTools()
+      this._syncTools();
 
-      const result = await this._chatHandler.chat(enhancedMessage, options)
-      this._status = 'idle'
-      this.emit('status', { status: 'idle' })
+      const result = await this._chatHandler.chat(enhancedMessage, options);
+      this._status = 'idle';
+      this.emit('status', { status: 'idle' });
 
       // 处理队列中的下一条消息
-      setImmediate(() => this._processQueue())
+      setImmediate(() => this._processQueue());
 
-      return result
+      return result;
     } catch (err) {
-      this._status = 'error'
-      this.emit('status', { status: 'error', error: err.message })
+      this._status = 'error';
+      this.emit('status', { status: 'error', error: err.message });
 
       // 发生错误时也要处理队列
-      setImmediate(() => this._processQueue())
+      setImmediate(() => this._processQueue());
 
-      throw err
+      throw err;
     }
   }
 
@@ -514,25 +718,25 @@ class Agent extends EventEmitter {
    */
   async pushMessage(message, options = {}) {
     // 自动从执行上下文获取 sessionId
-    const ctx = this.framework.getExecutionContext()
+    const ctx = this.framework.getExecutionContext();
     if (ctx?.sessionId && !options.sessionId) {
-      options.sessionId = ctx.sessionId
+      options.sessionId = ctx.sessionId;
     }
 
     // 如果忙碌，进入队列等待
     if (this._status === 'busy') {
-      const queuedItem = { message, options, resolve: null, reject: null }
+      const queuedItem = { message, options, resolve: null, reject: null };
       const promise = new Promise((resolve, reject) => {
-        queuedItem.resolve = resolve
-        queuedItem.reject = reject
-      })
-      this._messageQueue.push(queuedItem)
-      console.log('[Agent] busy, message queued')
-      return promise
+        queuedItem.resolve = resolve;
+        queuedItem.reject = reject;
+      });
+      this._messageQueue.push(queuedItem);
+      // Agent busy, message queued
+      return promise;
     }
 
     // 空闲则直接处理
-    return this.chat(message, options)
+    return this.chat(message, options);
   }
 
   /**
@@ -541,25 +745,25 @@ class Agent extends EventEmitter {
    */
   async _processQueue() {
     if (this._isProcessingQueue || this._messageQueue.length === 0) {
-      return
+      return;
     }
 
-    this._isProcessingQueue = true
+    this._isProcessingQueue = true;
 
     // 强制设置为 idle，确保 this.chat() 能执行
-    this._status = 'idle'
+    this._status = 'idle';
 
     while (this._messageQueue.length > 0) {
-      const item = this._messageQueue.shift()
+      const item = this._messageQueue.shift();
       try {
-        const result = await this.chat(item.message, item.options)
-        item.resolve(result)
+        const result = await this.chat(item.message, item.options);
+        item.resolve(result);
       } catch (err) {
-        item.reject(err)
+        item.reject(err);
       }
     }
 
-    this._isProcessingQueue = false
+    this._isProcessingQueue = false;
   }
 
   /**
@@ -567,41 +771,41 @@ class Agent extends EventEmitter {
    */
   async *chatStream(message, options = {}) {
     if (this._status === 'busy') {
-      throw new Error('Agent is busy')
+      throw new Error('Agent is busy');
     }
 
     // 允许从 error 状态重试
     if (this._status === 'error') {
-      this._status = 'idle'
+      this._status = 'idle';
     }
 
-    this._status = 'busy'
-    this.emit('status', { status: 'busy' })
+    this._status = 'busy';
+    this.emit('status', { status: 'busy' });
 
     try {
       // 检查是否有待处理的系统通知（调度 + 思考）
-      const notifications = this._getAllPendingNotifications()
-      let enhancedMessage = message
+      const notifications = this._getAllPendingNotifications();
+      let enhancedMessage = message;
       if (notifications.length > 0) {
-        enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`
+        enhancedMessage = `【系统通知】\n${notifications.join('\n\n')}\n\n---\n用户消息: ${message}`;
       }
 
-      this._syncTools()
+      this._syncTools();
 
-      yield* this._chatHandler.chatStream(enhancedMessage, options)
-      this._status = 'idle'
-      this.emit('status', { status: 'idle' })
+      yield* this._chatHandler.chatStream(enhancedMessage, options);
+      this._status = 'idle';
+      this.emit('status', { status: 'idle' });
 
       // 处理队列中的下一条消息
-      setImmediate(() => this._processQueue())
+      setImmediate(() => this._processQueue());
     } catch (err) {
-      this._status = 'error'
-      this.emit('status', { status: 'error', error: err.message })
+      this._status = 'error';
+      this.emit('status', { status: 'error', error: err.message });
 
       // 发生错误时也要处理队列
-      setImmediate(() => this._processQueue())
+      setImmediate(() => this._processQueue());
 
-      throw err
+      throw err;
     }
   }
 
@@ -610,39 +814,40 @@ class Agent extends EventEmitter {
    */
   setMetadata(keyOrObj, value) {
     if (typeof keyOrObj === 'string') {
-      this._metadata.set(keyOrObj, value)
+      this._metadata.set(keyOrObj, value);
     } else if (keyOrObj && typeof keyOrObj === 'object') {
       for (const [key, val] of Object.entries(keyOrObj)) {
-        this._metadata.set(key, val)
+        this._metadata.set(key, val);
       }
     }
-    this._refreshContext()
-    return this
+    this._invalidateSystemPromptCache();
+    this._refreshContext();
+    return this;
   }
 
   /**
    * 获取元数据
    */
   getMetadata(key) {
-    return this._metadata.get(key)
+    return this._metadata.get(key);
   }
 
   /**
    * 删除元数据
    */
   deleteMetadata(key) {
-    this._metadata.delete(key)
-    this._refreshContext()
-    return this
+    this._metadata.delete(key);
+    this._refreshContext();
+    return this;
   }
 
   /**
    * 清空元数据
    */
   clearMetadata() {
-    this._metadata.clear()
-    this._refreshContext()
-    return this
+    this._metadata.clear();
+    this._refreshContext();
+    return this;
   }
 
   /**
@@ -650,25 +855,25 @@ class Agent extends EventEmitter {
    */
   clearHistory() {
     if (this._chatHandler) {
-      this._chatHandler.clearHistory()
+      this._chatHandler.clearHistory();
     }
-    return this
+    return this;
   }
 
   /**
    * 获取状态
    */
   getStatus() {
-    return this._status
+    return this._status;
   }
 
   /**
    * 重置状态（从卡住状态恢复）
    */
   resetStatus() {
-    this._status = 'idle'
-    this.emit('status', { status: 'idle' })
-    return this
+    this._status = 'idle';
+    this.emit('status', { status: 'idle' });
+    return this;
   }
 
   /**
@@ -676,12 +881,12 @@ class Agent extends EventEmitter {
    */
   destroy() {
     if (this._chatHandler) {
-      this._chatHandler.destroy()
+      this._chatHandler.destroy();
     }
-    this._tools.clear()
-    this.removeAllListeners()
-    this.emit('destroyed')
+    this._tools.clear();
+    this.removeAllListeners();
+    this.emit('destroyed');
   }
 }
 
-module.exports = { Agent }
+module.exports = { Agent };