foliko 1.0.65 → 1.0.66

package/src/capabilities/workflow-engine.js

@@ -22,74 +22,130 @@ const StepType = {
   DELAY: 'delay',
   TOOL: 'tool',
   INPUT: 'input',
-  OUTPUT: 'output'
+  OUTPUT: 'output',
+  MESSAGE: 'message',
+  THINK: 'think'
 }
 
 /**
- * 工作流步骤基类
+ * StepExecutor - 统一的步骤执行器
+ * 同时被 WorkflowEngine 和 ExplorerLoop 使用
  */
-class WorkflowStep {
-  constructor(config) {
-    this.id = config.id || `step_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
-    this.type = config.type
-    this.name = config.name || ''
-    this.description = config.description || ''
-    this.condition = config.condition || null
-    this.timeout = config.timeout || 30000
-    this.retry = config.retry || { enabled: false, maxAttempts: 3, delay: 1000 }
-    this.onSuccess = config.onSuccess || null
-    this.onFailure = config.onFailure || null
+class StepExecutor {
+  constructor(framework) {
+    this.framework = framework
   }
 
-  async execute(context, engine) {
-    throw new Error('execute() must be implemented by subclass')
+  /**
+   * 执行单个步骤
+   */
+  async executeStep(step, context) {
+    const handler = this._getStepHandler(step.type)
+    if (!handler) {
+      throw new Error(`Unknown step type: ${step.type}`)
+    }
+    return await handler.call(this, step, context)
   }
 
-  validate() {
-    if (!this.type) {
-      throw new Error('Step must have a type')
+  /**
+   * 执行多个步骤（顺序）
+   */
+  async executeSteps(steps, context) {
+    const results = []
+    for (const step of steps) {
+      const result = await this.executeStep(step, context)
+      results.push(result)
     }
-    return true
+    return results
   }
-}
 
-/**
- * 脚本步骤
- */
-class ScriptStep extends WorkflowStep {
-  constructor(config) {
-    super({ ...config, type: StepType.SCRIPT })
-    this.script = config.script
-    this.outputVariable = config.outputVariable || null
+  /**
+   * 获取步骤类型处理器
+   */
+  _getStepHandler(type) {
+    const handlers = {
+      [StepType.TOOL]: this.executeTool,
+      [StepType.SCRIPT]: this.executeScript,
+      [StepType.CONDITION]: this.executeCondition,
+      [StepType.LOOP]: this.executeLoop,
+      [StepType.DELAY]: this.executeDelay,
+      [StepType.SEQUENTIAL]: this.executeSequential,
+      [StepType.MESSAGE]: this.executeMessage,
+      [StepType.THINK]: this.executeThink
+    }
+    return handlers[type]
   }
 
-  async execute(context, engine) {
-    console.log(`[Workflow] Executing script step: ${this.name || this.id}`)
+  /**
+   * 执行工具步骤
+   */
+  async executeTool(step, context) {
+    if (!step.tool) {
+      throw new Error('Tool step requires a tool name')
+    }
+
+    console.log(`[StepExecutor] Executing tool: ${step.tool}`)
+
+    // 解析工具参数，支持变量引用
+    const resolvedArgs = this._resolveArgs(step.args || {}, context)
+
+    // 获取当前 sessionId
+    let sessionId = context.variables?._sessionId
+    if (!sessionId && this.framework.getExecutionContext) {
+      const ctx = this.framework.getExecutionContext()
+      sessionId = ctx?.sessionId
+    }
+
+    // 执行工具
+    let result
+    if (sessionId && this.framework.runWithContext) {
+      result = await this.framework.runWithContext(
+        { sessionId },
+        async () => await this.framework.executeTool(step.tool, resolvedArgs)
+      )
+    } else {
+      result = await this.framework.executeTool(step.tool, resolvedArgs)
+    }
+
+    // 保存结果到变量
+    if (step.outputVariable) {
+      context.variables[step.outputVariable] = result
+    }
+    context.lastResult = result
+
+    if (result && result.error) {
+      console.warn(`[StepExecutor] Tool ${step.tool} returned error: ${result.error}`)
+    }
+
+    return result
+  }
+
+  /**
+   * 执行脚本步骤
+   */
+  async executeScript(step, context) {
+    console.log(`[StepExecutor] Executing script step: ${step.name || step.id}`)
 
     try {
-      // 创建安全的脚本执行环境
       const scriptContext = {
         input: context.input,
         variables: context.variables,
         previousResult: context.lastResult,
         console: {
-          log: (...args) => console.log(`[Script:${this.id}]`, ...args)
+          log: (...args) => console.log(`[Script:${step.id}]`, ...args)
         }
       }
 
-      // 执行脚本
       let result
-      if (typeof this.script === 'function') {
-        result = await this.script(scriptContext)
-      } else if (typeof this.script === 'string') {
-        // eslint-disable-next-line no-new-func
-        const fn = new Function('context', `return (async () => { ${this.script} })()`)
+      if (typeof step.script === 'function') {
+        result = await step.script(scriptContext)
+      } else if (typeof step.script === 'string') {
+        const fn = new Function('context', `return (async () => { ${step.script} })()`)
         result = await fn(scriptContext)
       }
 
-      // 保存结果到变量
-      if (this.outputVariable) {
-        context.variables[this.outputVariable] = result
+      if (step.outputVariable) {
+        context.variables[step.outputVariable] = result
       }
       context.lastResult = result
 
@@ -98,128 +154,79 @@ class ScriptStep extends WorkflowStep {
       throw new Error(`Script execution failed: ${err.message}`)
     }
   }
-}
-
-/**
- * 条件步骤
- */
-class ConditionStep extends WorkflowStep {
-  constructor(config) {
-    super({ ...config, type: StepType.CONDITION })
-    this.branches = config.branches || []
-    this.defaultBranch = config.defaultBranch || null
-  }
 
-  async execute(context, engine) {
-    console.log(`[Workflow] Evaluating condition: ${this.name || this.id}`)
+  /**
+   * 执行条件步骤
+   */
+  async executeCondition(step, context) {
+    console.log(`[StepExecutor] Evaluating condition: ${step.name || step.id}`)
 
-    for (const branch of this.branches) {
+    for (const branch of (step.branches || [])) {
       try {
         let conditionValue
         if (typeof branch.condition === 'function') {
           conditionValue = branch.condition(context)
         } else if (typeof branch.condition === 'string') {
-          // eslint-disable-next-line no-new-func
           const fn = new Function('context', `with(context.variables) { return (${branch.condition}) }`)
           conditionValue = fn(context)
         }
 
         if (conditionValue) {
-          console.log(`[Workflow] Condition matched: ${branch.name || branch.stepId}`)
+          console.log(`[StepExecutor] Condition matched: ${branch.name || branch.stepId}`)
 
           if (branch.steps && branch.steps.length > 0) {
-            // 执行分支步骤
-            for (const stepConfig of branch.steps) {
-              const step = engine.createStep(stepConfig)
-              await step.execute(context, engine)
-            }
+            await this.executeSteps(branch.steps, context)
           }
 
-          return branch.stepId
+          return branch.stepId || branch.name
         }
       } catch (err) {
-        console.warn(`[Workflow] Branch condition error:`, err.message)
+        console.warn(`[StepExecutor] Branch condition error:`, err.message)
       }
     }
 
     // 执行默认分支
-    if (this.defaultBranch && this.defaultBranch.steps) {
-      console.log(`[Workflow] Executing default branch`)
-      for (const stepConfig of this.defaultBranch.steps) {
-        const step = engine.createStep(stepConfig)
-        await step.execute(context, engine)
-      }
+    if (step.defaultBranch && step.defaultBranch.steps) {
+      console.log(`[StepExecutor] Executing default branch`)
+      await this.executeSteps(step.defaultBranch.steps, context)
     }
 
     return null
   }
-}
 
-/**
- * 顺序步骤
- */
-class SequentialStep extends WorkflowStep {
-  constructor(config) {
-    super({ ...config, type: StepType.SEQUENTIAL })
-    this.steps = config.steps || []
-  }
-
-  async execute(context, engine) {
-    console.log(`[Workflow] Executing sequential: ${this.name || this.id}`)
-
-    const results = []
-
-    for (const stepConfig of this.steps) {
-      const step = engine.createStep(stepConfig)
-      const result = await step.execute(context, engine)
-      results.push(result)
-    }
-
-    return results
-  }
-}
-
-/**
- * 循环步骤
- */
-class LoopStep extends WorkflowStep {
-  constructor(config) {
-    super({ ...config, type: StepType.LOOP })
-    this.maxIterations = config.maxIterations || 10
-    this.loopVariable = config.loopVariable || 'loopIndex'
-    this.steps = config.steps || []
-    this.until = config.until || null // 终止条件
-  }
-
-  async execute(context, engine) {
-    console.log(`[Workflow] Executing loop: ${this.name || this.id}`)
+  /**
+   * 执行循环步骤
+   */
+  async executeLoop(step, context) {
+    console.log(`[StepExecutor] Executing loop: ${step.name || step.id}`)
 
     const results = []
+    const maxIterations = step.maxIterations || 10
+    const loopVariable = step.loopVariable || 'loopIndex'
 
-    for (let i = 0; i < this.maxIterations; i++) {
-      context.variables[this.loopVariable] = i
-
-      console.log(`[Workflow] Loop iteration ${i}`)
+    for (let i = 0; i < maxIterations; i++) {
+      context.variables[loopVariable] = i
+      console.log(`[StepExecutor] Loop iteration ${i}`)
 
-      for (const stepConfig of this.steps) {
-        const step = engine.createStep(stepConfig)
-        const result = await step.execute(context, engine)
-        results.push(result)
+      const iterationResults = []
+      for (const stepConfig of (step.steps || [])) {
+        const result = await this.executeStep(stepConfig, context)
+        iterationResults.push(result)
       }
+      results.push(iterationResults)
 
       // 检查终止条件
-      if (this.until) {
+      if (step.until) {
         let shouldStop = false
-        if (typeof this.until === 'function') {
-          shouldStop = this.until(context)
-        } else if (typeof this.until === 'string') {
-          // eslint-disable-next-line no-new-func
-          const fn = new Function('context', `with(context.variables) { return (${this.until}) }`)
+        if (typeof step.until === 'function') {
+          shouldStop = step.until(context)
+        } else if (typeof step.until === 'string') {
+          const fn = new Function('context', `with(context.variables) { return (${step.until}) }`)
           shouldStop = fn(context)
         }
 
         if (shouldStop) {
-          console.log(`[Workflow] Loop terminated at iteration ${i}`)
+          console.log(`[StepExecutor] Loop terminated at iteration ${i}`)
           break
         }
       }
@@ -227,80 +234,89 @@ class LoopStep extends WorkflowStep {
 
     return results
   }
-}
-
-/**
- * 延迟步骤
- */
-class DelayStep extends WorkflowStep {
-  constructor(config) {
-    super({ ...config, type: StepType.DELAY })
-    this.delayMs = config.delayMs || 1000
-  }
 
-  async execute(context, engine) {
-    console.log(`[Workflow] Delaying ${this.delayMs}ms`)
-    await new Promise(resolve => setTimeout(resolve, this.delayMs))
+  /**
+   * 执行延迟步骤
+   */
+  async executeDelay(step, context) {
+    const delayMs = step.delayMs || 1000
+    console.log(`[StepExecutor] Delaying ${delayMs}ms`)
+    await new Promise(resolve => setTimeout(resolve, delayMs))
     return null
   }
-}
 
-/**
- * 工具步骤
- */
-class ToolStep extends WorkflowStep {
-  constructor(config) {
-    super({ ...config, type: StepType.TOOL })
-    this.tool = config.tool
-    this.args = config.args || {}
-    this.outputVariable = config.outputVariable || null
+  /**
+   * 执行顺序步骤
+   */
+  async executeSequential(step, context) {
+    console.log(`[StepExecutor] Executing sequential: ${step.name || step.id}`)
+    return await this.executeSteps(step.steps || [], context)
   }
 
-  async execute(context, engine) {
-    if (!this.tool) {
-      throw new Error('Tool step requires a tool name')
-    }
+  /**
+   * 执行消息步骤（ExplorerLoop 专用）
+   */
+  async executeMessage(step, context) {
+    console.log(`[StepExecutor] Executing message step`)
 
-    console.log(`[Workflow] Executing tool: ${this.tool}`)
+    const agent = this._getActiveAgent()
+    if (!agent) {
+      return { success: false, error: '没有可用的代理' }
+    }
 
-    // 解析工具参数，支持变量引用
-    const resolvedArgs = this._resolveArgs(this.args, context)
+    let content = step.content || ''
+    // 支持变量引用
+    content = this._resolveValue(content, context)
 
-    // 获取当前 sessionId（从上下文变量或执行上下文）
-    let sessionId = context.variables._sessionId
-    if (!sessionId && engine.framework.getExecutionContext) {
-      const ctx = engine.framework.getExecutionContext()
-      sessionId = ctx?.sessionId
+    // 如果有事件上下文，附加到消息
+    if (context.variables?._event) {
+      content = `${content}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
     }
 
-    // 使用 sessionId 上下文执行工具
-    let result
-    if (sessionId && engine.framework.runWithContext) {
-      result = await engine.framework.runWithContext(
-        { sessionId },
-        async () => await engine.framework.executeTool(this.tool, resolvedArgs)
-      )
-    } else {
-      result = await engine.framework.executeTool(this.tool, resolvedArgs)
-    }
+    const result = await agent.pushMessage(content)
+    return { success: true, result }
+  }
 
