feat(core): implement detailed failure context builder for AI fallback execution

quanru · quanru · commit 1a784571c5d0 · 2025-12-31T16:45:11.000+08:00
diff --git a/packages/core/src/agent/agent.ts b/packages/core/src/agent/agent.ts
@@ -1264,99 +1264,15 @@ export class Agent<
     await player.run();
 
     if (player.status === 'error') {
-      const totalTasks = player.taskStatusList.length;
-
-      // Collect completed tasks
-      const completedTasks = player.taskStatusList
-        .filter((task) => task.status === 'done')
-        .map((task) => ({ index: task.index, name: task.name }));
-
-      // Collect failed tasks
-      const failedTasks = player.taskStatusList
-        .filter((task) => task.status === 'error')
-        .map((task) => ({
-          index: task.index,
-          name: task.name,
-          error: task.error,
-          currentStep: task.currentStep,
-          totalSteps: task.totalSteps,
-        }));
-
-      // Collect pending tasks
-      const pendingTasks = player.taskStatusList
-        .filter((task) => task.status === 'init')
-        .map((task) => ({ index: task.index, name: task.name }));
-
-      // Build detailed fallback context for AI
-      const fallbackContextParts: string[] = [];
-
-      // Title
-      if (failedTasks.length > 0) {
-        const firstFailed = failedTasks[0];
-        fallbackContextParts.push(
-          `Previous cached workflow execution failed at step ${firstFailed.index + 1}/${totalTasks}:\n`,
-        );
-      } else {
-        fallbackContextParts.push(
-          'Previous cached workflow execution failed.\n',
-        );
-      }
-
-      // Completed steps
-      if (completedTasks.length > 0) {
-        fallbackContextParts.push('Completed successfully:');
-        for (const task of completedTasks) {
-          fallbackContextParts.push(
-            `  ✓ Step ${task.index + 1}/${totalTasks}: "${task.name}"`,
-          );
-        }
-        fallbackContextParts.push('');
-      }
-
-      // Failed steps
-      if (failedTasks.length > 0) {
-        fallbackContextParts.push('Failed:');
-        for (const task of failedTasks) {
-          const stepInfo =
-            task.currentStep !== undefined
-              ? ` (at substep ${task.currentStep + 1}/${task.totalSteps})`
-              : '';
-          fallbackContextParts.push(
-            `  ✗ Step ${task.index + 1}/${totalTasks}: "${task.name}"${stepInfo}`,
-          );
-          fallbackContextParts.push(
-            `    Error: ${task.error?.message || 'Unknown error'}`,
-          );
-        }
-        fallbackContextParts.push('');
-      }
-
-      // Pending steps
-      if (pendingTasks.length > 0) {
-        fallbackContextParts.push('Remaining steps (not executed):');
-        for (const task of pendingTasks) {
-          fallbackContextParts.push(
-            `  - Step ${task.index + 1}/${totalTasks}: "${task.name}"`,
-          );
-        }
-        fallbackContextParts.push('');
-      }
-
-      // Guidance
-      if (failedTasks.length > 0) {
-        const firstFailed = failedTasks[0];
-        fallbackContextParts.push(
-          `Please continue from Step ${firstFailed.index + 1} and avoid repeating the successful steps.`,
-        );
-      }
-
-      const fallbackContext = fallbackContextParts.join('\n');
+      const { fallbackContext, completedTasks, failedTasks, pendingTasks } =
+        player.buildFailureContext();
 
       // Build error message for logging
+      const totalTasks = player.taskStatusList.length;
       const errors = failedTasks
         .map(
-          (task) =>
-            `task ${task.index + 1}/${totalTasks} "${task.name}": ${task.error?.message}`,
+          (t) =>
+            `task ${t.index + 1}/${totalTasks} "${t.name}": ${t.error?.message}`,
         )
         .join('\n');
 
diff --git a/packages/core/src/yaml/player.ts b/packages/core/src/yaml/player.ts
@@ -202,6 +202,101 @@ export class ScriptPlayer<T extends MidsceneYamlScriptEnv> {
     this.errorInSetup = error;
   }
 
+  /**
+   * Build detailed failure context for AI fallback when execution fails
+   */
+  buildFailureContext(): {
+    fallbackContext: string;
+    completedTasks: { index: number; name: string }[];
+    failedTasks: {
+      index: number;
+      name: string;
+      error?: Error;
+      currentStep?: number;
+      totalSteps: number;
+    }[];
+    pendingTasks: { index: number; name: string }[];
+  } {
+    const totalTasks = this.taskStatusList.length;
+
+    const completedTasks = this.taskStatusList
+      .filter((t) => t.status === 'done')
+      .map((t) => ({ index: t.index, name: t.name }));
+
+    const failedTasks = this.taskStatusList
+      .filter((t) => t.status === 'error')
+      .map((t) => ({
+        index: t.index,
+        name: t.name,
+        error: t.error,
+        currentStep: t.currentStep,
+        totalSteps: t.totalSteps,
+      }));
+
+    const pendingTasks = this.taskStatusList
+      .filter((t) => t.status === 'init')
+      .map((t) => ({ index: t.index, name: t.name }));
+
+    const parts: string[] = [];
+
+    // Title
+    if (failedTasks.length > 0) {
+      parts.push(
+        `Previous cached workflow execution failed at step ${failedTasks[0].index + 1}/${totalTasks}:\n`,
+      );
+    } else {
+      parts.push('Previous cached workflow execution failed.\n');
+    }
+
+    // Completed
+    if (completedTasks.length > 0) {
+      parts.push('Completed successfully:');
+      for (const t of completedTasks) {
+        parts.push(`  ✓ Step ${t.index + 1}/${totalTasks}: "${t.name}"`);
+      }
+      parts.push('');
+    }
+
+    // Failed
+    if (failedTasks.length > 0) {
+      parts.push('Failed:');
+      for (const t of failedTasks) {
+        const stepInfo =
+          t.currentStep !== undefined
+            ? ` (at substep ${t.currentStep + 1}/${t.totalSteps})`
+            : '';
+        parts.push(
+          `  ✗ Step ${t.index + 1}/${totalTasks}: "${t.name}"${stepInfo}`,
+        );
+        parts.push(`    Error: ${t.error?.message || 'Unknown error'}`);
+      }
+      parts.push('');
+    }
+
+    // Pending
+    if (pendingTasks.length > 0) {
+      parts.push('Remaining steps (not executed):');
+      for (const t of pendingTasks) {
+        parts.push(`  - Step ${t.index + 1}/${totalTasks}: "${t.name}"`);
+      }
+      parts.push('');
+    }
+
+    // Guidance
+    if (failedTasks.length > 0) {
+      parts.push(
+        `Please continue from Step ${failedTasks[0].index + 1} and avoid repeating the successful steps.`,
+      );
+    }
+
+    return {
+      fallbackContext: parts.join('\n'),
+      completedTasks,
+      failedTasks,
+      pendingTasks,
+    };
+  }
+
   private notifyCurrentTaskStatusChange(taskIndex?: number) {
     const taskIndexToNotify =
       typeof taskIndex === 'number' ? taskIndex : this.currentTaskIndex;
diff --git a/packages/core/tests/unit-test/agent-cache-fallback.test.ts b/packages/core/tests/unit-test/agent-cache-fallback.test.ts
@@ -119,7 +119,12 @@ Please continue from Step 3 and avoid repeating the successful steps.`,
         { index: 1, name: 'Enter username' },
       ],
       failedTasksDetailed: [
-        { index: 2, name: 'Enter password', error: new Error('Element not found'), totalSteps: 1 },
+        {
+          index: 2,
+          name: 'Enter password',
+          error: new Error('Element not found'),
+          totalSteps: 1,
+        },
       ],
       pendingTasks: [],
     };
@@ -156,7 +161,9 @@ Please continue from Step 3 and avoid repeating the successful steps.`,
     const actionCall = (agent.taskExecutor.action as any).mock.calls[0];
     const contextParam = actionCall[4]; // 5th parameter is aiActContext
 
-    expect(contextParam).toContain('Previous cached workflow execution failed at step 3/3');
+    expect(contextParam).toContain(
+      'Previous cached workflow execution failed at step 3/3',
+    );
     expect(contextParam).toContain('Step 1/3:');
     expect(contextParam).toContain('Step 2/3:');
     expect(contextParam).toContain('Step 3/3:');
@@ -191,7 +198,9 @@ Please continue from Step 3 and avoid repeating the successful steps.`,
     const mockError = new Error('YAML execution failed');
     (mockError as any).executionContext = {
       successfulTasks: ['Click login'],
-      failedTasks: [{ name: 'Enter username', error: new Error('Field not found') }],
+      failedTasks: [
+        { name: 'Enter username', error: new Error('Field not found') },
+      ],
       totalTasks: 2,
       fallbackContext: `Previous cached workflow execution failed at step 2/2:
 
@@ -204,7 +213,14 @@ Failed:
 
 Please continue from Step 2 and avoid repeating the successful steps.`,
       completedTasks: [{ index: 0, name: 'Click login' }],
-      failedTasksDetailed: [{ index: 1, name: 'Enter username', error: new Error('Field not found'), totalSteps: 1 }],
+      failedTasksDetailed: [
+        {
+          index: 1,
+          name: 'Enter username',
+          error: new Error('Field not found'),
+          totalSteps: 1,
+        },
+      ],
       pendingTasks: [],
     };
 
@@ -236,7 +252,9 @@ Please continue from Step 2 and avoid repeating the successful steps.`,
 
     expect(contextParam).toContain('User is on login page');
     expect(contextParam).toContain('--- Cache Execution Failed ---');
-    expect(contextParam).toContain('Previous cached workflow execution failed at step 2/2');
+    expect(contextParam).toContain(
+      'Previous cached workflow execution failed at step 2/2',
+    );
     expect(contextParam).toContain('✓ Step 1/2: "Click login"');
     expect(contextParam).toContain('✗ Step 2/2: "Enter username"');
   });
