foliko 1.0.67 → 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/feishu-plugin.js

@@ -288,8 +288,18 @@ class FeishuPlugin extends Plugin {
 
     // 确定 openId
     let openId = null
-    if (sessionId && sessionId.startsWith('feishu_')) {
-      openId = sessionId.replace('feishu_', '')
+    let effectiveSessionId = sessionId
+
+    // 如果没有 sessionId，尝试从执行上下文获取
+    if (!effectiveSessionId) {
+      const ctx = this._framework.getExecutionContext()
+      if (ctx?.sessionId) {
+        effectiveSessionId = ctx.sessionId
+      }
+    }
+
+    if (effectiveSessionId && effectiveSessionId.startsWith('feishu_')) {
+      openId = effectiveSessionId.replace('feishu_', '')
     } else if (this._sessionPlugin) {
       // 获取最近的 feishu 会话
       const sessions = this._sessionPlugin.listSessions()

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

@@ -188,8 +188,15 @@ class SchedulerPlugin extends Plugin {
             return { success: false, error: 'Agent not available' }
           }
 
-          // 如果没有指定 sessionId，自动获取当前活跃会话
+          // 如果没有指定 sessionId，优先从执行上下文获取（来自 WeChat 等消息源）
           let targetSessionId = sessionId
+          if (!targetSessionId) {
+            const ctx = this._framework.getExecutionContext()
+            if (ctx?.sessionId) {
+              targetSessionId = ctx.sessionId
+            }
+          }
+          // 如果执行上下文也没有，从 sessionPlugin 获取最近活跃会话
           if (!targetSessionId) {
             const sessionPlugin = this._framework.pluginManager.get('session')
             if (sessionPlugin) {
@@ -547,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/telegram-plugin.js

@@ -99,8 +99,10 @@ class TelegramPlugin extends Plugin {
         this._framework.on('agent:created', (agent) => {
           console.log('[Telegram] New agent created:', agent.name)
         })
-        this._framework.on('scheduler:reminder', async (data) => {
-          await this._handleScheduledReminder(data)
+
+        // 监听统一通知事件
+        this._framework.on('notification', async (data) => {
+          await this._handleNotification(data)
         })
 
         // 监听 webhook 事件
@@ -113,36 +115,62 @@ class TelegramPlugin extends Plugin {
     }
   }
 
-  async _handleScheduledReminder(data) {
-    const { taskName, message, sessionId } = data
-    const reminderText = `🔔 [${taskName}]\n\n${message}`
-
-    if (sessionId && sessionId.startsWith('telegram_')) {
-      const chatId = sessionId.replace('telegram_', '')
-      try {
-        await this._bot.sendMessage(chatId, reminderText)
-        console.log(`[Telegram] Reminder sent to chat ${chatId}`)
-      } catch (err) {
-        console.error(`[Telegram] Failed to send reminder:`, err.message)
-      }
+  /**
+   * 处理统一通知
+   */
+  async _handleNotification(data) {
+    const { title, message, source, level } = data
+
+    if (!this._bot) {
+      console.warn('[Telegram] Bot not ready, cannot send notification')
       return
     }
 
-    if (this._sessionPlugin) {
+    // 确定 chatId
+    let chatId = null
+    let effectiveSessionId = data.sessionId
+
+    // 如果没有 sessionId，尝试从执行上下文获取
+    if (!effectiveSessionId) {
+      const ctx = this._framework.getExecutionContext()
+      if (ctx?.sessionId) {
+        effectiveSessionId = ctx.sessionId
+      }
+    }
+
+    if (effectiveSessionId && effectiveSessionId.startsWith('telegram_')) {
+      chatId = effectiveSessionId.replace('telegram_', '')
+    } else if (this._sessionPlugin) {
+      // 获取最近的 telegram 会话
       const sessions = this._sessionPlugin.listSessions()
         .filter(s => s.id.startsWith('telegram_'))
         .sort((a, b) => new Date(b.lastActive).getTime() - new Date(a.lastActive).getTime())
-
       if (sessions.length > 0) {
-        const chatId = sessions[0].id.replace('telegram_', '')
-        try {
-          await this._bot.sendMessage(chatId, reminderText)
-          console.log(`[Telegram] Reminder sent to recent chat ${chatId}`)
-        } catch (err) {
-          console.error(`[Telegram] Failed to send reminder:`, err.message)
-        }
+        chatId = sessions[0].id.replace('telegram_', '')
       }
     }
+
+    if (!chatId) {
+      console.warn('[Telegram] No telegram session found for notification')
+      return
+    }
+
+    // 格式化通知消息
+    const levelEmoji = {
+      info: 'ℹ️',
+      warning: '⚠️',
+      success: '✅',
+      error: '❌'
+    }
+    const emoji = levelEmoji[level] || 'ℹ️'
+    const notificationText = `${emoji} [${source}] ${title}\n\n${message}`
+
+    try {
+      await this._bot.sendMessage(chatId, notificationText)
+      console.log(`[Telegram] Notification sent to chat ${chatId}`)
+    } catch (err) {
+      console.error(`[Telegram] Failed to send notification:`, err.message)
+    }
   }
 
   /**

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)`)