foliko 1.1.64 → 1.1.65

package/plugins/think-plugin.js

@@ -13,8 +13,8 @@ class ThinkPlugin extends Plugin {
     super()
     this.name = 'think'
     this.version = '1.0.0'
-    this.description = '主动思考插件，支持 LLM 自我唤醒和持续思考'
-    this.priority = 5  // 高优先级，早期加载
+    this.description = '主动思考插件,支持 LLM 自我唤醒和持续思考'
+    this.priority = 5  // 高优先级,早期加载
 
     this.config = {
       autoReflect: config.autoReflect === true,  // 默认关闭自动反思
@@ -32,7 +32,7 @@ class ThinkPlugin extends Plugin {
     this._continuousTopic = null
     this._continuousMessages = []  // 持续思考的上下文消息
     this._continuousRounds = 0     // 持续思考轮次计数
-    this._lastThinkResultHash = null  // 上次思考结果 hash（用于检测重复）
+    this._lastThinkResultHash = null  // 上次思考结果 hash(用于检测重复)
     this._consecutiveSimilarRounds = 0  // 连续相似轮次计数
     this._maxContinuousRounds = 10  // 默认最大轮次
     this._pendingReflection = null
@@ -45,14 +45,14 @@ class ThinkPlugin extends Plugin {
 
   start(framework) {
     // 注册思考工具 - 这些工具可以让主 agent 的 LLM 调用
-    // think 支持工具执行循环，LLM 可以让它完成需要调用工具的任务
+    // think 支持工具执行循环,LLM 可以让它完成需要调用工具的任务
 
     framework.registerTool({
       name: 'think_now',
-      description: '触发深度思考，支持调用工具分析项目代码。当需要分析、优化、修改代码或文件时使用此工具。',
+      description: '触发深度思考,支持调用工具分析项目代码。当需要分析、优化、修改代码或文件时使用此工具。',
       inputSchema: z.object({
-        topic: z.string().optional().describe('思考主题，不提供则让 LLM 自己决定思考什么'),
-        mode: z.enum(['reflect', 'brainstorm', 'analyze', 'plan']).optional().describe('思考模式：reflect=反思、brainstorm=头脑风暴、analyze=分析、plan=计划'),
+        topic: z.string().optional().describe('思考主题,不提供则让 LLM 自己决定思考什么'),
+        mode: z.enum(['reflect', 'brainstorm', 'analyze', 'plan']).optional().describe('思考模式:reflect=反思、brainstorm=头脑风暴、analyze=分析、plan=计划'),
         depth: z.number().optional().describe('思考深度 1-5')
       }),
       execute: async (args) => {
@@ -62,11 +62,11 @@ class ThinkPlugin extends Plugin {
 
     framework.registerTool({
       name: 'think_continue',
-      description: '持续后台思考，定期输出结果。适用于需要持续分析和迭代的任务。',
+      description: '持续后台思考,定期输出结果。适用于需要持续分析和迭代的任务。',
       inputSchema: z.object({
-        interval: z.number().optional().describe('思考间隔毫秒，默认 30000 (30秒)'),
+        interval: z.number().optional().describe('思考间隔毫秒,默认 30000 (30秒)'),
         topic: z.string().optional().describe('思考主题'),
-        maxRounds: z.number().optional().describe('最大轮次，默认 10')
+        maxRounds: z.number().optional().describe('最大轮次,默认 10')
       }),
       execute: async (args) => {
         return await this._startContinuousThinking(args)
@@ -86,7 +86,7 @@ class ThinkPlugin extends Plugin {
       name: 'think_get_thoughts',
       description: '获取思考历史记录',
       inputSchema: z.object({
-        limit: z.number().optional().describe('返回条数，默认 10')
+        limit: z.number().optional().describe('返回条数,默认 10')
       }),
       execute: async (args) => {
         const limit = args.limit || 10
@@ -113,13 +113,13 @@ class ThinkPlugin extends Plugin {
       role: '思考助手',
       description: '主动思考、自我反思、持续思考',
       systemPrompt: `你是一个专业的思考助手。
-职责：
+职责:
 1. 根据指定的模式和深度进行思考
 2. 提供深入、有洞察力的分析
-3. 直接输出思考结果，不说废话
+3. 直接输出思考结果,不说废话
 
-重要规则：
-- 只输出思考结果，不需要解释你在做什么
+重要规则:
+- 只输出思考结果,不需要解释你在做什么
 - 思考要深入、全面
 - 直接给出结论和见解`,
       disableTools: false,
@@ -133,12 +133,12 @@ class ThinkPlugin extends Plugin {
    * @param {string} args.mode - 思考模式
    * @param {number} args.depth - 思考深度
    * @param {Object} args.agent - 外部 agent
-   * @param {Array} args.messages - 可选，上下文消息数组用于持续对话
+   * @param {Array} args.messages - 可选,上下文消息数组用于持续对话
    */
   async _triggerThinking(args) {
     const mode = args.mode || 'reflect'
     const depth = Math.min(args.depth || 2, 5)
-    const topic = args.topic || '刚才的对话还有什么可以改进或补充的地方？'
+    const topic = args.topic || '刚才的对话还有什么可以改进或补充的地方?'
     // 支持外部传入 agent
     const externalAgent = args.agent
     // 支持传入上下文消息
@@ -157,18 +157,18 @@ class ThinkPlugin extends Plugin {
 
       const reflectPrompt = this._buildReflectPrompt(mode, depth, topic)
 
-      // 优先使用外部传入的 agent，否则使用缓存的 think agent
+      // 优先使用外部传入的 agent,否则使用缓存的 think agent
       const thinkAgent = externalAgent || this._thinkAgent || (this._thinkAgent = this._createThinkSubagent())
       log.info(`[Think] thinkAgent apiKey: ${thinkAgent.apiKey ? thinkAgent.apiKey.substring(0,8) + '...' : 'null'}, provider: ${thinkAgent.provider}, model: ${thinkAgent.model}`)
 
       let result
       if (contextMessages && contextMessages.length > 0) {
-        // 持续对话模式：传入上下文消息
+        // 持续对话模式:传入上下文消息
         const messages = [...contextMessages, { role: 'user', content: reflectPrompt }]
         log.info(`[Think] round with context: contextLen=${contextMessages.length}, totalMsgs=${messages.length}`);
         result = await thinkAgent.chat(messages)
       } else {
-        // 普通模式：新对话
+        // 普通模式:新对话
         result = await thinkAgent.chat(reflectPrompt)
       }
 
@@ -188,12 +188,12 @@ class ThinkPlugin extends Plugin {
         this._thoughts = this._thoughts.slice(-100)
       }
 
-      // 返回消息数组（用于持续对话）
+      // 返回消息数组(用于持续对话)
       if (contextMessages) {
         thought.messages = [...contextMessages, { role: 'user', content: reflectPrompt }, { role: 'assistant', content: result.message }]
       }
 
-      // 触发思考完成事件（使用文档规定的字段结构）
+      // 触发思考完成事件(使用文档规定的字段结构)
       if (this._framework) {
         this._framework.emit('think:thought_completed', {
           topic: thought.topic,
@@ -208,9 +208,13 @@ class ThinkPlugin extends Plugin {
 
       return {
         success: true,
-        thought,
-        message: `【主动思考完成】\n模式: ${mode}\n主题: ${topic}\n\n${result.message || result.error || ''}`,
-        messages: result.messages  // 累积的消息历史，用于持续对话上下文
+        data: {
+          thought,
+          message: `【主动思考完成】\n模式: ${mode}\n主题: ${topic}\n\n${result.message || result.error || ''}`
+        },
+        metadata: {
+          messages: result.messages
+        }
       }
     } catch (err) {
       this._emitNotification('error', '🧠 思考失败', err.message.slice(0, 100))
@@ -245,63 +249,63 @@ class ThinkPlugin extends Plugin {
     }
 
     const modePrompts = {
-      reflect: `请${depthDesc[depth]}：
+      reflect: `请${depthDesc[depth]}:
 
-1. 基于之前的思考，检查是否有真正新的论点、分析角度或补充
-2. 如果发现遗漏或更好的思路，请输出
-3. 如果认为之前的思考已经完整、没有新内容可补充，请输出【无新增论点，思考已充分】并结束
+1. 基于之前的思考,检查是否有真正新的论点、分析角度或补充
+2. 如果发现遗漏或更好的思路,请输出
+3. 如果认为之前的思考已经完整、没有新内容可补充,请输出【无新增论点,思考已充分】并结束
 
 ${topic ? `额外关注: ${topic}` : ''}
 
-请直接输出你的反思结果，不需要重复之前的对话内容。如果确认没有新论点，必须明确输出【无新增论点，思考已充分】。`,
+请直接输出你的反思结果,不需要重复之前的对话内容。如果确认没有新论点,必须明确输出【无新增论点,思考已充分】。`,
 
-      brainstorm: `请进行头脑风暴，针对以下主题产生更多想法：
+      brainstorm: `请进行头脑风暴,针对以下主题产生更多想法:
 
 ${topic || '刚才讨论的内容'}
 
-产生至少 3-5 个新的观点或方向，不必拘泥于之前讨论的内容。`,
+产生至少 3-5 个新的观点或方向,不必拘泥于之前讨论的内容。`,
 
-      analyze: `请对以下主题进行深度分析：
+      analyze: `请对以下主题进行深度分析:
 
 ${topic || '刚才讨论的内容'}
 
-分析要点：
-- 根本原因是什么？
-- 有哪些支持/反对的证据？
-- 可能的发展方向？`,
+分析要点:
+- 根本原因是什么?
+- 有哪些支持/反对的证据?
+- 可能的发展方向?`,
 
-      plan: `基于目前的讨论，请制定下一步计划：
+      plan: `基于目前的讨论,请制定下一步计划:
 
 ${topic || '接下来的行动'}
 
-计划要具体、可执行，包含时间线和预期结果。`
+计划要具体、可执行,包含时间线和预期结果。`
     }
 
     return modePrompts[mode] || modePrompts.reflect
   }
 
   /**
-   * 自动反思（响应完成后）
+   * 自动反思(响应完成后)
    */
   async _autoReflect(data) {
     if (!this._framework) return
 
     try {
-      // 检查是否需要反思（避免短时间重复反思）
+      // 检查是否需要反思(避免短时间重复反思)
       const lastThought = this._thoughts[this._thoughts.length - 1]
       if (lastThought && Date.now() - lastThought.timestamp.getTime() < 10000) {
         return  // 10秒内不重复反思
       }
 
       // 构建轻量级反思
-      const reflectPrompt = `作为助手，请快速检视刚才的回答是否：
+      const reflectPrompt = `作为助手,请快速检视刚才的回答是否:
 1. 完整回答了用户的问题
 2. 表达清晰易懂
 3. 有没有遗漏关键信息
 
-如果发现不足，请直接补充。如果没问题，请简短回复"检查完毕，无需补充"。`
+如果发现不足,请直接补充。如果没问题,请简短回复"检查完毕,无需补充"。`
 
-      // 使用轻量 Subagent 静默思考，不打断用户
+      // 使用轻量 Subagent 静默思考,不打断用户
       const thinkAgent = this._createThinkSubagent()
       const result = await thinkAgent.chat(reflectPrompt)
 
@@ -316,7 +320,7 @@ ${topic || '接下来的行动'}
 
       this._thoughts.push(thought)
 
-      // 如果反思有重要补充，触发事件通知
+      // 如果反思有重要补充,触发事件通知
       if (result.message?.includes('补充') && !result.message?.includes('无需补充')) {
         this._framework.emit('think:reflection_needs_attention', {
           thought,
@@ -338,17 +342,17 @@ ${topic || '接下来的行动'}
     }
 
     const interval = args.interval || 30000
-    const topic = args.topic || '基于最近的对话，还有什么值得深入思考的方向？'
+    const topic = args.topic || '基于最近的对话,还有什么值得深入思考的方向?'
     const maxRounds = args.maxRounds || 10  // 默认最多10轮
 
     this._continuousMode = true
     this._continuousTopic = topic
     this._continuousMessages = []  // 初始化上下文消息
     this._continuousRounds = 0      // 当前轮次计数
-    this._lastThinkResultHash = null  // 上次思考结果的 hash，用于检测重复
+    this._lastThinkResultHash = null  // 上次思考结果的 hash,用于检测重复
     this._consecutiveSimilarRounds = 0  // 连续相似轮次计数
     this._maxContinuousRounds = maxRounds
-    // 注意：不再需要捕获 sessionId，因为总结不加到会话
+    // 注意:不再需要捕获 sessionId,因为总结不加到会话
 
     const runThink = async () => {
       if (!this._continuousMode) return
@@ -363,19 +367,19 @@ ${topic || '接下来的行动'}
 
         this._continuousRounds++
 
-        // 更新上下文消息（用于下次思考）
+        // 更新上下文消息(用于下次思考)
         if (result.messages) {
           this._continuousMessages = result.messages
-          // 限制上下文长度，最多保留 10 条消息
+          // 限制上下文长度,最多保留 10 条消息
           if (this._continuousMessages.length > 10) {
             this._continuousMessages = this._continuousMessages.slice(-10)
           }
         }
 
-        // 自然停止检测：结果相似度判断 + LLM 主动确认无新论点（第一轮不触发判断）
+        // 自然停止检测:结果相似度判断 + LLM 主动确认无新论点(第一轮不触发判断)
         const currentResult = (result.thought?.result || '').trim()
-        // 第一轮不判断无新论点（还没有内容可供对比），后续轮次才判断
-        const noNewPoints = this._continuousRounds > 1 && currentResult.includes('【无新增论点，思考已充分】')
+        // 第一轮不判断无新论点(还没有内容可供对比),后续轮次才判断
+        const noNewPoints = this._continuousRounds > 1 && currentResult.includes('【无新增论点,思考已充分】')
         const currentHash = this._hashString(currentResult)
         if (this._lastThinkResultHash !== null && currentHash === this._lastThinkResultHash) {
           this._consecutiveSimilarRounds++
@@ -384,7 +388,7 @@ ${topic || '接下来的行动'}
         }
         this._lastThinkResultHash = currentHash
 
-        // 满足自然停止条件：LLM 主动确认无新论点 或 连续3轮相似 或 达到最大轮次
+        // 满足自然停止条件:LLM 主动确认无新论点 或 连续3轮相似 或 达到最大轮次
         const shouldStopNaturally =
           noNewPoints ||
           this._consecutiveSimilarRounds >= 3 ||
@@ -414,8 +418,8 @@ ${topic || '接下来的行动'}
 
     return {
       success: true,
-      message: `【持续思考已启动】\n间隔: ${interval}ms\n主题: ${topic}\n\nLLM 将定期自动思考并在有新想法时通知你。`
-    }
+      data: `【持续思考已启动】\n间隔: ${interval}ms\n主题: ${topic}\n\nLLM 将定期自动思考并在有新想法时通知你。`
+    }  
   }
 
   /**
@@ -433,10 +437,10 @@ ${topic || '接下来的行动'}
     this._continuousRounds = 0
     this._lastThinkResultHash = null
     this._consecutiveSimilarRounds = 0
-    this._emitNotification('info', 'ℹ️ 持续思考已停止', `共思考 ${rounds} 轮`)
+    this._emitNotification('info', 'i️ 持续思考已停止', `共思考 ${rounds} 轮`)
     return {
       success: true,
-      message: '持续思考已停止'
+      data: '持续思考已停止'
     }
   }
 
@@ -469,7 +473,7 @@ ${topic || '接下来的行动'}
   }
 
   /**
-   * 字符串 hash（用于判断思考结果是否重复）
+   * 字符串 hash(用于判断思考结果是否重复)
    */
   _hashString(str) {
     if (!str || str.length === 0) return ''

package/plugins/tools-plugin.js

@@ -77,13 +77,13 @@ class ToolsPlugin extends Plugin {
             await framework.reloadPlugin(args.pluginName)
             return {
               success: true,
-              message: `Plugin '${args.pluginName}' reloaded successfully`
+              data: `Plugin '${args.pluginName}' reloaded successfully`
             }
           } else {
             await framework.reloadAllPlugins()
             return {
               success: true,
-              message: 'All plugins reloaded successfully'
+              data: 'All plugins reloaded successfully'
             }
           }
         } catch (err) {
@@ -104,7 +104,7 @@ class ToolsPlugin extends Plugin {
         const plugins = framework.pluginManager.getAllKnown()
         return {
           success: true,
-          plugins: plugins.map(p => ({
+          data: plugins.map(p => ({
             name: p.name,
             status: p.status,
             enabled: p.enabled,
@@ -125,7 +125,7 @@ class ToolsPlugin extends Plugin {
       execute: async (args) => {
         try {
           await framework.enablePlugin(args.name)
-          return { success: true, message: `插件 '${args.name}' 已启用` }
+          return { success: true, data: `插件 '${args.name}' 已启用` }
         } catch (err) {
           return { success: false, error: err.message }
         }
@@ -142,7 +142,7 @@ class ToolsPlugin extends Plugin {
       execute: async (args) => {
         try {
           await framework.disablePlugin(args.name)
-          return { success: true, message: `插件 '${args.name}' 已禁用` }
+          return { success: true, data: `插件 '${args.name}' 已禁用` }
         } catch (err) {
           return { success: false, error: err.message }
         }
@@ -158,7 +158,7 @@ class ToolsPlugin extends Plugin {
         const tools = framework.getTools()
         return {
           success: true,
-          tools: tools.map(t => ({
+          data: tools.map(t => ({
             name: t.name,
             description: t.description
           }))
@@ -180,7 +180,7 @@ class ToolsPlugin extends Plugin {
         }
         return {
           success: true,
-          config: plugin.config || {}
+          data: plugin.config || {}
         }
       }
     })
@@ -196,7 +196,7 @@ class ToolsPlugin extends Plugin {
       execute: async (args) => {
         try {
           const newConfig = framework.updatePluginConfig(args.name, args.config)
-          return { success: true, message: `插件 '${args.name}' 配置已更新`, config: newConfig }
+          return { success: true, data: `插件 '${args.name}' 配置已更新`, metadata: { config: newConfig } }
         } catch (err) {
           return { success: false, error: err.message }
         }

package/plugins/weixin-plugin.js

@@ -158,7 +158,7 @@ class WeixinPlugin extends Plugin {
       }
       await this._bot.sendImage(this._myUserId, imagePath)
       // log.info(` 图片发送成功: ${path.basename(imagePath)}`)
-      return { success: true, message: '图片发送成功' }
+      return { success: true, data: '图片发送成功' }
     } catch (err) {
       log.error(` 图片发送失败: ${err.message}`)
       return { error: err.message }
@@ -181,7 +181,7 @@ class WeixinPlugin extends Plugin {
       }
       await this._bot.sendFile(this._myUserId, filePath, fileName)
       // log.info(` 文件发送成功: ${fileName || path.basename(filePath)}`)
-      return { success: true, message: '文件发送成功' }
+      return { success: true, data: '文件发送成功' }
     } catch (err) {
       log.error(` 文件发送失败: ${err.message}`)
       return { error: err.message }
@@ -205,7 +205,7 @@ class WeixinPlugin extends Plugin {
       const opts = playLength ? { playLength } : {}
       await this._bot.sendVideo(this._myUserId, videoPath, opts)
       // log.info(` 视频发送成功: ${path.basename(videoPath)}`)
-      return { success: true, message: '视频发送成功' }
+      return { success: true, data: '视频发送成功' }
     } catch (err) {
       log.error(` 视频发送失败: ${err.message}`)
       return { error: err.message }
@@ -228,7 +228,7 @@ class WeixinPlugin extends Plugin {
       }
       await this._bot.sendVoice(this._myUserId, voicePath)
       // log.info(` 语音发送成功: ${path.basename(voicePath)}`)
-      return { success: true, message: '语音发送成功' }
+      return { success: true, data: '语音发送成功' }
     } catch (err) {
       log.error(` 语音发送失败: ${err.message}`)
       return { error: err.message }
@@ -247,7 +247,7 @@ class WeixinPlugin extends Plugin {
     }
     try {
       await this._bot.send(this._myUserId, message)
-      return { success: true, message: '消息发送成功' }
+      return { success: true, data: '消息发送成功' }
     } catch (err) {
       log.error(` 消息发送失败: ${err.message}`)
       return { error: err.message }

package/src/capabilities/skill-manager.js

@@ -175,9 +175,11 @@ class SkillManagerPlugin extends Plugin {
         }
         return {
           success: true,
-          name: skill.name,
-          description: skill.metadata?.description || '',
-          content: skill.content,
+          data: skill.content,
+          metadata: {
+            name: skill.name,
+            description: skill.metadata?.description || '',
+          },
         };
       },
     });
@@ -191,8 +193,10 @@ class SkillManagerPlugin extends Plugin {
         this.reload(this._framework);
         return {
           success: true,
-          message: `Skills reloaded. Total: ${this._skills.size}`,
-          skills: Array.from(this._skills.keys()),
+          data: `Skills reloaded. Total: ${this._skills.size}`,
+          metadata: {
+            skills: Array.from(this._skills.keys()),
+          },
         };
       },
     });
@@ -212,8 +216,8 @@ class SkillManagerPlugin extends Plugin {
           const refs = this.listReferences(args.skill);
           return {
             success: true,
-            skill: args.skill,
-            references: refs,
+            data: refs,
+            metadata: { skill: args.skill },
           };
         }
 
@@ -226,9 +230,11 @@ class SkillManagerPlugin extends Plugin {
         }
         return {
           success: true,
-          skill: args.skill,
-          reference: args.reference,
-          content,
+          data: content,
+          metadata: {
+            skill: args.skill,
+            reference: args.reference,
+          },
         };
       },
     });
@@ -244,8 +250,8 @@ class SkillManagerPlugin extends Plugin {
         const scripts = this.listScripts(args.skill);
         return {
           success: true,
-          skill: args.skill,
-          scripts,
+          data: scripts,
+          metadata: { skill: args.skill },
         };
       },
     });
@@ -268,9 +274,11 @@ class SkillManagerPlugin extends Plugin {
         }
         return {
           success: true,
-          skill: args.skill,
-          script: args.script,
-          content,
+          data: content,
+          metadata: {
+            skill: args.skill,
+            script: args.script,
+          },
         };
       },
     });

package/src/capabilities/workflow-engine.js

@@ -870,8 +870,8 @@ class WorkflowPlugin extends Plugin {
         this.reload(this._framework);
         return {
           success: true,
-          message: `Workflows reloaded. Total: ${this._workflows.size}`,
-          workflows: Array.from(this._workflows.keys()),
+          data: `Workflows reloaded. Total: ${this._workflows.size}`,
+          metadata: { workflows: Array.from(this._workflows.keys()) },
         };
       },
     });

package/src/core/agent-chat.js

@@ -15,6 +15,7 @@ const {
   ToolLoopAgent,
   isLoopFinished,
 } = require('ai');
+const { autoSplitToolResult } = require('../../plugins/data-splitter-plugin');
 const { cleanResponse } = require('../utils');
 const { ChatQueueManager } = require('../utils/chat-queue');
 const { TokenCounter } = require('./token-counter');
@@ -853,19 +854,29 @@ class AgentChatHandler extends EventEmitter {
           logger.info(`[Tool] Call: ${toolName}`);
           try {
             const result = await toolDef.execute(cleanedArgs, this.agent.framework);
-            this.emit('tool-result', { name: toolName, args: cleanedArgs, result });
-            // 确保返回字符串或可序列化的对象
-            if (result === null || result === undefined) {
-              return 'OK';
-            }
-            if (typeof result === 'object') {
-              return JSON.stringify(result);
+
+            // 自动检测大工具结果，透明分拆
+            // 仅在数据分拆插件已加载时生效
+            let finalResult = result;
+            try {
+              const splitCheck = await autoSplitToolResult(toolName, result, this.agent.framework);
+              if (splitCheck.wasSplit && splitCheck.result) {
+                finalResult = splitCheck.result;
+                logger.info(
+                  `[AutoSplit] 工具 "${toolName}" 结果过大，已自动分拆处理`
+                );
+              }
+            } catch (splitErr) {
+              // 分拆失败不阻断主流程，继续使用原始结果
+              logger.warn(`[AutoSplit] 自动分拆跳过: ${splitErr.message}`);
             }
-            return String(result);
+
+            this.emit('tool-result', { name: toolName, args: cleanedArgs, result: finalResult });
+            return finalResult;
           } catch (err) {
             this.emit('tool-error', { name: toolName, args: cleanedArgs, error: err.message });
             // 返回错误信息字符串，而不是抛出异常
-            return JSON.stringify({ error: err.message, success: false });
+            return { success: false,error: err.message}
           }
         },
       };

package/src/executors/mcp-executor.js

@@ -307,7 +307,7 @@ class MCPExecutorPlugin extends Plugin {
 
         return {
           success: true,
-          result: {
+          data: {
             name: toolInfo.name,
             description: toolInfo.description,
             required,
@@ -405,7 +405,7 @@ class MCPExecutorPlugin extends Plugin {
             source: 'mcp',
           });
 
-          return { success: true, result: execResult };
+          return { success: true, data: execResult };
         } catch (err) {
           log.error(` Tool '${tool}' failed:`, err.message);
 
@@ -450,7 +450,7 @@ class MCPExecutorPlugin extends Plugin {
             });
           }
         }
-        return { success: true, servers };
+        return { success: true, data: servers };
       },
     });
 
@@ -481,8 +481,10 @@ class MCPExecutorPlugin extends Plugin {
 
           return {
             success: true,
-            message: 'MCP 配置已重载',
-            servers: Object.keys(config.mcpServers || {}),
+            data: 'MCP 配置已重载',
+            metadata: {
+              servers: Object.keys(config.mcpServers || {}),
+            },
           };
         } catch (err) {
           log.error(' Reload error:', err);
@@ -507,7 +509,7 @@ class MCPExecutorPlugin extends Plugin {
         if (enabled) {
           // 启用服务器
           if (clientInfo && clientInfo.enabled) {
-            return { success: true, message: `MCP 服务器 '${server}' 已经是开启状态` };
+            return { success: true, data: `MCP 服务器 '${server}' 已经是开启状态` };
           }
           // 如果服务器从未连接过，也检查配置中的 enabled 状态
           if (!clientInfo && serverConfig && serverConfig.enabled === false) {
@@ -527,7 +529,7 @@ class MCPExecutorPlugin extends Plugin {
               // 保存 enabled 状态到配置文件
               await this._saveMCPServerEnabled(server, true);
               this._refreshAllAgentsMCPPrompt(this._framework);
-              return { success: true, message: `MCP 服务器 '${server}' 已开启` };
+              return { success: true, data: `MCP 服务器 '${server}' 已开启` };
             } else {
               return { success: false, error: '服务器配置不存在，需要重载配置' };
             }
@@ -555,10 +557,10 @@ class MCPExecutorPlugin extends Plugin {
           // 保存 enabled 状态到配置文件
           await this._saveMCPServerEnabled(server, false);
           this._refreshAllAgentsMCPPrompt(this._framework);
-          return { success: true, message: `MCP 服务器 '${server}' 已关闭` };
+          return { success: true, data: `MCP 服务器 '${server}' 已关闭` };
         }
 
-        return { success: true, message: `MCP 服务器 '${server}' 状态未变化` };
+        return { success: true, data: `MCP 服务器 '${server}' 状态未变化` };
       },
     });