-    // 保存结果到变量
-    if (this.outputVariable) {
-      context.variables[this.outputVariable] = result
+  /**
+   * 执行思考步骤（ExplorerLoop 专用）
+   */
+  async executeThink(step, context) {
+    console.log(`[StepExecutor] Executing think step`)
+
+    const thinkPlugin = this.framework.pluginManager?.get('think')
+    if (!thinkPlugin) {
+      return { success: false, error: '思考插件不可用' }
     }
-    context.lastResult = result
 
-    // 检查工具执行结果
-    if (result && result.error) {
-      console.warn(`[Workflow] Tool ${this.tool} returned error: ${result.error}`)
+    let topic = step.topic || 'Ambient代理反思'
+    topic = this._resolveValue(topic, context)
+
+    if (context.variables?._event) {
+      topic = `${topic}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
     }
 
+    const result = await thinkPlugin._triggerThinking({
+      topic,
+      mode: step.mode || 'reflect',
+      depth: step.depth || 2
+    })
+
     return result
   }
 
+  /**
+   * 获取活跃代理
+   */
+  _getActiveAgent() {
+    if (this.framework._mainAgent) {
+      return this.framework._mainAgent
+    }
+    const agents = this.framework._agents || []
+    return agents.length > 0 ? agents[agents.length - 1] : null
+  }
+
   /**
    * 解析参数中的变量引用
-   * 支持 {{variableName}} 语法
    */
   _resolveArgs(args, context) {
     const resolved = {}
@@ -312,18 +328,14 @@ class ToolStep extends WorkflowStep {
 
   _resolveValue(value, context) {
     if (typeof value === 'string') {
-      // 替换 {{variable}} 或 {{variables.name}} 语法
       return value.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (match, path) => {
-        // 支持 variables.xxx 或直接 xxx 格式
         if (path.startsWith('variables.')) {
           return this._getNestedValue(context, path) ?? match
         } else if (path.startsWith('context.')) {
           return this._getNestedValue(context, path) ?? match
         } else {
-          // 尝试从 context.variables 获取
           const val = this._getNestedValue(context.variables, path)
           if (val !== undefined) return val
-          // 尝试从 context 直接获取
           return this._getNestedValue(context, path) ?? match
         }
       })
@@ -351,6 +363,175 @@ class ToolStep extends WorkflowStep {
   }
 }
 
+/**
+ * 工作流步骤基类
+ */
+class WorkflowStep {
+  constructor(config) {
+    this.id = config.id || `step_${Date.now()}_${Math.random().toString(36).substr(2, 9)}`
+    this.type = config.type
+    this.name = config.name || ''
+    this.description = config.description || ''
+    this.condition = config.condition || null
+    this.timeout = config.timeout || 30000
+    this.retry = config.retry || { enabled: false, maxAttempts: 3, delay: 1000 }
+    this.onSuccess = config.onSuccess || null
+    this.onFailure = config.onFailure || null
+  }
+
+  async execute(context, engine) {
+    throw new Error('execute() must be implemented by subclass')
+  }
+
+  validate() {
+    if (!this.type) {
+      throw new Error('Step must have a type')
+    }
+    return true
+  }
+}
+
+/**
+ * 脚本步骤
+ */
+class ScriptStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.SCRIPT })
+    this.script = config.script
+    this.outputVariable = config.outputVariable || null
+  }
+
+  async execute(context, engine) {
+    // 使用 StepExecutor 执行脚本逻辑
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.SCRIPT,
+      script: this.script,
+      outputVariable: this.outputVariable
+    }
+    return await executor.executeScript(stepConfig, context)
+  }
+}
+
+/**
+ * 条件步骤
+ */
+class ConditionStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.CONDITION })
+    this.branches = config.branches || []
+    this.defaultBranch = config.defaultBranch || null
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.CONDITION,
+      branches: this.branches,
+      defaultBranch: this.defaultBranch
+    }
+    return await executor.executeCondition(stepConfig, context)
+  }
+}
+
+/**
+ * 顺序步骤
+ */
+class SequentialStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.SEQUENTIAL })
+    this.steps = config.steps || []
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.SEQUENTIAL,
+      steps: this.steps
+    }
+    return await executor.executeSequential(stepConfig, context)
+  }
+}
+
+/**
+ * 循环步骤
+ */
+class LoopStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.LOOP })
+    this.maxIterations = config.maxIterations || 10
+    this.loopVariable = config.loopVariable || 'loopIndex'
+    this.steps = config.steps || []
+    this.until = config.until || null
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.LOOP,
+      maxIterations: this.maxIterations,
+      loopVariable: this.loopVariable,
+      steps: this.steps,
+      until: this.until
+    }
+    return await executor.executeLoop(stepConfig, context)
+  }
+}
+
+/**
+ * 延迟步骤
+ */
+class DelayStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.DELAY })
+    this.delayMs = config.delayMs || 1000
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.DELAY,
+      delayMs: this.delayMs
+    }
+    return await executor.executeDelay(stepConfig, context)
+  }
+}
+
+/**
+ * 工具步骤
+ */
+class ToolStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.TOOL })
+    this.tool = config.tool
+    this.args = config.args || {}
+    this.outputVariable = config.outputVariable || null
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.TOOL,
+      tool: this.tool,
+      args: this.args,
+      outputVariable: this.outputVariable
+    }
+    return await executor.executeTool(stepConfig, context)
+  }
+}
+
 /**
  * 工作流引擎
  */
@@ -634,6 +815,7 @@ module.exports = {
   WorkflowEngine,
   WorkflowStep,
   StepType,
+  StepExecutor,
   ScriptStep,
   ConditionStep,
   SequentialStep,