foliko 1.0.68 → 1.0.69

package/plugins/email.js

@@ -29,6 +29,9 @@ class EmailPlugin extends Plugin {
     this._lastSeenUid = null
     this._watchConfig = null
     this._watchEnabled = false
+    this._checkInProgress = false  // 防止并发检查
+    this._recentlyEmailed = new Set()  // 去重：最近已处理的 messageId（短TTL，用于快速去重）
+    this._processedEmails = new Set()  // 已处理（已回复）的邮件，不会重复处理（长TTL）
   }
 
   install(framework) {
@@ -64,12 +67,36 @@ class EmailPlugin extends Plugin {
    * 发送邮件事件
    */
   _emitEmailReceived(email) {
-    if (this._framework) {
-      this._framework.emit('email:received', {
-        email,
-        timestamp: new Date()
-      })
+    if (!this._framework) return
+    // 去重：如果最近已处理过这个 messageId，跳过
+    const msgId = email.messageId || email.uid
+    //console.log(`[Email] _emitEmailReceived: msgId=${msgId}, messageId=${email.messageId}, uid=${email.uid}`)
+
+    // 优先检查是否已处理过（长TTL，防止服务器标记失败导致重复处理）
+    if (msgId && this._processedEmails.has(msgId)) {
+      console.log(`[Email] 跳过已处理的邮件: ${email.subject} (${msgId})`)
+      return
+    }
+
+    // 快速去重（短TTL，防止同一批次重复触发）
+    if (msgId && this._recentlyEmailed.has(msgId)) {
+      //console.log(`[Email] 跳过重复邮件: ${email.subject} (${msgId})`)
+      return
     }
+
+    // 标记为已处理
+    if (msgId) {
+      this._recentlyEmailed.add(msgId)
+      // 5分钟后从 Set 中移除，允许重新处理（适用于邮件被删除后重新收到的极端情况）
+      setTimeout(() => {
+        this._recentlyEmailed.delete(msgId)
+      }, 5 * 60 * 1000)
+    }
+
+    this._framework.emit('email:received', {
+      email,
+      timestamp: new Date()
+    })
   }
 
   _registerTools() {
@@ -211,9 +238,12 @@ class EmailPlugin extends Plugin {
         subject: z.string().describe('原始邮件主题'),
         body: z.string().describe('原始邮件内容'),
         from: z.string().optional().describe('发件人邮箱地址（可选）'),
-        prompt: z.string().optional().describe('自定义提示词，用于指导AI生成回复内容')
+        prompt: z.string().optional().describe('自定义提示词，用于指导AI生成回复内容'),
+        timeout: z.number().optional().describe('AI生成回复超时时间（毫秒），默认60000'),
+        messageId: z.string().optional().describe('原始邮件的Message-ID，用于在邮件客户端中创建回复线程')
       }),
       execute: async (args) => {
+        console.log('[Email] Auto-reply tool invoked with args:', args)
         return this._handleAutoReply(args)
       }
     })
@@ -223,18 +253,25 @@ class EmailPlugin extends Plugin {
    * 处理自动回复
    */
   async _handleAutoReply(args) {
-    let { to, subject, body, from, _event, prompt } = args
+    let { to, subject, body, from, _event, prompt, messageId, inReplyTo } = args
 
     // 如果没有直接参数，尝试从 _event 提取
-    // _event 格式: { type: 'email:received', email: {...}, timestamp: ... }
+    // _event 格式: { event: 'email:received', data: { uid, messageId, from, to, subject, text, ... }, timestamp }
     if (!to && !subject && !body && _event) {
-      const email = _event.email || _event.data?.email || {}
+      const email = _event.data || _event.email || {}
       from = email.from?.text || email.from || ''
       to = email.to?.text || email.to || ''
       subject = email.subject || ''
       body = email.text || email.body || ''
+      // 从事件中提取 messageId 作为 inReplyTo
+      if (!messageId) {
+        messageId = email.messageId || email.uid
+      }
     }
 
+    // 优先使用传入的 inReplyTo，否则用 messageId
+    const replyTo = inReplyTo || messageId
+
     // 检查必要参数
     if (!from && !to) {
       return { success: false, error: '缺少收件人地址' }
@@ -244,11 +281,12 @@ class EmailPlugin extends Plugin {
     }
 
     try {
-      // 获取活跃的 Agent
-      const agent = this._getActiveAgent()
-      if (!agent) {
-        return { success: false, error: 'No active agent found' }
-      }
+      // 使用子Agent生成回复
+      const replyAgent = this._framework.createSubAgent({
+        name: 'email_replier',
+        role: '邮件自动回复助手，专注于生成专业、礼貌、简洁的邮件回复',
+        parentTools: []
+      })
 
       // 构建提示让 LLM 生成回复
       const finalPrompt = prompt || `你是一封邮件自动回复助手。请根据以下邮件内容，生成一封专业的回复邮件。
@@ -265,14 +303,14 @@ ${body}
 3. 只输出邮件正文内容，不要额外解释
 4. 回复语言应与原邮件一致（如果原邮件是中文，则用中文回复）`
 
-      // 等待 Agent 生成回复（带超时保护）
+      // 等待 Agent 生成回复（带超时保护，默认60秒）
+      const timeoutMs = args.timeout || 60000
       const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => reject(new Error('AI回复生成超时（30秒）')), 30000)
+        setTimeout(() => reject(new Error(`AI回复生成超时（${timeoutMs/1000}秒）`)), timeoutMs)
       })
 
-      const replyPromise = agent.pushMessage(finalPrompt, { maxSteps: 3 })
+      const replyPromise = replyAgent.chat(finalPrompt, { maxSteps: 3 })
       const replyResult = await Promise.race([replyPromise, timeoutPromise])
-
       // 提取回复内容
       let replyContent = ''
       if (typeof replyResult === 'string') {
@@ -296,10 +334,33 @@ ${body}
       const sendResult = await this._sendEmail({
         to: from || to,
         subject: `Re: ${subject}`,
-        body: replyContent
+        body: replyContent,
+        inReplyTo: replyTo,
+        references: replyTo ? [replyTo] : undefined
       })
 
       if (sendResult.success) {
+        // 发送成功后，标记为已处理（本地记录，防止服务器标记失败导致重复处理）
+        const msgId = messageId || _event?.data?.messageId || _event?.email?.messageId || uid
+        if (msgId) {
+          this._processedEmails.add(msgId)
+          console.log(`[Email] 邮件已处理: ${msgId}`)
+          // 24小时后从已处理列表中移除（防止永久记住）
+          setTimeout(() => {
+            this._processedEmails.delete(msgId)
+          }, 24 * 60 * 60 * 1000)
+        }
+
+        // 自动标记原邮件为已读（服务器端）
+        const uid = _event?.data?.uid || _event?.email?.uid
+        if (uid) {
+          try {
+            await this._markAsRead({ messageId: String(uid) })
+          } catch (err) {
+            console.warn(`[Email] 自动标记已读失败: ${err.message}`)
+          }
+        }
+
         return {
           success: true,
           message: `自动回复已发送至 ${from || to}`,
@@ -473,6 +534,17 @@ ${body}
   async _checkNewEmails() {
     if (!this._watchConfig) return
 
+    const callId = `${Date.now()}_${Math.random().toString(36).substr(2, 5)}`
+    console.log(`[Email] [${callId}] _checkNewEmails called, _checkInProgress=${this._checkInProgress}`)
+
+    // 防止并发检查
+    if (this._checkInProgress) {
+      console.log(`[Email] [${callId}] Skipping - already in progress`)
+      return
+    }
+    this._checkInProgress = true
+    console.log(`[Email] [${callId}] Started, _checkInProgress=${this._checkInProgress}`)
+
     const Imap = require('imap-mkl')
     const { simpleParser } = require('mailparser')
 
@@ -495,6 +567,8 @@ ${body}
 
       const cleanup = () => {
         try { imap.end() } catch (e) {}
+        this._checkInProgress = false
+        console.log(`[Email] ${Date.now()} cleanup called, _checkInProgress=false`)
       }
 
       imap.on('ready', () => {
@@ -525,6 +599,9 @@ ${body}
               const f = imap.fetch(latestUid, { bodies: '' })
 
               f.on('message', (msg) => {
+                let msgCount = 0
+                msgCount++
+                console.log(`[Email] f.on('message') called count=${msgCount}, uid=${latestUid}`)
                 let email = {}
                 let bodyParsed = false
 
@@ -532,6 +609,7 @@ ${body}
                   simpleParser(stream).then(mail => {
                     email = {
                       uid: mail.uid || latestUid,
+                      messageId: mail.messageId,
                       subject: mail.subject,
                       from: mail.from?.text || '',
                       to: mail.to?.text || '',
@@ -551,7 +629,13 @@ ${body}
                 })
 
                 msg.on('end', () => {
+                  console.log(`[Email] msg.on('end') called for uid=${latestUid}`)
+                  let checkCount = 0
                   const checkDone = () => {
+                    checkCount++
+                    if (checkCount > 1) {
+                      console.log(`[Email] checkDone called ${checkCount} times, bodyParsed=${bodyParsed}`)
+                    }
                     if (bodyParsed) {
                       // 更新最后看到的 UID
                       this._lastSeenUid = latestUid
@@ -620,7 +704,9 @@ ${body}
         text: args.isHtml ? undefined : args.body,
         html: args.isHtml ? args.body : undefined,
         cc: args.cc,
-        bcc: args.bcc
+        bcc: args.bcc,
+        inReplyTo: args.inReplyTo,
+        references: args.references
       }
 
       // 处理附件

package/plugins/file-system-plugin.js

@@ -221,56 +221,102 @@ class FileSystemPlugin extends Plugin {
     // 搜索文件
     framework.registerTool({
       name: 'search_file',
-      description: '在文件中搜索文本',
+      description: '在文件或目录中搜索文本',
       inputSchema: z.object({
         query: z.string().optional().describe('搜索关键词'),
-        pattern: z.string().optional().describe('搜索模式'),
+        pattern: z.string().optional().describe('搜索模式(支持正则)'),
         searchText: z.string().optional().describe('搜索文本'),
         path: z.string().optional().describe('搜索目录'),
         dirPath: z.string().optional().describe('搜索目录(同path)'),
+        file: z.string().optional().describe('搜索指定文件'),
         fileType: z.string().optional().describe('文件类型过滤'),
-        maxResults: z.number().optional().describe('最大结果数')
+        maxResults: z.number().optional().describe('最大结果数'),
+        contextLines: z.number().optional().describe('匹配行的上下文行数')
       }),
       execute: async (args, framework) => {
         const pattern = args.query || args.pattern || args.searchText || ''
         const dirPath = args.path || args.dirPath || '.'
+        const targetFile = args.file
         const fileType = args.fileType
         const maxResults = args.maxResults || 50
+        const contextLines = args.contextLines || 0
         try {
           const results = []
           const regex = new RegExp(pattern, 'gi')
-          const searchDir = (currentPath, depth = 0) => {
-            if (depth > 5 || results.length >= maxResults) return
-            const entries = fs.readdirSync(currentPath, { withFileTypes: true })
-            for (const entry of entries) {
-              if (results.length >= maxResults) break
-              const fullPath = path.join(currentPath, entry.name)
-              const relativePath = path.relative(process.cwd(), fullPath)
-              if (relativePath.includes('node_modules') || relativePath.includes('.git') ||
-                  relativePath.includes('dist') || relativePath.includes('build')) {
-                continue
+
+          // 搜索单个文件
+          if (targetFile) {
+            const fullPath = path.resolve(targetFile)
+            if (!fs.existsSync(fullPath)) {
+              return { success: false, error: `文件不存在: ${targetFile}` }
+            }
+            try {
+              const content = fs.readFileSync(fullPath, 'utf8')
+              const lines = content.split('\n')
+              for (let i = 0; i < lines.length; i++) {
+                if (regex.test(lines[i])) {
+                  let matchInfo = { file: targetFile, line: i + 1, content: lines[i].substring(0, 200) }
+                  // 添加上下文行
+                  if (contextLines > 0) {
+                    const start = Math.max(0, i - contextLines)
+                    const end = Math.min(lines.length, i + contextLines + 1)
+                    matchInfo.context = lines.slice(start, end).map((l, idx) => ({
+                      line: start + idx + 1,
+                      content: l
+                    }))
+                  }
+                  results.push(matchInfo)
+                  if (results.length >= maxResults) break
+                }
               }
-              if (entry.isDirectory()) {
-                searchDir(fullPath, depth + 1)
-              } else if (entry.isFile()) {
-                if (fileType && !entry.name.endsWith(fileType)) continue
-                const ext = path.extname(entry.name)
-                if (['.jpg', '.png', '.gif', '.exe', '.dll', '.zip'].includes(ext)) continue
-                try {
-                  const content = fs.readFileSync(fullPath, 'utf8')
-                  const lines = content.split('\n')
-                  for (let i = 0; i < lines.length; i++) {
-                    if (regex.test(lines[i])) {
-                      results.push({ file: relativePath, line: i + 1, content: lines[i].substring(0, 100) })
-                      if (results.length >= maxResults) break
+              regex.lastIndex = 0
+            } catch (e) {
+              return { success: false, error: `读取文件失败: ${e.message}` }
+            }
+          } else {
+            // 搜索目录
+            const searchDir = (currentPath, depth = 0) => {
+              if (depth > 5 || results.length >= maxResults) return
+              const entries = fs.readdirSync(currentPath, { withFileTypes: true })
+              for (const entry of entries) {
+                if (results.length >= maxResults) break
+                const fullPath = path.join(currentPath, entry.name)
+                const relativePath = path.relative(process.cwd(), fullPath)
+                if (relativePath.includes('node_modules') || relativePath.includes('.git') ||
+                    relativePath.includes('dist') || relativePath.includes('build')) {
+                  continue
+                }
+                if (entry.isDirectory()) {
+                  searchDir(fullPath, depth + 1)
+                } else if (entry.isFile()) {
+                  if (fileType && !entry.name.endsWith(fileType)) continue
+                  const ext = path.extname(entry.name)
+                  if (['.jpg', '.png', '.gif', '.exe', '.dll', '.zip'].includes(ext)) continue
+                  try {
+                    const content = fs.readFileSync(fullPath, 'utf8')
+                    const lines = content.split('\n')
+                    for (let i = 0; i < lines.length; i++) {
+                      if (regex.test(lines[i])) {
+                        let matchInfo = { file: relativePath, line: i + 1, content: lines[i].substring(0, 200) }
+                        if (contextLines > 0) {
+                          const start = Math.max(0, i - contextLines)
+                          const end = Math.min(lines.length, i + contextLines + 1)
+                          matchInfo.context = lines.slice(start, end).map((l, idx) => ({
+                            line: start + idx + 1,
+                            content: l
+                          }))
+                        }
+                        results.push(matchInfo)
+                        if (results.length >= maxResults) break
+                      }
                     }
-                  }
-                  regex.lastIndex = 0
-                } catch (e) { }
+                    regex.lastIndex = 0
+                  } catch (e) { }
+                }
               }
             }
+            searchDir(dirPath)
           }
-          searchDir(dirPath)
           return { success: true, pattern, results: results.slice(0, maxResults), total: results.length }
         } catch (error) {
           return { success: false, error: error.message }

package/plugins/python-executor-plugin.js

@@ -50,10 +50,11 @@ class PythonExecutorPlugin extends Plugin {
       description: '执行 Python 代码，禁止传入无用的emoji',
       inputSchema: z.object({
         code: z.string().describe('Python 代码'),
-        timeout: z.number().optional().describe('超时时间（毫秒），默认 120000')
+        timeout: z.number().optional().describe('超时时间（毫秒），默认 120000'),
+        input_data: z.record(z.any()).optional().describe('输入数据对象，可在代码中通过 input_data.get("key") 访问')
       }),
       execute: async (args) => {
-        return this._executePython(args.code, args.timeout || this.config.timeout)
+        return this._executePython(args.code, args.timeout || this.config.timeout, args.input_data)
       }
     })
 
@@ -92,7 +93,7 @@ class PythonExecutorPlugin extends Plugin {
    * 执行 Python 代码
    * @private
    */
-  _executePython(code, timeout) {
+  _executePython(code, timeout, inputData) {
     return new Promise((resolve) => {
       const startTime = Date.now()
       let output = ''
@@ -101,10 +102,20 @@ class PythonExecutorPlugin extends Plugin {
       // 创建临时脚本文件
       const tempFile = path.join(this._tempDir, `temp_${Date.now()}.py`)
 
+      // 注入 input_data 变量
+      let inputDataSetup = ''
+      if (inputData) {
+        const inputDataJson = JSON.stringify(inputData).replace(/'/g, "\\'")
+        inputDataSetup = `import json\ninput_data = json.loads('${inputDataJson}')\n`
+      } else {
+        inputDataSetup = `input_data = {}\n`
+      }
+
       // 包装代码，添加错误处理
       const wrappedCode = `
 import sys
 import traceback
+${inputDataSetup}
 try:
 ${code.split('\n').map(line => '    ' + line).join('\n')}
 except SystemExit:
@@ -136,13 +147,26 @@ except Exception:
         } catch (e) { }
 
         const elapsed = Date.now() - startTime
+
+        // 限制返回数据大小，避免上下文超限（限制为 5000 字符）
+        const MAX_OUTPUT_LENGTH = 5000
+        let truncatedOutput = output
+        let truncated = false
+        if (output.length > MAX_OUTPUT_LENGTH) {
+          truncatedOutput = output.substring(0, MAX_OUTPUT_LENGTH) + `\n... [输出已截断，总长度 ${output.length} 字符]`
+          truncated = true
+        }
+
         resolve({
           success: code === 0,
           exitCode: code,
-          stdout: output,
-          stderr: errorOutput,
+          stdout: truncatedOutput,
+          stderr: errorOutput.length > MAX_OUTPUT_LENGTH
+            ? errorOutput.substring(0, MAX_OUTPUT_LENGTH) + `\n... [错误输出已截断]`
+            : errorOutput,
           elapsed,
-          timedOut: code === null
+          timedOut: code === null,
+          truncated
         })
       })
 
@@ -164,11 +188,20 @@ except Exception:
           try {
             fs.unlinkSync(tempFile)
           } catch (e) { }
+
+          // 限制返回数据大小
+          const MAX_OUTPUT_LENGTH = 5000
+          const truncatedOutput = output.length > MAX_OUTPUT_LENGTH
+            ? output.substring(0, MAX_OUTPUT_LENGTH) + `\n... [输出已截断，总长度 ${output.length} 字符]`
+            : output
+
           resolve({
             success: false,
             error: `Python execution timed out after ${timeout}ms`,
-            stdout: output,
-            stderr: errorOutput,
+            stdout: truncatedOutput,
+            stderr: errorOutput.length > MAX_OUTPUT_LENGTH
+              ? errorOutput.substring(0, MAX_OUTPUT_LENGTH) + `\n... [错误输出已截断]`
+              : errorOutput,
             timedOut: true
           })
         }

package/plugins/scheduler-plugin.js

@@ -554,18 +554,14 @@ class SchedulerPlugin extends Plugin {
 
     try {
       if (task.llm) {
-        // LLM 模式：调用 Agent 处理
-        const agent = this._getAgent()
-        if (!agent) {
-          console.error('[Scheduler] Agent not available')
-          return
-        }
-
-        const result = await agent.pushMessage(task.message, {
-          isScheduledTask: true,
-          sessionId: task.sessionId
+        // LLM 模式：使用子Agent处理
+        const schedulerAgent = this._framework.createSubAgent({
+          name: 'scheduler_task',
+          role: '定时任务执行助手，专注于处理定时提醒和任务执行'
         })
 
+        const result = await schedulerAgent.chat(task.message)
+
         this._taskStats.completed++
 
         // 获取 LLM 返回的消息

package/plugins/web-plugin.js

@@ -312,11 +312,15 @@ class WebPlugin extends Plugin {
     // 触发 webhook 接收事件
     this._framework.emit('webhook:received', { webhook, data: webhookData, sessionId: finalSessionId })
 
+    // 使用子Agent处理 webhook
+    const webhookAgent = this._framework.createSubAgent({
+      name: 'webhook_handler',
+      role: 'Webhook处理助手，专注于处理webhook数据并生成适当响应'
+    })
+
     if (!webhook.awaitResponse) {
       // 不等待，立即返回
-      agent.pushMessage(`${prompt}\n\n数据:\n${JSON.stringify(webhookData, null, 2)}`, {
-        sessionId: finalSessionId
-      }).then(result => {
+      webhookAgent.chat(`${prompt}\n\n数据:\n${JSON.stringify(webhookData, null, 2)}`).then(result => {
         const responseText = result.message || result.text || ''
         console.log(`[Web] Webhook processed (${webhook.path}), LLM response (${responseText.length} chars)`)
 
@@ -340,9 +344,7 @@ class WebPlugin extends Plugin {
 
     // 等待 LLM 处理完成
     try {
-      const result = await agent.pushMessage(`${prompt}\n\n数据:\n${JSON.stringify(webhookData, null, 2)}`, {
-        sessionId: finalSessionId
-      })
+      const result = await webhookAgent.chat(`${prompt}\n\n数据:\n${JSON.stringify(webhookData, null, 2)}`)
       const responseText = result.message || result.text || ''
       console.log(`[Web] Webhook processed (${webhook.path}), LLM response (${responseText.length} chars)`)
 

package/skills/ambient-agent/SKILL.md

@@ -144,7 +144,7 @@ think     → think
 ```
 
 这意味着：
-- 变量引用语法一致：`{{variableName}}`
+- 变量引用语法一致：`${variableName}`（Ambient Agent 使用 `${}`)
 - sessionId 传递机制一致
 - 错误处理方式一致
 
@@ -162,6 +162,66 @@ context.variables.loopIndex   // 循环索引（如果被 loop 执行）
 context.input                 // 工作流/目标输入参数
 ```
 
+## 变量引用语法
+
+Ambient Agent 使用 `${}` 语法在 action 参数中引用变量：
+
+### 1. 事件数据引用 `${event.xxx}`
+
+当 goal 监听事件时，事件数据可通过 `${event.xxx}` 直接引用：
+
+```javascript
+{
+  id: 'auto-reply',
+  type: 'tool',
+  name: 'email_auto_reply',
+  args: {
+    to: '${event.from}',
+    subject: '${event.subject}',
+    body: '${event.text}',
+    from: ''
+  }
+}
+```
+
+**注意**：`email:received` 事件的数据结构：
+- `event.from` - 发件人地址
+- `event.subject` - 邮件主题
+- `event.text` - 邮件正文（纯文本）
+- `event.body` - 邮件正文（可能含 HTML）
+- `event.messageId` - 邮件消息 ID
+
+### 2. 多步骤引用 `${actionId.output.field}`
+
+当有多个顺序执行的 action 时，后续 action 可以引用前一个 action 的输出：
+
+```javascript
+actions: [
+  {
+    id: 'read-email',
+    type: 'tool',
+    name: 'email_read',
+    args: { limit: 1, unreadOnly: true }
+  },
+  {
+    id: 'process',
+    type: 'tool',
+    name: 'some_processor',
+    args: {
+      // 引用 read-email 输出的 emails 数组的第一个元素的 from 字段
+      sender: '${read-email.output.emails[0].from}'
+    }
+  }
+]
+```
+
+### 3. 变量解析规则
+
+`${}` 语法支持嵌套属性访问：
+- `${event.from}` - 直接字段
+- `${actionId.output.field}` - 嵌套字段
+- `${event.data.xxx}` - data 对象内的字段（兼容性别名）
+
 ## 创建目标的最佳实践
 
 1. **明确目标标题** - 让用户清楚知道目标意图
@@ -172,13 +232,13 @@ context.input                 // 工作流/目标输入参数
 
 ## 示例：创建邮件自动回复目标
 
-**重要**：`email:received` 事件的 `email` 对象包含：
-- `email.from` - 发件人地址
-- `email.to` - 收件人地址
-- `email.subject` - 邮件主题
-- `email.body` - 邮件正文
+**重要**：`email:received` 事件的数据结构：
+- `event.from` - 发件人地址
+- `event.subject` - 邮件主题
+- `event.text` - 邮件正文（纯文本）
+- `event.messageId` - 邮件消息 ID
 
-使用 `{{}}` 语法从事件中提取参数：
+使用 `${}` 语法从事件中提取参数：
 
 ```javascript
 await ambient_goals({
@@ -192,9 +252,18 @@ await ambient_goals({
       type: 'tool',
       name: 'email_auto_reply',
       args: {
-        to: '{{_event.email.from}}',
-        subject: '{{_event.email.subject}}',
-        body: '{{_event.email.body}}'
+        to: '${event.from}',
+        subject: '${event.subject}',
+        body: '${event.text}',
+        from: ''
+      }
+    },
+    {
+      id: 'mark-read',
+      type: 'tool',
+      name: 'email_mark_read',
+      args: {
+        messageId: '${event.messageId}'
       }
     }
   ],
@@ -211,14 +280,15 @@ await ambient_goals({
 
 // ✅ 正确 - 从事件中提取参数
 { type: 'tool', name: 'email_auto_reply', args: {
-    to: '{{_event.email.from}}',
-    subject: '{{_event.email.subject}}',
-    body: '{{_event.email.body}}'
+    to: '${event.from}',
+    subject: '${event.subject}',
+    body: '${event.text}',
+    from: ''
   }
 }
 ```
 
-**注意**：`email_auto_reply` 需要 `to`、`subject`、`body` 三个必需参数，必须从 `{{_event.email.xxx}}` 提取。
+**注意**：`email_auto_reply` 需要 `to`、`subject`、`body` 三个必需参数，必须从 `${event.xxx}` 提取。由于 `email:received` 事件已携带邮件数据，不需要额外的 `email_read` 步骤来读取邮件。
 
 ## 生命周期