foliko 1.0.67 → 1.0.69

package/src/capabilities/workflow-engine.js

@@ -16,6 +16,8 @@ const StepType = {
   AGENT: 'agent',
   SCRIPT: 'script',
   CONDITION: 'condition',
+  SWITCH: 'switch',
+  TRY: 'try',
   PARALLEL: 'parallel',
   SEQUENTIAL: 'sequential',
   LOOP: 'loop',
@@ -24,7 +26,8 @@ const StepType = {
   INPUT: 'input',
   OUTPUT: 'output',
   MESSAGE: 'message',
-  THINK: 'think'
+  THINK: 'think',
+  WORKFLOW: 'workflow'  // 嵌套工作流
 }
 
 /**
@@ -67,15 +70,117 @@ class StepExecutor {
       [StepType.TOOL]: this.executeTool,
       [StepType.SCRIPT]: this.executeScript,
       [StepType.CONDITION]: this.executeCondition,
+      [StepType.SWITCH]: this.executeSwitch,
+      [StepType.TRY]: this.executeTry,
+      [StepType.PARALLEL]: this.executeParallel,
       [StepType.LOOP]: this.executeLoop,
       [StepType.DELAY]: this.executeDelay,
       [StepType.SEQUENTIAL]: this.executeSequential,
       [StepType.MESSAGE]: this.executeMessage,
-      [StepType.THINK]: this.executeThink
+      [StepType.THINK]: this.executeThink,
+      [StepType.WORKFLOW]: this.executeWorkflowStep
     }
     return handlers[type]
   }
 
+  /**
+   * 执行 switch 步骤
+   */
+  async executeSwitch(step, context) {
+    console.log(`[StepExecutor] Executing switch: ${step.name || step.id}`)
+
+    const value = this._resolveValue(step.value, context)
+    const branches = step.branches || []
+
+    for (const branch of branches) {
+      const caseValue = this._resolveValue(branch.case, context)
+      if (value === caseValue) {
+        console.log(`[StepExecutor] Switch matched case: ${caseValue}`)
+        if (branch.steps && branch.steps.length > 0) {
+          return await this.executeSteps(branch.steps, context)
+        }
+        return { matched: caseValue }
+      }
+    }
+
+    // 默认分支
+    if (step.default && step.default.steps) {
+      console.log(`[StepExecutor] Executing switch default branch`)
+      return await this.executeSteps(step.default.steps, context)
+    }
+
+    return { matched: null, value }
+  }
+
+  /**
+   * 执行 try-catch 步骤
+   */
+  async executeTry(step, context) {
+    console.log(`[StepExecutor] Executing try-catch: ${step.name || step.id}`)
+
+    try {
+      if (step.try && step.try.steps) {
+        const result = await this.executeSteps(step.try.steps, context)
+        return { success: true, result }
+      }
+      return { success: true }
+    } catch (err) {
+      console.log(`[StepExecutor] Try block failed, executing catch: ${err.message}`)
+      if (step.catch && step.catch.steps) {
+        const catchResult = await this.executeSteps(step.catch.steps, context)
+        return { success: false, error: err.message, caught: catchResult }
+      }
+      return { success: false, error: err.message }
+    }
+  }
+
+  /**
+   * 执行嵌套工作流步骤
+   */
+  async executeWorkflowStep(step, context) {
+    console.log(`[StepExecutor] Executing nested workflow: ${step.name || step.id}`)
+
+    if (!step.workflow) {
+      throw new Error('Workflow step requires a workflow definition')
+    }
+
+    // 执行嵌套工作流
+    const result = await this.framework.pluginManager.get('workflow').executeWorkflow(
+      step.workflow,
+      step.input || {},
+      context.variables._sessionId
+    )
+
+    // 将嵌套工作流的输出合并到当前上下文
+    if (result.output) {
+      for (const [key, value] of Object.entries(result.output)) {
+        context.variables[key] = value
+      }
+    }
+
+    return result
+  }
+
+  /**
+   * 执行并行步骤
+   */
+  async executeParallel(step, context) {
+    console.log(`[StepExecutor] Executing parallel: ${step.name || step.id}`)
+
+    const steps = step.steps || []
+    if (steps.length === 0) {
+      return []
+    }
+
+    // 并行执行所有步骤
+    const promises = steps.map(stepConfig => {
+      return this.executeStep(stepConfig, context)
+    })
+
+    const results = await Promise.all(promises)
+    return results
+  }
+
   /**
    * 执行工具步骤
    */
@@ -87,7 +192,14 @@ class StepExecutor {
     console.log(`[StepExecutor] Executing tool: ${step.tool}`)
 
     // 解析工具参数，支持变量引用
-    const resolvedArgs = this._resolveArgs(step.args || {}, context)
+    let resolvedArgs = this._resolveArgs(step.args || {}, context)
+
+    // 兼容旧格式：处理 step.input 字段（${stepId.output} 引用）
+    // 将 input 注入到 args.input_data，供 python-execute 使用
+    if (step.input) {
+      const resolvedInput = this._resolveArgs(step.input, context)
+      resolvedArgs.input_data = resolvedInput
+    }
 
     // 获取当前 sessionId
     let sessionId = context.variables?._sessionId
@@ -108,8 +220,10 @@ class StepExecutor {
     }
 
     // 保存结果到变量
-    if (step.outputVariable) {
-      context.variables[step.outputVariable] = result
+    // 支持 output 作为 outputVariable 的别名
+    const outputVar = step.outputVariable || step.output
+    if (outputVar) {
+      context.variables[outputVar] = result
     }
     context.lastResult = result
 
@@ -127,8 +241,15 @@ class StepExecutor {
     console.log(`[StepExecutor] Executing script step: ${step.name || step.id}`)
 
     try {
+      // 兼容旧格式：处理 step.input 字段（${stepId.output} 引用）
+      let resolvedInput = context.input || {}
+      if (step.input && typeof step.input === 'object') {
+        resolvedInput = this._resolveArgs(step.input, context)
+      }
+
       const scriptContext = {
-        input: context.input,
+        input: resolvedInput,
+        input_data: resolvedInput,  // 兼容 input_data 变量名
         variables: context.variables,
         previousResult: context.lastResult,
         console: {
@@ -144,8 +265,10 @@ class StepExecutor {
         result = await fn(scriptContext)
       }
 
-      if (step.outputVariable) {
-        context.variables[step.outputVariable] = result
+      // 支持 output 作为 outputVariable 的别名
+      const outputVar = step.outputVariable || step.output
+      if (outputVar) {
+        context.variables[outputVar] = result
       }
       context.lastResult = result
 
@@ -259,10 +382,11 @@ class StepExecutor {
   async executeMessage(step, context) {
     console.log(`[StepExecutor] Executing message step`)
 
-    const agent = this._getActiveAgent()
-    if (!agent) {
-      return { success: false, error: '没有可用的代理' }
-    }
+    // 使用子Agent处理消息，避免阻塞主agent
+    const messageAgent = this.framework.createSubAgent({
+      name: 'workflow_message',
+      role: '工作流任务执行助手，专注于处理工作流中的消息任务'
+    })
 
     let content = step.content || ''
     // 支持变量引用
@@ -273,7 +397,7 @@ class StepExecutor {
       content = `${content}\n\n[事件上下文: ${JSON.stringify(context.variables._event)}]`
     }
 
-    const result = await agent.pushMessage(content)
+    const result = await messageAgent.chat(content)
     return { success: true, result }
   }
 
@@ -334,7 +458,35 @@ class StepExecutor {
       // {{variables.xxx}} - 显式引用 context.variables
       // {{context.xxx}} - 显式引用 context 根属性
       // {{lastResult}} - 上一步结果（result 的别名）
-      return value.replace(/\{\{(\w+(?:\.\w+)*)\}\}/g, (match, path) => {
+      // ${stepId.output} - 引用指定 id 步骤的输出（兼容旧格式）
+      // ${stepId.output.path} - 从指定步骤输出提取字段
+      let result = value
+
+      // 先处理 ${stepId.output} 格式（兼容旧格式）
+      result = result.replace(/\$\{([^}]+)\}/g, (match, path) => {
+        const stepOutputs = context.variables._stepOutputs || {}
+        if (path === 'output') {
+          // ${output} 等同于 ${stepId.output} 引用上一步
+          return context.lastResult ?? match
+        }
+        if (path.includes('.')) {
+          // ${stepId.output.field} 格式
+          const [stepId, ...fieldParts] = path.split('.')
+          const stepOutput = stepOutputs[stepId]
+          if (stepOutput !== undefined) {
+            const val = this._getNestedValue(stepOutput, fieldParts.join('.'))
+            if (val !== undefined) return val
+          }
+        } else {
+          // ${stepId.output} 格式
+          const stepOutput = stepOutputs[path]
+          if (stepOutput !== undefined) return stepOutput
+        }
+        return match
+      })
+
+      // 再处理 {{...}} 格式（支持 _event.email.from 等嵌套属性）
+      result = result.replace(/\{\{([^}]+)\}\}/g, (match, path) => {
         // result 和 lastResult 都指向 context.lastResult
         if (path === 'result' || path === 'lastResult') {
           return context.lastResult ?? match
@@ -356,6 +508,8 @@ class StepExecutor {
           return this._getNestedValue(context, path) ?? match
         }
       })
+
+      return result
     } else if (Array.isArray(value)) {
       return value.map(v => this._resolveValue(v, context))
     } else if (typeof value === 'object' && value !== null) {
@@ -463,6 +617,98 @@ class ConditionStep extends WorkflowStep {
   }
 }
 
+/**
+ * 并行步骤
+ */
+class ParallelStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.PARALLEL })
+    this.steps = config.steps || []
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.PARALLEL,
+      steps: this.steps
+    }
+    return await executor.executeParallel(stepConfig, context)
+  }
+}
+
+/**
+ * Switch 步骤
+ */
+class SwitchStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.SWITCH })
+    this.value = config.value
+    this.branches = config.branches || []
+    this.default = config.default || null
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.SWITCH,
+      value: this.value,
+      branches: this.branches,
+      default: this.default
+    }
+    return await executor.executeSwitch(stepConfig, context)
+  }
+}
+
+/**
+ * Try-Catch 步骤
+ */
+class TryStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.TRY })
+    this.try = config.try || {}
+    this.catch = config.catch || {}
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.TRY,
+      try: this.try,
+      catch: this.catch
+    }
+    return await executor.executeTry(stepConfig, context)
+  }
+}
+
+/**
+ * 嵌套工作流步骤
+ */
+class NestedWorkflowStep extends WorkflowStep {
+  constructor(config) {
+    super({ ...config, type: StepType.WORKFLOW })
+    this.workflow = config.workflow
+    this.input = config.input || {}
+  }
+
+  async execute(context, engine) {
+    const executor = new StepExecutor(engine.framework)
+    const stepConfig = {
+      id: this.id,
+      name: this.name,
+      type: StepType.WORKFLOW,
+      workflow: this.workflow,
+      input: this.input
+    }
+    return await executor.executeWorkflowStep(stepConfig, context)
+  }
+}
+
 /**
  * 顺序步骤
  */
