foliko 1.0.64 → 1.0.66

package/src/capabilities/workflow-engine.js

@@ -20,75 +20,132 @@ const StepType = {
   SEQUENTIAL: 'sequential',
   LOOP: 'loop',
   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
 
@@ -97,61 +154,288 @@ 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
+  }
+
+  /**
+   * 执行循环步骤
+   */
+  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 < maxIterations; i++) {
+      context.variables[loopVariable] = i
+      console.log(`[StepExecutor] Loop iteration ${i}`)
+
+      const iterationResults = []
+      for (const stepConfig of (step.steps || [])) {
+        const result = await this.executeStep(stepConfig, context)
+        iterationResults.push(result)
+      }
+      results.push(iterationResults)
+
+      // 检查终止条件
+      if (step.until) {
+        let shouldStop = false
+        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(`[StepExecutor] Loop terminated at iteration ${i}`)
+          break
+        }
       }
     }
 
+    return results
+  }
+
+  /**
+   * 执行延迟步骤
+   */
+  async executeDelay(step, context) {
+    const delayMs = step.delayMs || 1000
+    console.log(`[StepExecutor] Delaying ${delayMs}ms`)
+    await new Promise(resolve => setTimeout(resolve, delayMs))
     return null
   }
+
+  /**
+   * 执行顺序步骤
+   */
+  async executeSequential(step, context) {
+    console.log(`[StepExecutor] Executing sequential: ${step.name || step.id}`)
+    return await this.executeSteps(step.steps || [], context)
+  }
+
+  /**
+   * 执行消息步骤（ExplorerLoop 专用）
+   */
+  async executeMessage(step, context) {
+    console.log(`[StepExecutor] Executing message step`)
+
+    const agent = this._getActiveAgent()
+    if (!agent) {
+      return { success: false, error: '没有可用的代理' }
+    }
+
+    let content = step.content || ''
+    // 支持变量引用
+    content = this._resolveValue(content, context)
+
+    // 如果有事件上下文，附加到消息
+    if (context.variables?._event) {
+      content = `${content}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
+    }
+
+    const result = await agent.pushMessage(content)
+    return { success: true, 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: '思考插件不可用' }
+    }
+
+    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
+  }
+
+  /**
+   * 解析参数中的变量引用
+   */
+  _resolveArgs(args, context) {
+    const resolved = {}
+    for (const [key, value] of Object.entries(args)) {
+      resolved[key] = this._resolveValue(value, context)
+    }
+    return resolved
+  }
+
+  _resolveValue(value, context) {
+    if (typeof value === 'string') {
+      return value.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (match, path) => {
+        if (path.startsWith('variables.')) {
+          return this._getNestedValue(context, path) ?? match
+        } else if (path.startsWith('context.')) {
+          return this._getNestedValue(context, path) ?? match
+        } else {
+          const val = this._getNestedValue(context.variables, path)
+          if (val !== undefined) return val
+          return this._getNestedValue(context, path) ?? match
+        }
+      })
+    } else if (Array.isArray(value)) {
+      return value.map(v => this._resolveValue(v, context))
+    } else if (typeof value === 'object' && value !== null) {
+      const resolved = {}
+      for (const [k, v] of Object.entries(value)) {
+        resolved[k] = this._resolveValue(v, context)
+      }
+      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
+  }
+}
+
+/**
+ * 工作流步骤基类
+ */
+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)
+  }
 }
 
 /**
@@ -164,17 +448,14 @@ class SequentialStep extends WorkflowStep {
   }
 
   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)
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.SEQUENTIAL,
+      steps: this.steps
     }
-
-    return results
+    return await executor.executeSequential(stepConfig, context)
   }
 }
 
@@ -187,44 +468,21 @@ class LoopStep extends WorkflowStep {
     this.maxIterations = config.maxIterations || 10
     this.loopVariable = config.loopVariable || 'loopIndex'
     this.steps = config.steps || []
-    this.until = config.until || null // 终止条件
+    this.until = config.until || null
   }
 
   async execute(context, engine) {
-    console.log(`[Workflow] Executing loop: ${this.name || this.id}`)
-
-    const results = []
-
-    for (let i = 0; i < this.maxIterations; i++) {
-      context.variables[this.loopVariable] = i
-
-      console.log(`[Workflow] Loop iteration ${i}`)
-
-      for (const stepConfig of this.steps) {
-        const step = engine.createStep(stepConfig)
-        const result = await step.execute(context, engine)
-        results.push(result)
-      }
-
-      // 检查终止条件
-      if (this.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}) }`)
-          shouldStop = fn(context)
-        }
-
-        if (shouldStop) {
-          console.log(`[Workflow] Loop terminated at iteration ${i}`)
-          break
-        }
-      }
+    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 results
+    return await executor.executeLoop(stepConfig, context)
   }
 }
 
