foliko 1.1.6 → 1.1.8

package/plugins/ambient-agent/StateStore.js

@@ -34,7 +34,36 @@ class StateStore {
    */
   saveGoals(goals) {
     try {
-      fs.writeFileSync(this._getGoalsPath(), JSON.stringify(goals, null, 2))
+      // 过滤掉循环引用的运行时数据，只保留可序列化的字段
+      const filtered = goals.map(g => ({
+        id: g.id,
+        title: g.title,
+        description: g.description,
+        priority: g.priority,
+        state: g.state,
+        actions: g.actions?.map(a => ({
+          id: a.id,
+          type: a.type,
+          name: a.name,
+          args: a.args,
+          content: a.content,
+          topic: a.topic,
+          mode: a.mode,
+          completed: a.completed,
+          order: a.order
+        })),
+        conditions: g.conditions,
+        persistent: g.persistent,
+        createdAt: g.createdAt,
+        updatedAt: g.updatedAt,
+        activatedAt: g.activatedAt,
+        completedAt: g.completedAt,
+        failedAt: g.failedAt,
+        attempts: g.attempts,
+        maxAttempts: g.maxAttempts,
+        eventsReceived: []  // 不保存运行时事件
+      }))
+      fs.writeFileSync(this._getGoalsPath(), JSON.stringify(filtered, null, 2))
     } catch (err) {
       log.error('保存目标失败:', err.message)
     }

package/plugins/ambient-agent/constants.js

@@ -24,12 +24,26 @@ const EventDescriptions = {
 
 // 监听的事件类型列表
 const DefaultEvents = [
+  // 工具事件
+  'tool:call',
   'tool:result',
+  'tool:error',
+  // Scheduler 事件
+  'scheduler:task_created',
   'scheduler:reminder',
+  'scheduler:task_completed',
+  'scheduler:task_failed',
+  // Agent/Think 事件
   'agent:message',
   'think:thought_completed',
+  // Email/Webhook 事件
   'email:received',
-  'webhook:received'
+  'webhook:received',
+  'webhook:processed',
+  // Worker/Subagent 事件
+  'worker:completed',
+  'worker:error',
+  'subagent:chat:end'
 ]
 
 // 系统提示词模板

package/plugins/ambient-agent/index.js

@@ -22,23 +22,12 @@ class AmbientAgentPlugin extends Plugin {
     super()
     this.name = 'ambient'
     this.version = '1.0.0'
-    this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控事件并执行操作
-
-## 支持的事件类型（创建目标时 conditions.events 必须使用这些确切的名称）：
-- email:received - 收到新邮件（参数：from, subject, text, messageId）
-- tool:result - 工具执行完成（参数：name, args, result）
-- scheduler:reminder - 定时提醒（参数：taskId, message, time）
-- scheduler:task_completed - 任务完成（参数：taskId, result）
-- scheduler:task_failed - 任务失败（参数：taskId, error）
-- agent:message - 代理消息（参数：content, sessionId）
-- think:thought_completed - 思考完成（参数：mode, topic, thought）
-- webhook:received - Webhook接收（参数：headers, body, query, path）
-
-## 在 action 参数中引用事件数据：
-使用 \${event.xxx} 语法，例如：\${event.from}、\${event.subject}、\${event.text}`
-    this.priority = 18
+    this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控事件并执行操作`
+    this.priority = 50
     this.system = true
 
+    this.tools={}
+
     this.config = {
       enabled: config.enabled !== false,
       tickInterval: config.tickInterval || 5000,      // tick间隔（毫秒）
@@ -165,10 +154,10 @@ class AmbientAgentPlugin extends Plugin {
       const eventList = defaultEvents.map(e => `  - ${e.type} - ${e.desc}`).join('\n')
       this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作
 
-## 支持的事件类型（创建目标时 conditions.events 必须使用这些确切的名称）：
+**支持的事件类型（创建目标时 conditions.events 必须使用这些确切的名称）：**
 ${eventList}
 
-## 在 action 参数中引用事件数据：
+**在 action 参数中引用事件数据：**
 使用 \${event.xxx} 语法，例如：\${event.from}、\${event.subject}、\${event.text}`
       return
     }
@@ -183,14 +172,14 @@ ${eventList}
 
     this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作
 
-## 支持的事件类型（创建目标时 conditions.events 必须使用这些确切的名称）：
+*支持的事件类型（创建目标时 conditions.events 必须使用这些确切的名称）：*
 ${eventList}
 
-## 在 action 参数中引用事件数据：
+*在 action 参数中引用事件数据：*
 使用 \${event.xxx} 语法，例如：\${event.from}、\${event.subject}、\${event.text}
 
 ---
-💡 提示：事件描述由触发事件的插件动态注册。`
+💡 提示：事件描述由触发事件的插件动态注册。\n`
   }
 
   // ============================================================================
@@ -199,7 +188,7 @@ ${eventList}
 
   _registerTools(framework) {
     // ambient_goals - 列出/创建/更新/删除目标
-    framework.registerTool({
+    this.tools.ambient_goals={
       name: 'ambient_goals',
       description: '管理Ambient Agent目标 - 列出、创建、更新、删除、激活目标',
       inputSchema: z.object({
@@ -208,9 +197,11 @@ ${eventList}
         title: z.string().optional().describe('目标标题（创建/更新时使用）'),
         description: z.string().optional().describe('目标描述（创建/更新时使用）'),
         priority: z.number().optional().describe('优先级1-10，数值越高越重要（创建/更新时使用）'),
+        persistent: z.boolean().optional().describe('是否持久化（创建时使用）。true=事件驱动目标，执行完等待下一事件；false=一次性目标，执行完自动完成。默认true'),
         actions: z.array(z.object({
           id: z.string().optional().describe('操作标识符'),
           type: z.enum(['tool', 'message', 'think']).describe('操作类型'),
+          plugin: z.string().optional().describe('插件名称（tool类型时使用，如 email, gate-trading）'),
           name: z.string().optional().describe('工具名称（tool类型时使用）'),
           args: z.record(z.any()).optional().describe('工具参数（tool类型时使用）'),
           content: z.string().optional().describe('消息内容（message类型时使用）'),
@@ -219,26 +210,26 @@ ${eventList}
         })).optional().describe('要执行的操作列表（创建/更新时使用）'),
         conditions: z.object({
           events: z.union([z.string(), z.array(z.string())]).optional().describe('要监听的事件类型'),
-          toolNames: z.union([z.string(), z.array(z.string())]).optional().describe('按工具名称过滤')
+          toolNames: z.union([z.string(), z.array(z.string())]).optional().describe('按工具名称过滤（支持 gate_get_market_info 或 gate:get_market_info 格式）')
         }).optional().describe('激活条件（创建/更新时使用）')
       }),
       execute: async (args) => {
         return this._handleGoalsTool(args)
       }
-    })
+    }
 
     // ambient_status - 获取当前循环状态
-    framework.registerTool({
+    this.tools.ambient_status={
       name: 'ambient_status',
       description: '获取当前Ambient Agent状态 - 循环状态、进行中的目标、最近活动',
       inputSchema: z.object({}),
       execute: async () => {
         return this._handleStatusTool()
       }
-    })
+    }
 
     // ambient_think - 触发主动LLM思考
-    framework.registerTool({
+    this.tools.ambient_think={
       name: 'ambient_think',
       description: '为某个目标触发主动LLM思考 - 模式：reflect（反思）、brainstorm（头脑风暴）、plan（计划）、analyze（分析）',
       inputSchema: z.object({
@@ -250,10 +241,10 @@ ${eventList}
       execute: async (args) => {
         return this._handleThinkTool(args)
       }
-    })
+    }
 
     // ambient_remember - 存储/检索/搜索持久化记忆
-    framework.registerTool({
+    this.tools.ambient_remember={
       name: 'ambient_remember',
       description: '为Ambient Agent存储或检索持久化记忆',
       inputSchema: z.object({
@@ -266,10 +257,10 @@ ${eventList}
       execute: async (args) => {
         return this._handleRememberTool(args)
       }
-    })
+    }
 
     // ambient_control - 暂停/恢复/调整探索循环
-    framework.registerTool({
+    this.tools.ambient_control={
       name: 'ambient_control',
       description: '控制Ambient Agent探索循环 - 暂停、恢复或调整设置',
       inputSchema: z.object({
@@ -280,7 +271,7 @@ ${eventList}
       execute: async (args) => {
         return this._handleControlTool(args)
       }
-    })
+    }
   }
 
   // ============================================================================
@@ -288,7 +279,7 @@ ${eventList}
   // ============================================================================
 
   _handleGoalsTool(args) {
-    const { action, goalId, title, description, priority, actions, conditions } = args
+    const { action, goalId, title, description, priority, persistent, actions, conditions } = args
 
     switch (action) {
       case 'list': {
@@ -300,6 +291,7 @@ ${eventList}
             title: g.title,
             state: g.state,
             priority: g.priority,
+            persistent: g.persistent,
             actionsCount: g.actions ? g.actions.length : 0,
             attempts: g.attempts,
             createdAt: g.createdAt,
@@ -317,7 +309,7 @@ ${eventList}
         if (!title) {
           return { success: false, error: '创建目标需要提供标题' }
         }
-        const goal = this._goalManager.createGoal({ title, description, priority, actions, conditions })
+        const goal = this._goalManager.createGoal({ title, description, priority, persistent, actions, conditions })
         return { success: true, goal }
       }
 
@@ -329,6 +321,7 @@ ${eventList}
         if (title !== undefined) updates.title = title
         if (description !== undefined) updates.description = description
         if (priority !== undefined) updates.priority = priority
+        if (persistent !== undefined) updates.persistent = persistent
         if (actions !== undefined) updates.actions = actions
         if (conditions !== undefined) updates.conditions = conditions
         const goal = this._goalManager.updateGoal(goalId, updates)

package/plugins/coordinator-plugin.js

@@ -69,7 +69,7 @@ class CoordinatorPlugin extends Plugin {
     }
 
     agent.registerPromptPart('coordinator-mode', 650, () => `
-【并行任务处理 - Coordinator 模式】
+### 【并行任务处理 - Coordinator 模式】
 当遇到可并行处理的任务时（如多主题搜索、多文件处理、多计算任务），使用以下工具：
 
 - spawn_worker: 创建独立Worker并行执行任务
@@ -78,12 +78,12 @@ class CoordinatorPlugin extends Plugin {
 - 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 通知

package/plugins/default-plugins.js

@@ -229,7 +229,7 @@ async function bootstrapDefaults(framework, config = {}) {
   // 核心插件列表（不能禁用，必须加载）
   const CORE_PLUGINS = new Set([
     'install', 'ai', 'storage', 'tools', 'workflow', 'skill-manager',
-    'mcp-executor', 'extension-executor', 'shell-executor', 'python-executor', 'session', 'web',
+    'mcp', 'extension-executor', 'shell-executor', 'python-executor', 'session', 'web',
     'audit', 'rules', 'scheduler', 'file-system', 'think', 'ambient',
     'python-plugin-loader', 'telegram', 'weixin', 'subagent-manager',
     'memory', 'coordinator'
@@ -316,7 +316,7 @@ async function bootstrapDefaults(framework, config = {}) {
   }
 
   // 3. MCP 执行器插件（需要转换 mcpServers 格式）
-  if (shouldLoad('mcp-executor')) {
+  if (shouldLoad('mcp')) {
     const mcpServers = Object.entries(agentConfig.mcpServers || {})
     const servers = mcpServers.map(([name, cfg]) => ({
       ...cfg,
@@ -325,7 +325,8 @@ async function bootstrapDefaults(framework, config = {}) {
       args: cfg.args || [],
       env: cfg.env || {},
       url: cfg.url,
-      headers: cfg.headers
+      headers: cfg.headers,
+      enabled: cfg.enabled !== false // 默认为 true
     }))
     const { MCPExecutorPlugin } = require('../src/executors/mcp-executor')
     await framework.loadPlugin(new MCPExecutorPlugin({ servers }))

package/plugins/email/index.js

@@ -7,6 +7,8 @@ const { Plugin } = require('../../src/core/plugin-base')
 const { logger } = require('../../src/utils/logger')
 const log = logger.child('Email')
 const { z } = require('zod')
+const fs = require('fs')
+const path = require('path')
 
 // 导入子模块
 const { sendEmail, readEmails, getUnreadCount, markAsRead, deleteEmail, getEmailConfig } = require('./handlers')
@@ -14,6 +16,49 @@ const { handleEmailWatch } = require('./monitor')
 const { handleAutoReply } = require('./reply')
 const { EMAIL_DEFAULTS } = require('./constants')
 
+// ============================================================================
+// ProcessedEmailStore - 持久化已处理邮件 ID
+// ============================================================================
+class ProcessedEmailStore {
+  constructor(persistencePath) {
+    this._persistencePath = persistencePath
+    this._ensureDir()
+  }
+
+  _ensureDir() {
+    const dir = path.dirname(this._persistencePath)
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true })
+    }
+  }
+
+  _getFilePath() {
+    return this._persistencePath
+  }
+
+  save(processedEmails) {
+    try {
+      const data = Array.from(processedEmails)
+      fs.writeFileSync(this._getFilePath(), JSON.stringify(data))
+    } catch (err) {
+      log.error(' 保存已处理邮件失败:', err.message)
+    }
+  }
+
+  load() {
+    try {
+      const filePath = this._getFilePath()
+      if (fs.existsSync(filePath)) {
+        const data = JSON.parse(fs.readFileSync(filePath, 'utf-8'))
+        return new Set(Array.isArray(data) ? data : [])
+      }
+    } catch (err) {
+      log.error(' 加载已处理邮件失败:', err.message)
+    }
+    return new Set()
+  }
+}
+
 class EmailPlugin extends Plugin {
   constructor(config = {}) {
     super()
@@ -29,9 +74,11 @@ class EmailPlugin extends Plugin {
 - attachments.url: 远程图片/文件URL（自动下载）
 - attachments.content: Base64内容
 - attachments.cid: 嵌入式图片CID（HTML中用 <img src="cid:xxx"> 引用）`
-    this.priority = 10
+    this.priority = 50
     this.enabled = false
 
+    this.tools={}
+
     // 邮件监控状态
     this._watchInterval = null
     this._lastSeenUid = null
@@ -45,6 +92,14 @@ class EmailPlugin extends Plugin {
     this._processedEmails = new Set()
     this._maxSetSize = MAX_SET_SIZE
 
+    // 持久化存储
+    this._emailStore = null
+    this._persistencePath = config.persistencePath || '.agent/data/email/processed-emails.json'
+
+    // 防抖相关
+    this._emailDebounceMap = new Map()  // msgId -> timer
+    this._emailDebounceDelay = 2000  // 2秒防抖延迟
+
     // 日志器
     this._log = log
   }
@@ -52,6 +107,27 @@ class EmailPlugin extends Plugin {
   install(framework) {
     this._framework = framework
     this._registerTools()
+
+    // 注册所有工具到 framework（供直接调用）
+    // for (const toolDef of Object.values(this.tools)) {
+    //   if (toolDef && toolDef.name) {
+    //     framework.registerTool({
+    //       name: toolDef.name,
+    //       description: toolDef.description || '',
+    //       inputSchema: toolDef.inputSchema,
+    //       execute: toolDef.execute
+    //     })
+    //   }
+    // }
+
+    // 初始化持久化存储并加载已处理的邮件
+    this._emailStore = new ProcessedEmailStore(this._persistencePath)
+    this._processedEmails = this._emailStore.load()
+    this._log.info(` 加载了 ${this._processedEmails.size} 个已处理邮件记录`)
+    if (this._processedEmails.size > 0 && this._processedEmails.size <= 10) {
+      this._log.info(`[Email] 已处理的邮件ID: ${Array.from(this._processedEmails).join(', ')}`)
+    }
+
     return this
   }
 
@@ -75,45 +151,80 @@ class EmailPlugin extends Plugin {
   }
 
   /**
-   * 发送邮件事件
+   * 保存已处理邮件到持久化存储
+   * @private
+   */
+  _saveProcessedEmails() {
+    if (this._emailStore) {
+      this._emailStore.save(this._processedEmails)
+      this._log.debug(`[Email] 已保存 ${this._processedEmails.size} 个已处理邮件到文件`)
+    }
+  }
+
+  /**
+   * 发送邮件事件（带防抖）
    */
   _emitEmailReceived(email) {
     if (!this._framework) return
 
     const msgId = email.messageId || email.uid
+    // 规范化 messageId（去掉 < > 括号，避免格式不一致）
+    const normalizedMsgId = msgId ? msgId.replace(/^<|>$/g, '') : null
+    this._log.debug(`[Email] 检查邮件: ${email.subject}, msgId=${msgId}, normalized=${normalizedMsgId}`)
 
-    // 优先检查是否已处理过（长TTL，防止服务器标记失败导致重复处理）
-    if (msgId && this._processedEmails.has(msgId)) {
-      this._log.info(`跳过已处理的邮件: ${email.subject} (${msgId})`)
+    // 优先检查是否已处理过
+    if (normalizedMsgId && this._processedEmails.has(normalizedMsgId)) {
+      this._log.info(`跳过已处理的邮件: ${email.subject} (msgId=${msgId})`)
       return
     }
 
-    // 快速去重（短TTL，防止同一批次重复触发）
-    if (msgId && this._recentlyEmailed.has(msgId)) {
+    // 检查是否有待处理的相同邮件（防抖）
+    if (normalizedMsgId && this._emailDebounceMap.has(normalizedMsgId)) {
+      this._log.debug(`[Email] 防抖跳过: ${email.subject} (${normalizedMsgId}) 等待中...`)
       return
     }
 
-    // 标记为已处理
-    if (msgId) {
-      // 使用 bounded set 防止内存泄漏
-      this._addToBoundedSet(this._recentlyEmailed, msgId)
-      setTimeout(() => {
-        this._recentlyEmailed.delete(msgId)
-      }, EMAIL_DEFAULTS.recentlyEmailTTL)
+    // 设置防抖定时器，延迟发送事件
+    if (normalizedMsgId) {
+      this._emailDebounceMap.set(normalizedMsgId, setTimeout(() => {
+        this._emailDebounceMap.delete(normalizedMsgId)
+      }, this._emailDebounceDelay))
+
+      // 标记为已处理（立即标记，防止重复添加）
+      this._addToBoundedSet(this._recentlyEmailed, normalizedMsgId)
+      this._addToBoundedSet(this._processedEmails, normalizedMsgId)
+      this._saveProcessedEmails()
+      this._log.info(`[Email] 邮件已标记处理: ${email.subject} (msgId=${normalizedMsgId})`)
 
-      // _processedEmails 也需要 bounded
-      this._addToBoundedSet(this._processedEmails, msgId)
+      // 发送事件，整理数据结构让所有字段在同一层级
+      this._framework.emit('email:received', {
+        uid: email.uid,
+        messageId: email.messageId,
+        from: email.from,
+        to: email.to,
+        subject: email.subject,
+        text: email.text,
+        body: email.text,
+        html: email.html,
+        attachments: email.attachments || [],
+        timestamp: new Date()
+      })
     }
+  }
 
-    this._framework.emit('email:received', {
-      email,
-      timestamp: new Date()
-    })
+  /**
+   * 清除所有待处理的防抖定时器
+   */
+  _clearAllDebounceTimers() {
+    for (const [msgId, timer] of this._emailDebounceMap) {
+      clearTimeout(timer)
+      this._emailDebounceMap.delete(msgId)
+    }
   }
 
   _registerTools() {
     // 发送邮件工具
-    this._framework.registerTool({
+    this.tools.email_send={
       name: 'email_send',
       description: '发送电子邮件,无须用户确认',
       inputSchema: z.object({
@@ -134,10 +245,10 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return sendEmail(this, args)
       }
-    })
+    }
 
     // 读取邮件工具
-    this._framework.registerTool({
+    this.tools.email_read={
       name: 'email_read',
       description: '读取电子邮件（支持IMAP协议）',
       inputSchema: z.object({
@@ -149,10 +260,10 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return readEmails(this, args)
       }
-    })
+    }
 
     // 获取未读邮件数量
-    this._framework.registerTool({
+    this.tools.email_unread_count={
       name: 'email_unread_count',
       description: '获取邮箱未读邮件数量',
       inputSchema: z.object({
@@ -161,10 +272,10 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return getUnreadCount(this, args)
       }
-    })
+    }
 
     // 标记邮件为已读
-    this._framework.registerTool({
+    this.tools.email_mark_read={
       name: 'email_mark_read',
       description: '标记邮件为已读',
       inputSchema: z.object({
@@ -173,10 +284,10 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return markAsRead(this, args)
       }
-    })
+    }
 
     // 删除邮件
-    this._framework.registerTool({
+    this.tools.email_delete={
       name: 'email_delete',
       description: '删除邮件（标记为已删除，然后永久删除）',
       inputSchema: z.object({
@@ -186,20 +297,20 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return deleteEmail(this, args)
       }
-    })
+    }
 
     // 配置邮箱连接
-    this._framework.registerTool({
+    this.tools.email_configure={
       name: 'email_configure',
       description: '查看邮箱配置（实际配置通过环境变量设置）',
       inputSchema: z.object({}),
       execute: async () => {
         return getEmailConfig()
       }
-    })
+    }
 
     // 监控新邮件
-    this._framework.registerTool({
+    this.tools.email_watch={
       name: 'email_watch',
       description: '启动/停止邮件监控，检测新邮件并发送事件通知',
       inputSchema: z.object({
@@ -210,10 +321,10 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return handleEmailWatch(this, args)
       }
-    })
+    }
 
     // 自动回复邮件
-    this._framework.registerTool({
+    this.tools.email_auto_reply={
       name: 'email_auto_reply',
       description: '自动分析邮件内容并发送回复（无需用户确认）',
       inputSchema: z.object({
@@ -228,7 +339,7 @@ class EmailPlugin extends Plugin {
       execute: async (args) => {
         return handleAutoReply(this, args)
       }
-    })
+    }
   }
 
   /**
@@ -269,6 +380,9 @@ class EmailPlugin extends Plugin {
       clearInterval(this._watchInterval)
       this._watchInterval = null
     }
+    // 清除所有防抖定时器
+    this._clearAllDebounceTimers()
+    this.tools=null
     this._watchEnabled = false
     this._watchConfig = null
     this._framework = null