foliko 2.0.5 → 2.0.7

package/plugins/core/workflow/index.js

@@ -287,33 +287,93 @@ class StepExecutor {
   }
   /**
    * 执行循环步骤
+   * 支持两种模式：
+   * 1. 固定次数循环：maxIterations + loopVariable
+   * 2. 数组迭代循环：over + as + index
    */
   async executeLoop(step, context) {
     this._log.debug(` 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;
-      this._log.debug(` Loop iteration ${i}`);
-      const iterationResults = [];
-      for (const stepConfig of step.steps || []) {
-        const result = await this.executeStep(stepConfig, context);
-        iterationResults.push(result);
+
+    // 检查是否是数组迭代模式 (over + as)
+    if (step.over && step.as) {
+      // 数组迭代模式
+      const arrayPath = step.over;
+      const itemVar = step.as;
+      const indexVar = step.index || 'index';
+
+      // 解析数组路径 - 特殊处理 input.xxx 路径
+      let array;
+      if (arrayPath.startsWith('input.')) {
+        // 直接从 context.input 获取
+        const key = arrayPath.substring(6); // 去掉 'input.' 前缀
+        array = context.input ? context.input[key] : undefined;
+      } else {
+        array = this._resolveValue(`{{${arrayPath}}}`, context);
       }
-      results.push(iterationResults);
-      // 检查终止条件
-      if (step.until) {
-        let shouldStop = false;
-        if (typeof step.until === 'function') {
-          shouldStop = step.until(context);
-        } else if (typeof step.until === 'string') {
-          // 使用沙箱评估循环条件，防止恶意代码执行
-        shouldStop = await evaluateInSandbox(step.until, context, { timeout: 5000 });
+
+      if (!Array.isArray(array)) {
+        this._log.warn(` Loop over: '${arrayPath}' is not an array, skipping. Found:`, typeof array);
+        return results;
+      }
+
+      const maxIterations = step.maxIterations || array.length;
+      for (let i = 0; i < Math.min(maxIterations, array.length); i++) {
+        // 设置循环变量
+        context.variables[indexVar] = i;
+        context.variables[itemVar] = array[i];
+        context.variables.loopIndex = i; // 兼容旧代码
+
+        this._log.debug(` Loop iteration ${i}: ${itemVar}=`, array[i]);
+
+        // 执行循环体
+        const iterationResults = [];
+        for (const stepConfig of step.steps || []) {
+          const result = await this.executeStep(stepConfig, context);
+          iterationResults.push(result);
         }
-        if (shouldStop) {
-          this._log.debug(` Loop terminated at iteration ${i}`);
-          break;
+        results.push(iterationResults);
+
+        // 检查终止条件
+        if (step.until) {
+          let shouldStop = false;
+          if (typeof step.until === 'function') {
+            shouldStop = step.until(context);
+          } else if (typeof step.until === 'string') {
+            shouldStop = await evaluateInSandbox(step.until, context, { timeout: 5000 });
+          }
+          if (shouldStop) {
+            this._log.debug(` Loop terminated at iteration ${i}`);
+            break;
+          }
+        }
+      }
+    } else {
+      // 固定次数循环模式（原有逻辑）
+      const maxIterations = step.maxIterations || 10;
+      const loopVariable = step.loopVariable || 'loopIndex';
+      for (let i = 0; i < maxIterations; i++) {
+        context.variables[loopVariable] = i;
+        context.variables.loopIndex = i; // 兼容
+        this._log.debug(` 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') {
+            shouldStop = await evaluateInSandbox(step.until, context, { timeout: 5000 });
+          }
+          if (shouldStop) {
+            this._log.debug(` Loop terminated at iteration ${i}`);
+            break;
+          }
         }
       }
     }
