foliko 1.0.68 → 1.0.69

package/plugins/ambient-agent-plugin.js

@@ -115,13 +115,15 @@ class GoalManager {
   }
 
   createGoal(goalData) {
+    const actions = goalData.actions || []
     const goal = {
       id: generateId(),
       title: goalData.title || '未命名目标',
       description: goalData.description || '',
       priority: goalData.priority || 5,
       state: GoalState.PENDING,
-      actions: goalData.actions || [],
+      actions: actions,
+      _originalActions: actions.slice(),  // 保存原始 actions，用于事件驱动目标重置
       conditions: goalData.conditions || {},
       createdAt: new Date(),
       updatedAt: new Date(),
@@ -203,9 +205,22 @@ class GoalManager {
   addEventToGoal(goalId, event) {
     const goal = this._goals.get(goalId)
     if (!goal) return
+
+    // 通用去重：如果最近 2 秒内已有相同类型的事件，跳过
+    const now = Date.now()
+    const recentSameEvent = goal.eventsReceived.find(e =>
+      e.event === event.type && (now - new Date(e.timestamp).getTime()) < 2000
+    )
+    if (recentSameEvent) {
+      console.log(`[Ambient] 跳过重复事件: ${event.type} (2秒内不重复添加)`)
+      return
+    }
+
+    // event 格式: { type: 'email:received', email: {...}, timestamp: ... }
+    // 需要提取 type 和 data（email 对象）
     goal.eventsReceived.push({
       event: event.type,
-      data: event.data,
+      data: event.data || event.email || event,
       timestamp: new Date()
     })
     this._persist()
@@ -257,11 +272,27 @@ class EventWatcher {
 
   _handleEvent(type, data) {
     const activeGoals = this._goalManager.getActiveGoals()
+    console.log(`[Ambient] _handleEvent: type=${type}, activeGoals=${activeGoals.length}`)
     for (const goal of activeGoals) {
       // 检查目标条件是否匹配此事件
-      if (this._isRelevantToGoal(goal, type, data)) {
+      const isRelevant = this._isRelevantToGoal(goal, type, data)
+      console.log(`[Ambient] goal=${goal.id}, isRelevant=${isRelevant}, conditions=${JSON.stringify(goal.conditions)}`)
+      if (isRelevant) {
         // 将 data 展平到事件对象中，方便通过 {{_event.xxx}} 访问
         this._goalManager.addEventToGoal(goal.id, { type, ...data })
+        console.log(`[Ambient] Event added to goal ${goal.id}`)
+      }
+    }
+
+    // 检查是否有 pending 目标需要激活
+    const pendingGoals = this._goalManager.getPendingGoals()
+    for (const goal of pendingGoals) {
+      if (this._isRelevantToGoal(goal, type, data)) {
+        // 激活目标
+        this._goalManager.activateGoal(goal.id)
+        // 添加事件
+        this._goalManager.addEventToGoal(goal.id, { type, ...data })
+        console.log(`[Ambient] 事件触发激活目标: ${goal.id} (事件: ${type})`)
       }
     }
   }
@@ -300,10 +331,17 @@ class Reflector {
   evaluateOutcome(goal, actionResult) {
     if (!goal) return null
 
+    // 检查是否是事件驱动目标
+    const isEventDriven = goal.conditions?.events && goal.conditions.events.length > 0
+
     // 检查错误
     if (actionResult && actionResult.error) {
       // 增加尝试次数但不立即失败
       goal.attempts++
+      // 事件驱动目标：错误不导致失败或完成
+      if (isEventDriven) {
+        return { shouldContinue: true, goalComplete: false }
+      }
       return {
         shouldContinue: goal.attempts < goal.maxAttempts,
         actionTaken: false
@@ -314,6 +352,11 @@ class Reflector {
     if (actionResult && actionResult.success === true) {
       goal.attempts++
 
+      // 事件驱动目标：永远不会完成，持续等待下一事件
+      if (isEventDriven) {
+        return { shouldContinue: true, goalComplete: false }
+      }
+
       // 检查目标是否完成
       if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
         return { shouldContinue: false, goalComplete: true }
@@ -325,6 +368,11 @@ class Reflector {
     // 工具执行无错误 - 视为成功
     goal.attempts++
 
+    // 事件驱动目标：永远不会完成
+    if (isEventDriven) {
+      return { shouldContinue: true, goalComplete: false }
+    }
+
     // 检查目标是否完成（没有更多操作）
     if (goal.actions.length === 0 || goal.attempts >= goal.maxAttempts) {
       return { shouldContinue: false, goalComplete: true }
@@ -510,9 +558,59 @@ class ExplorerLoop {
       // 检查目标是否有未处理的事件
       const hasNewEvents = goal.eventsReceived && goal.eventsReceived.length > 0
 
+      // 检查是否是事件驱动目标
+      const isEventDriven = goal.conditions?.events && goal.conditions.events.length > 0
+
+      // 事件驱动目标：只有在新事件时才执行 actions
+      if (isEventDriven && !hasNewEvents) {
+        continue
+      }
+
       // 获取下一个操作
       if (goal.actions && goal.actions.length > 0) {
-        const action = goal.actions[0] // 简单策略：取第一个操作
+        // 如果有多个 action，按顺序执行所有 action
+        if (goal.actions.length > 1) {
+          const eventData = hasNewEvents ? goal.eventsReceived[0] : null
+          const results = await this._executeAllActions(goal.actions, eventData)
+
+          // 最后一个结果用于评估
+          const lastResult = results.length > 0 ? results[results.length - 1].result : null
+
+          // 评估结果
+          const outcome = this._reflector.evaluateOutcome(goal, lastResult)
+
+          // 检查是否是事件驱动目标
+          const isEventDriven = goal.conditions?.events && goal.conditions.events.length > 0
+
+          if (outcome.goalComplete && !isEventDriven) {
+            // 非事件驱动目标可以完成
+            this._goalManager.completeGoal(goal.id)
+            this._addActivity('goal_completed', { goalId: goal.id, attempts: goal.attempts })
+            this._notifyUser('目标完成', `目标 "${goal.title}" 已完成（尝试次数：${goal.attempts}）`, 'success')
+          } else if (!outcome.shouldContinue && !isEventDriven) {
+            // 非事件驱动目标可以失败
+            this._goalManager.failGoal(goal.id, '达到最大尝试次数')
+            this._addActivity('goal_failed', { goalId: goal.id, reason: '达到最大尝试次数' })
+            this._notifyUser('目标失败', `目标 "${goal.title}" 失败：达到最大尝试次数`, 'error')
+          } else {
+            // 事件驱动目标：不论结果如何，都重置并继续等待下一事件
+            this._addActivity('actions_completed', { goalId: goal.id, actionCount: results.length })
+          }
+
+          // 执行操作后清除已处理的事件，并重置 actions 以处理下一事件
+          if (hasNewEvents) {
+            goal.eventsReceived = []
+            // 重置 actions 为原始 actions，以便处理下一事件
+            if (goal._originalActions) {
+              goal.actions = goal._originalActions.slice()
+            }
+            this._goalManager.updateGoal(goal.id, { eventsReceived: [], actions: goal.actions })
+          }
+          continue
+        }
+
+        // 单个 action，使用原有逻辑
+        const action = goal.actions[0]
 
         // 循环检测（仅用于非事件驱动的操作）
         if (!hasNewEvents && this._reflector.checkLoopDetection(goal, action.id)) {
@@ -540,14 +638,21 @@ class ExplorerLoop {
           this._notifyUser('目标失败', `目标 "${goal.title}" 失败：达到最大尝试次数`, 'error')
         } else if (outcome.actionTaken) {
           // 从队列中移除已完成的操作
-          goal.actions.shift()
+          // 注意：对于事件驱动目标，如果 hasNewEvents 为 true，不移除 action 而是在下面重置
+          if (!hasNewEvents) {
+            goal.actions.shift()
+          }
           this._addActivity('action_executed', { goalId: goal.id, action: action.id, hasEvents: hasNewEvents })
         }
 
-        // 执行操作后清除已处理的事件
-        if (hasNewEvents && outcome.actionTaken) {
+        // 执行操作后清除已处理的事件，并重置 actions 以处理下一事件
+        if (hasNewEvents) {
           goal.eventsReceived = []
-          this._goalManager.updateGoal(goal.id, { eventsReceived: [] })
+          // 重置 actions 为原始 actions，以便处理下一事件
+          if (goal._originalActions) {
+            goal.actions = goal._originalActions.slice()
+          }
+          this._goalManager.updateGoal(goal.id, { eventsReceived: [], actions: goal.actions })
         }
       }
     }
@@ -555,33 +660,59 @@ class ExplorerLoop {
     // 激活满足条件的待处理目标
     const pendingGoals = this._goalManager.getPendingGoals()
     for (const goal of pendingGoals) {
-      // 自动激活没有条件或条件已满足的目标
+      // 自动激活没有条件的目标
+      // 有条件的目标会在事件触发时被 EventWatcher 自动激活
       if (!goal.conditions || Object.keys(goal.conditions).length === 0) {
         this._goalManager.activateGoal(goal.id)
         this._addActivity('goal_activated', { goalId: goal.id })
+      } else {
+        // 有条件的目标，立即激活以便开始监听事件
+        this._goalManager.activateGoal(goal.id)
+        this._addActivity('goal_activated', { goalId: goal.id, reason: '事件监听目标已激活' })
       }
     }
   }
 
-  async _executeAction(action, eventData = null) {
+  /**
+   * 执行单个 action
+   * @param {Object} action - action 配置
+   * @param {Object} eventData - 事件数据
+   * @param {Object} context - 执行上下文（包含 stepOutputs 等）
+   * @returns {Promise<Object>} 执行结果
+   */
+  async _executeAction(action, eventData = null, context = null) {
     if (!this._framework) {
       return { success: false, error: '框架不可用' }
     }
 
     try {
-      // 创建执行上下文
-      const context = {
-        input: {},
-        variables: {
-          _event: eventData,
-          _action: action
-        },
-        lastResult: null
+      // 如果没有提供 context，创建一个新的
+      if (!context) {
+        context = {
+          input: {},
+          variables: {
+            _event: eventData?.data || eventData || null,
+            _eventRaw: eventData || null,
+            _action: action
+          },
+          lastResult: null
+        }
+      } else {
+        // 更新 context 中的 _action
+        context.variables._action = action
       }
 
       // 将 action 转换为 step 配置
       const step = this._actionToStep(action)
 
+      // 解析 step.args 中的变量引用（支持 ${actionId.output} 格式）
+      if (step.args) {
+        step.args = this._resolveActionArgs(step.args, context)
+      }
+      if (step.input) {
+        step.input = this._resolveActionArgs(step.input, context)
+      }
+
       // message 和 think 类型使用专用子 agent 执行
       if (step.type === 'message' || step.type === 'think') {
         return await this._executeWithAmbientAgent(step, context)
@@ -595,6 +726,154 @@ class ExplorerLoop {
     }
   }
 
+  /**
+   * 解析 action 参数中的变量引用
+   * 支持 ${actionId.output}、${actionId.output.field} 和 ${event.xxx} 格式
+   * @param {Object} args - 参数对象
+   * @param {Object} context - 执行上下文
+   * @returns {Object} 解析后的参数
+   */
+  _resolveActionArgs(args, context) {
+    if (!args || typeof args !== 'object') return args
+
+    const stepOutputs = context.variables._stepOutputs || {}
+    const eventData = context.variables._event || {}
+
+    const resolved = {}
+    for (const [key, value] of Object.entries(args)) {
+      resolved[key] = this._resolveActionValue(value, stepOutputs, eventData)
+    }
+    return resolved
+  }
+
+  /**
+   * 解析单个值中的 ${actionId.output} 引用和 ${event.xxx} 引用
+   */
+  _resolveActionValue(value, stepOutputs, eventData) {
+    if (typeof value === 'string') {
+      // 处理 ${actionId.output} 和 ${actionId.output.field} 格式
+      const result = value.replace(/\$\{([^}]+)\}/g, (match, path) => {
+        if (path === 'output' || path === 'result') {
+          // {{result}} 引用上一步结果
+          return stepOutputs._lastResult ?? match
+        }
+        if (path.startsWith('event.')) {
+          // ${event.xxx} 引用事件数据
+          let eventPath = path.replace(/^event\./, '')
+          // 优先在 eventData.data 中查找（因为事件数据通常存储在 data 字段）
+          if (eventData?.data) {
+            let val = this._getNestedValue(eventData.data, eventPath)
+            if (val !== undefined) return val
+          }
+          // 再尝试直接在 eventData 中查找
+          let val = this._getNestedValue(eventData, eventPath)
+          if (val !== undefined) return val
+          // 兼容：如果 path 是 event.data.xxx 但 eventData 没有 data，尝试跳过一层
+          if (eventPath.startsWith('data.')) {
+            eventPath = eventPath.replace(/^data\./, '')
+            val = this._getNestedValue(eventData, eventPath)
+            if (val !== undefined) return val
+          }
+          // 特殊回退：如果查找 body 但找不到，尝试 text（邮件数据中用 text）
+          if (eventPath === 'body' || eventPath === 'text') {
+            const textVal = this._getNestedValue(eventData?.data, 'text')
+            if (textVal !== undefined) return textVal
+          }
+          return match
+        }
+        if (path === 'event') {
+          // ${event} 引用整个事件数据对象
+          return eventData ?? match
+        }
+        if (path.includes('.')) {
+          // ${actionId.output.field} 格式
+          const [actionId, ...fieldParts] = path.split('.')
+          if (actionId === 'result' || actionId === 'output') {
+            // {{result.field}} 格式
+            const val = this._getNestedValue(stepOutputs._lastResult, fieldParts.join('.'))
+            return val !== undefined ? val : match
+          }
+          const actionOutput = stepOutputs[actionId]
+          if (actionOutput !== undefined) {
+            const val = this._getNestedValue(actionOutput, fieldParts.join('.'))
+            return val !== undefined ? val : match
+          }
+        } else {
+          // ${actionId.output} 格式
+          const actionOutput = stepOutputs[path]
+          if (actionOutput !== undefined) return actionOutput
+        }
+        return match
+      })
+      return result
+    } else if (Array.isArray(value)) {
+      return value.map(v => this._resolveActionValue(v, stepOutputs, eventData))
+    } else if (typeof value === 'object' && value !== null) {
+      const resolved = {}
+      for (const [k, v] of Object.entries(value)) {
+        resolved[k] = this._resolveActionValue(v, stepOutputs, eventData)
+      }
+      return resolved
+    }
+    return value
+  }
+
+  _getNestedValue(obj, path) {
+    if (!obj) return undefined
+    const parts = path.split('.')
+    let current = obj
+    for (const part of parts) {
+      if (current === null || current === undefined) return undefined
+      current = current[part]
+    }
+    return current
+  }
+
+  /**
+   * 按顺序执行所有 actions
+   * @param {Array} actions - action 数组
+   * @param {Object} eventData - 事件数据
+   * @returns {Promise<Array>} 所有执行结果
+   */
+  async _executeAllActions(actions, eventData = null) {
+    const results = []
+    const stepOutputs = {}
+
+    const context = {
+      input: {},
+      variables: {
+        _event: eventData?.data || eventData || null,
+        _eventRaw: eventData || null,
+        _stepOutputs: stepOutputs
+      },
+      lastResult: null
+    }
+
+    for (const action of actions) {
+      // 执行前更新 stepOutputs
+      context.variables._stepOutputs = stepOutputs
+
+      const result = await this._executeAction(action, eventData, context)
+
+      // 保存结果：使用 action id 作为键
+      if (action.id) {
+        stepOutputs[action.id] = result
+      }
+      // 同时保存为 _lastResult 供 {{result}} 引用
+      stepOutputs._lastResult = result
+      context.lastResult = result
+
+      results.push({ actionId: action.id, result })
+
+      // 如果执行失败，停止执行
+      if (result && result.success === false) {
+        break
+      }
+    }
+
+    return results
+  }
+
   /**
    * 使用 ambient 子 agent 执行 AI 相关操作
    */
@@ -735,7 +1014,20 @@ class AmbientAgentPlugin extends Plugin {
     super()
     this.name = 'ambient'
     this.version = '1.0.0'
-    this.description = 'Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作'
+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.system = true
 
@@ -785,10 +1077,29 @@ class AmbientAgentPlugin extends Plugin {
     this._eventWatcher = new EventWatcher(this._goalManager, this._framework)
     this._eventWatcher.start()
 
-    // 动态更新description显示支持的事件
-    const events = Array.from(this._eventWatcher._relevantEvents).join(', ')
+    // 动态更新description显示支持的事件及参数
+    const eventDescriptions = {
+      'tool:result': '工具执行结果事件 - 参数: name(工具名), args(执行参数), result(执行结果), error(错误信息)',
+      'scheduler:reminder': '定时提醒事件 - 参数: taskId(任务ID), message(提醒消息), time(触发时间)',
+      'scheduler:task_completed': '任务完成事件 - 参数: taskId(任务ID), result(任务结果)',
+      'scheduler:task_failed': '任务失败事件 - 参数: taskId(任务ID), error(错误信息)',
+      'agent:message': '代理消息事件 - 参数: content(消息内容), sessionId(会话ID), agentId(代理ID)',
+      'think:thought_completed': '思考完成事件 - 参数: mode(思考模式), topic(思考主题), thought(思考内容), depth(思考深度)',
+      'email:received': '收到邮件事件 - 参数: from(发件人), to(收件人), subject(主题), text(正文), body(HTML正文), messageId(消息ID), timestamp(时间戳)',
+      'webhook:received': 'Webhook接收事件 - 参数: headers(HTTP头), body(请求体), query(查询参数), path(请求路径)'
+    }
+
+    const events = Array.from(this._eventWatcher._relevantEvents)
+    const eventList = events.map(e => {
+      const desc = eventDescriptions[e] || e
+      return `  - ${desc}`
+    }).join('\n')
+
     this.description = `Ambient Agent - 持续后台运行的智能代理，用于主动监控和执行操作
-支持的事件：${events}`
+支持的事件及参数：
+${eventList}
+
+使用 \${event.xxx} 在 action 参数中引用事件数据`
 
     // 启动探索循环
     this._explorerLoop = new ExplorerLoop(this._goalManager, this._reflector, this._framework, {