@@ -541,6 +787,8 @@ class ToolStep extends WorkflowStep {
     this.tool = config.tool
     this.args = config.args || {}
     this.outputVariable = config.outputVariable || null
+    this.output = config.output || null  // 兼容旧格式
+    this.input = config.input || null    // 兼容旧格式：input 字段
   }
 
   async execute(context, engine) {
@@ -551,7 +799,9 @@ class ToolStep extends WorkflowStep {
       type: StepType.TOOL,
       tool: this.tool,
       args: this.args,
-      outputVariable: this.outputVariable
+      outputVariable: this.outputVariable,
+      output: this.output,  // 传递 output
+      input: this.input     // 传递 input
     }
     return await executor.executeTool(stepConfig, context)
   }
@@ -574,17 +824,64 @@ class WorkflowEngine extends EventEmitter {
     this._steps.set(type, StepClass)
   }
 
-  /**
+    /**
    * 创建步骤实例
+   * 自动推断步骤类型：
+   * - 有 tool 字段 -> tool 类型
+   * - 有 code/script 字段 -> script 类型
+   * - 有 branches 字段 -> condition 类型
+   * - 有 value + branches -> switch 类型
+   * - 有 try/catch 字段 -> try 类型
+   * - 有 parallel 属性 -> parallel 类型
+   * - 有 steps 字段 + loopVariable/maxIterations -> loop 类型
+   * - 有 steps 字段 -> sequential 类型
+   * - 有 delayMs 字段 -> delay 类型
+   * - 有 workflow 字段 -> workflow 类型
    */
   createStep(config) {
-    const StepClass = this._steps.get(config.type)
+    let type = config.type
+
+    // 自动推断类型
+    if (!type) {
+      if (config.tool) {
+        type = StepType.TOOL
+      } else if (config.code || config.script) {
+        type = StepType.SCRIPT
+      } else if (config.try || config.catch) {
+        type = StepType.TRY
+      } else if (config.value !== undefined && config.branches) {
+        type = StepType.SWITCH
+      } else if (config.parallel === true || config.mode === 'parallel') {
+        type = StepType.PARALLEL
+      } else if (config.workflow) {
+        type = StepType.WORKFLOW
+      } else if (config.branches) {
+        type = StepType.CONDITION
+      } else if (config.steps && (config.loopVariable || config.maxIterations)) {
+        type = StepType.LOOP
+      } else if (config.steps) {
+        type = StepType.SEQUENTIAL
+      } else if (config.delayMs !== undefined) {
+        type = StepType.DELAY
+      } else if (config.message) {
+        type = StepType.MESSAGE
+      } else if (config.topic) {
+        type = StepType.THINK
+      }
+    }
+
+    if (!type) {
+      throw new Error(`Cannot infer step type for step: ${JSON.stringify(config).substring(0, 100)}`)
+    }
+
+    const StepClass = this._steps.get(type)
 
     if (!StepClass) {
-      throw new Error(`Unknown step type: ${config.type}`)
+      throw new Error(`Unknown step type: ${type}`)
     }
 
-    return new StepClass(config)
+    // 确保配置有 type 字段
+    return new StepClass({ ...config, type })
   }
 
   /**
@@ -626,10 +923,14 @@ class WorkflowPlugin extends Plugin {
     // 注册内置步骤类型
     this._engine.registerStepType(StepType.SCRIPT, ScriptStep)
     this._engine.registerStepType(StepType.CONDITION, ConditionStep)
+    this._engine.registerStepType(StepType.SWITCH, SwitchStep)
+    this._engine.registerStepType(StepType.TRY, TryStep)
+    this._engine.registerStepType(StepType.PARALLEL, ParallelStep)
     this._engine.registerStepType(StepType.SEQUENTIAL, SequentialStep)
     this._engine.registerStepType(StepType.LOOP, LoopStep)
     this._engine.registerStepType(StepType.DELAY, DelayStep)
     this._engine.registerStepType(StepType.TOOL, ToolStep)
+    this._engine.registerStepType(StepType.WORKFLOW, NestedWorkflowStep)
 
     // 注册工作流执行工具
     framework.registerTool({
@@ -714,7 +1015,7 @@ class WorkflowPlugin extends Plugin {
 
           if (workflowDef && workflowDef.steps) {
             this._workflows.set(workflowName, workflowDef)
-            console.log(`[Workflow] Loaded: ${workflowName}`)
+            //console.log(`[Workflow] Loaded: ${workflowName}`)
           }
         } catch (err) {
           console.error(`[Workflow] Failed to load ${file}:`, err.message)
@@ -758,6 +1059,21 @@ class WorkflowPlugin extends Plugin {
     console.log('[Workflow] Reloading...')
     this._framework = framework
 
+    // 重新创建 engine（确保使用最新代码）
+    this._engine = new (require('./src/capabilities/workflow-engine').WorkflowEngine)(framework)
+
+    // 注册内置步骤类型
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.SCRIPT, require('./src/capabilities/workflow-engine').ScriptStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.TOOL, require('./src/capabilities/workflow-engine').ToolStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.CONDITION, require('./src/capabilities/workflow-engine').ConditionStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.SWITCH, require('./src/capabilities/workflow-engine').SwitchStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.TRY, require('./src/capabilities/workflow-engine').TryStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.PARALLEL, require('./src/capabilities/workflow-engine').ParallelStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.SEQUENTIAL, require('./src/capabilities/workflow-engine').SequentialStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.LOOP, require('./src/capabilities/workflow-engine').LoopStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.DELAY, require('./src/capabilities/workflow-engine').DelayStep)
+    this._engine.registerStepType(require('./src/capabilities/workflow-engine').StepType.WORKFLOW, require('./src/capabilities/workflow-engine').NestedWorkflowStep)
+
     // 清除已注册的工具
     for (const toolName of this._workflowTools.values()) {
       // 工具注销需要框架支持，这里只清理内部状态
@@ -808,15 +1124,40 @@ class WorkflowPlugin extends Plugin {
       // 执行工作流步骤
       if (workflow.steps && Array.isArray(workflow.steps)) {
         const results = []
+        // 按 id 存储步骤输出，供 ${id.output} 引用
+        context.variables._stepOutputs = {}
         for (const stepConfig of workflow.steps) {
           const step = this._engine.createStep(stepConfig)
           const result = await step.execute(context, this._engine)
           results.push(result)
+          // 如果步骤有 id，存储其输出
+          if (stepConfig.id) {
+            context.variables._stepOutputs[stepConfig.id] = result
+          }
+        }
+
+        // 只返回最后一步的结果（包含最终输出）和成功状态
+        // 不返回所有中间结果，避免上下文超限
+        const lastResult = results.length > 0 ? results[results.length - 1] : null
+
+        // 从 context.variables 中提取非下划线开头的用户变量
+        // 下划线开头的是内部变量（如 _stepOutputs），不需要返回
+        const userVariables = {}
+        for (const [key, value] of Object.entries(context.variables)) {
+          if (!key.startsWith('_')) {
+            userVariables[key] = value
+          }
+        }
+
+        return {
+          success: true,
+          stepCount: workflow.steps.length,
+          result: lastResult,
+          output: userVariables
         }
-        return { success: true, results, output: context.variables }
       }
 
-      return { success: true, output: context.variables }
+      return { success: true, output: {} }
     } catch (err) {
       return { success: false, error: err.message }
     }
@@ -843,6 +1184,10 @@ module.exports = {
   StepExecutor,
   ScriptStep,
   ConditionStep,
+  ParallelStep,
+  SwitchStep,
+  TryStep,
+  NestedWorkflowStep,
   SequentialStep,
   LoopStep,
   DelayStep,