@@ -773,7 +833,7 @@ class WorkflowEngine extends EventEmitter {
         type = StepType.WORKFLOW;
       } else if (config.branches) {
         type = StepType.CONDITION;
-      } else if (config.steps && (config.loopVariable || config.maxIterations)) {
+      } else if (config.steps && (config.loopVariable || config.maxIterations || config.over)) {
         type = StepType.LOOP;
       } else if (config.steps) {
         type = StepType.SEQUENTIAL;
@@ -847,7 +907,11 @@ class WorkflowPlugin extends Plugin {
       description: '执行指定的工作流',
       inputSchema: z.object({
         workflow: z.string().describe('工作流定义（JSON 或 JavaScript 代码）'),
-        input: z.object({}).optional().describe('工作流输入参数'),
+        // Use record(z.any()) rather than object({}) so callers can pass an
+        // object with arbitrary fields; default z.object({}) strips unknown
+        // keys (and here the schema is empty, so input would always end up
+        // as `{}` regardless of what was sent).
+        input: z.record(z.any()).optional().describe('工作流输入参数'),
       }),
       execute: async (args, framework) => {
         // 获取当前 sessionId
@@ -870,7 +934,16 @@ class WorkflowPlugin extends Plugin {
       description: '重载所有工作流，当用户添加或修改工作流后调用此工具',
       inputSchema: z.object({}),
       execute: async () => {
-        this.reload(this._framework);
+        // Forward to pluginManager.reload so the framework has a chance to
+        // refresh the plugin prototype (workflow_reload used to call
+        // this.reload() directly, but instance.reload() always runs against
+        // the prototype captured at construction time, ignoring code changes
+        // until the process restarts).
+        if (typeof framework.reloadPlugin === 'function') {
+          await framework.reloadPlugin('workflow');
+        } else {
+          this.reload(this._framework);
+        }
         return {
           success: true,
           data: `Workflows reloaded. Total: ${this._workflows.size}`,
@@ -934,15 +1007,48 @@ class WorkflowPlugin extends Plugin {
             let workflowDef;
             if (file.endsWith('.js')) {
               workflowDef = runWorkflowFileSafely(content, { timeout: 10000 });
+              if (workflowDef && typeof workflowDef === 'object' && typeof workflowDef.default === 'function') {
+                // ES module-style default export: { default: function($){...} }
+                workflowDef = workflowDef.default;
+              }
               if (typeof workflowDef === 'function') {
-                workflowDef = workflowDef(this._engine || {});
+                // Two JS workflow patterns are supported:
+                //   1. FLOW(function($) { $.push(...); $.next('start'); })
+                //      -> the exported value is a *factory* that must be called with engine
+                //   2. module.exports = function($) { $.push(...); $.next('start'); }
+                //      -> the exported value is the workflow function itself (not a factory)
+                //      -> it must NOT be called here; v2 JsRunner will invoke it with $ directly.
+                //      -> FLOW() can also export a factory directly if there's no surrounding
+                //         function body (raw expression form).
+                // We detect the factory form by looking for the literal `FLOW(` token
+                // in the file's source. When FLOW() is detected, we invoke it as factory.
+                if (/\bFLOW\s*\(/.test(content)) {
+                  try {
+                    workflowDef = workflowDef(this._engine || {});
+                    if (workflowDef && typeof workflowDef === 'object' && typeof workflowDef.default === 'function') {
+                      workflowDef = workflowDef.default;
+                    }
+                  } catch (err) {
+                    log.error(` Failed to call FLOW() factory for ${file}:`, err.message);
+                  }
+                }
+                // else: leave workflowDef as-is (it's already the workflow function)
               }
-              workflowDef = workflowDef.default || workflowDef;
             } else {
               workflowDef = JSON.parse(content);
             }
-            if (workflowDef && workflowDef.steps) {
+            // Accept either:
+            //   - JSON-style workflow with stages/flow field
+            //   - JS workflow exported as a function (Total.js style: FLOW(function($){...})
+            //     or module.exports = function($){...})
+            if (workflowDef && (workflowDef.stages || workflowDef.flow)) {
+              this._workflows.set(workflowName, workflowDef);
+            } else if (typeof workflowDef === 'function') {
+              // Store the JS function directly; v2 FlowEngine detects function type
+              // and dispatches to JsRunner.
               this._workflows.set(workflowName, workflowDef);
+            } else {
+              log.warn(`Skipping ${file}: not a recognized workflow definition (no stages/flow, and not a function)`);
             }
           } catch (err) {
             log.error(` Failed to load ${file}:`, err.message);
@@ -958,9 +1064,17 @@ class WorkflowPlugin extends Plugin {
    */
   _registerWorkflowTools() {
     for (const [name, workflow] of this._workflows) {
-      if (this._workflowTools.has(name)) continue;
       const toolName = `workflow_${name}`;
       const description = workflow.description || `执行工作流: ${name}`;
+      // 注意：framework.registerTool 不做去重，导致 reload 后会有两个同名
+      // `workflow_<name>` 工具。getTool 返回第一个（旧的）。每次注册前先清掉。
+      if (this._framework?.toolRegistry?.unregisterTool) {
+        try {
+          this._framework.toolRegistry.unregisterTool(toolName);
+        } catch (e) {
+          // noop
+        }
+      }
       this._framework.registerTool({
         name: toolName,
         description,
@@ -968,13 +1082,24 @@ class WorkflowPlugin extends Plugin {
           input: z.object({}).optional().describe('工作流输入参数'),
         }),
         execute: async (args, framework) => {
-          // Get current sessionId to ensure notifications reach the correct session
-          let sessionId = null;
-          const ctx = framework?.getExecutionContext?.();
-          if (ctx?.sessionId) {
-            sessionId = ctx.sessionId;
+          // 每次执行都从 this._workflows 重新查最新处理函数。
+          // 这样即使 ChatHandler 缓存了上个版本的 execute，我们仍能闭包到本对象上。
+          // 注意：ToolRegistry._tools.set 被调用后都是一个新的 execute 对象（闭包重新生成），
+          // 旧 execute 会因为 ChatHandler._aiToolsCache 不清而一直残留。
+          // 修复点：framework.registerTool现在会同步重设 ChatHandler 相关缓存。
+          let liveWorkflow;
+          try {
+            liveWorkflow = this._workflows.get(name);
+            if (!liveWorkflow) {
+              return { success: false, error: `Workflow '${name}' not loaded` };
+            }
+            let sessionId = null;
+            const ctx = framework?.getExecutionContext?.();
+            if (ctx?.sessionId) sessionId = ctx.sessionId;
+            return await this.executeWorkflow(liveWorkflow, args.input || {}, sessionId);
+          } catch (e) {
+            return { success: false, error: e.message, stack: e.stack };
           }
-          return await this.executeWorkflow(workflow, args.input || {}, sessionId);
         },
       });
       this._workflowTools.set(name, toolName);
@@ -1009,10 +1134,35 @@ class WorkflowPlugin extends Plugin {
    * 重载工作流
    */
   reload(framework) {
-    // 清除当前模块缓存，确保重新加载最新代码
-    delete require.cache[__filename];
+    // 清除所有 workflow 相关模块的 require 缓存（action.js / engine.js / json-runner.js / context.js）
+    // 否则即使代码已修改，Node.js 仍会使用旧的模块引用
+    const workflowDir = path.dirname(__filename);
+    // framework 根目录（用于清除 src/utils 等跨插件共享模块）
+    const frameworkRoot = path.resolve(workflowDir, '..', '..', '..');
+    const modulesToClear = [
+      __filename,
+      path.join(workflowDir, 'engine.js'),
+      path.join(workflowDir, 'json-runner.js'),
+      path.join(workflowDir, 'js-runner.js'),
+      path.join(workflowDir, 'context.js'),
+      path.join(workflowDir, 'stages', 'action.js'),
+      path.join(workflowDir, 'stages', 'choice.js'),
+      path.join(workflowDir, 'stages', 'each.js'),
+      path.join(workflowDir, 'stages', 'parallel.js'),
+      path.join(frameworkRoot, 'src', 'utils', 'sandbox.js'),
+    ];
+    for (const modPath of modulesToClear) {
+      delete require.cache[modPath];
+    }
+
+    // 销毁 v2 引擎实例（懒加载缓存），强制下次执行时重建
+    this._flowEngineV2 = null;
+
     this._framework = framework;
     const fresh = require(__filename);
+    // 重现现有实例的 prototype，让后续方法调用走最新代码
+    // (实例属性如 _workflows/_workflowTools/_engine 保持，prototype 方法切换为 fresh)
+    Object.setPrototypeOf(this, fresh.WorkflowPlugin.prototype);
     // 重新创建 engine（确保使用最新代码）
     this._engine = new fresh.WorkflowEngine(framework);
     // 注册内置步骤类型
@@ -1027,8 +1177,12 @@ class WorkflowPlugin extends Plugin {
     this._engine.registerStepType(fresh.StepType.DELAY, fresh.DelayStep);
     this._engine.registerStepType(fresh.StepType.WORKFLOW, fresh.NestedWorkflowStep);
     // 清除已注册的工具
+    // framework.registerTool/unregisterTool 会同步重置 ChatHandler._aiToolsCache。
     for (const toolName of this._workflowTools.values()) {
-      // 工具注销需要框架支持，这里只清理内部状态
+      try {
+        if (this._framework?.unregisterTool) this._framework.unregisterTool(toolName);
+        else this._framework?.toolRegistry?.unregister?.(toolName);
+      } catch (_) {}
     }
     this._workflowTools.clear();
     this._workflows.clear();
@@ -1044,8 +1198,15 @@ class WorkflowPlugin extends Plugin {
   }
   /**
    * 执行工作流
+   * 支持 v2 JSON 和 JS 格式
    */
   async executeWorkflow(workflowDef, input = {}, sessionId = null) {
+    // Lazy load v2 engine to avoid circular require
+    if (!this._flowEngineV2) {
+      const { FlowEngine } = require('./engine');
+      this._flowEngineV2 = new FlowEngine(this._framework);
+    }
+
     try {
       let workflow;
       if (typeof workflowDef === 'string') {
@@ -1054,55 +1215,20 @@ class WorkflowPlugin extends Plugin {
         if (this._workflows.has(workflowName)) {
           workflow = this._workflows.get(workflowName);
         } else {
-          // 尝试解析 JSON 或执行代码
+          // 尝试解析 JSON
           try {
             workflow = JSON.parse(workflowDef);
           } catch {
-            // 使用沙箱解析工作流定义，防止恶意代码执行
-            workflow = runWorkflowSafely(workflowDef, this._engine, { timeout: 5000 });
+            // JSON 解析失败，视为 JS 代码
+            workflow = workflowDef;
           }
         }
       } else {
         workflow = workflowDef;
       }
-      const context = this._engine.createContext(input, {});
-      // 将 sessionId 存储到上下文变量，供工具步骤使用
-      if (sessionId) {
-        context.variables._sessionId = sessionId;
-      }
-      // 执行工作流步骤
-      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, output: {} };
+
+      // 委托给 v2 引擎执行
+      return await this._flowEngineV2.execute(workflow, input, sessionId);
     } catch (err) {
       return { success: false, error: err.message };
     }