@@ -238,9 +496,39 @@ class DelayStep extends WorkflowStep {
   }
 
   async execute(context, engine) {
-    console.log(`[Workflow] Delaying ${this.delayMs}ms`)
-    await new Promise(resolve => setTimeout(resolve, this.delayMs))
-    return null
+    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)
   }
 }
 
@@ -316,6 +604,7 @@ class WorkflowPlugin extends Plugin {
     this._engine.registerStepType(StepType.SEQUENTIAL, SequentialStep)
     this._engine.registerStepType(StepType.LOOP, LoopStep)
     this._engine.registerStepType(StepType.DELAY, DelayStep)
+    this._engine.registerStepType(StepType.TOOL, ToolStep)
 
     // 注册工作流执行工具
     framework.registerTool({
@@ -325,8 +614,14 @@ class WorkflowPlugin extends Plugin {
         workflow: z.string().describe('工作流定义（JSON 或 JavaScript 代码）'),
         input: z.object({}).optional().describe('工作流输入参数')
       }),
-      execute: async (args) => {
-        return await this.executeWorkflow(args.workflow, args.input || {})
+      execute: async (args, framework) => {
+        // 获取当前 sessionId
+        let sessionId = null
+        const ctx = framework.getExecutionContext()
+        if (ctx?.sessionId) {
+          sessionId = ctx.sessionId
+        }
+        return await this.executeWorkflow(args.workflow, args.input || {}, sessionId)
       }
     })
 
@@ -455,18 +750,24 @@ class WorkflowPlugin extends Plugin {
   /**
    * 执行工作流
    */
-  async executeWorkflow(workflowDef, input = {}) {
+  async executeWorkflow(workflowDef, input = {}, sessionId = null) {
     try {
       let workflow
 
       if (typeof workflowDef === 'string') {
-        // 尝试解析 JSON 或执行代码
-        try {
-          workflow = JSON.parse(workflowDef)
-        } catch {
-          // eslint-disable-next-line no-new-func
-          const fn = new Function('engine', 'return (' + workflowDef + ')')
-          workflow = fn(this._engine)
+        // 尝试作为工作流名称加载（先检查是否已加载的工作流）
+        const workflowName = workflowDef.trim()
+        if (this._workflows.has(workflowName)) {
+          workflow = this._workflows.get(workflowName)
+        } else {
+          // 尝试解析 JSON 或执行代码
+          try {
+            workflow = JSON.parse(workflowDef)
+          } catch {
+            // eslint-disable-next-line no-new-func
+            const fn = new Function('engine', 'return (' + workflowDef + ')')
+            workflow = fn(this._engine)
+          }
         }
       } else {
         workflow = workflowDef
@@ -474,6 +775,11 @@ class WorkflowPlugin extends Plugin {
 
       const context = this._engine.createContext(input, {})
 
+      // 将 sessionId 存储到上下文变量，供工具步骤使用
+      if (sessionId) {
+        context.variables._sessionId = sessionId
+      }
+
       // 执行工作流步骤
       if (workflow.steps && Array.isArray(workflow.steps)) {
         const results = []
@@ -509,9 +815,11 @@ module.exports = {
   WorkflowEngine,
   WorkflowStep,
   StepType,
+  StepExecutor,
   ScriptStep,
   ConditionStep,
   SequentialStep,
   LoopStep,
-  DelayStep
+  DelayStep,
+  ToolStep
 }