Harden cached replay against special and fallback throws

Co-authored-by: Shri Sukhani <shrisukhani@users.noreply.github.com>

Author: cursoragent

src/agent/shared/run-cached-action.test.ts

@@ -282,4 +282,70 @@ describe("runCachedStep", () => {
       })
     );
   });
+
+  it("returns failed task output when special action execution throws", async () => {
+    executeReplaySpecialAction.mockRejectedValue(new Error("navigation failed"));
+
+    const result = await runCachedStep({
+      page: createMockPage(),
+      instruction: "go to app",
+      cachedAction: {
+        actionType: "goToUrl",
+        arguments: ["https://example.com"],
+      },
+      tokenLimit: 8000,
+      llm: createMockLLM(),
+      mcpClient: undefined,
+      variables: [],
+    });
+
+    expect(result.status).toBe(TaskStatus.FAILED);
+    expect(result.output).toContain("Failed to execute cached special action");
+    expect(result.output).toContain("navigation failed");
+    expect(result.replayStepMeta).toEqual(
+      expect.objectContaining({
+        usedCachedAction: true,
+        fallbackUsed: false,
+        retries: 1,
+      })
+    );
+  });
+
+  it("returns failed output when perform fallback throws", async () => {
+    executeReplaySpecialAction.mockResolvedValue(null);
+    resolveXPathWithCDP.mockRejectedValue(new Error("xpath resolution failed"));
+    const performFallback = jest
+      .fn()
+      .mockRejectedValue(new Error("perform fallback crashed"));
+
+    const result = await runCachedStep({
+      page: createMockPage(),
+      instruction: "click login",
+      cachedAction: {
+        actionType: "actElement",
+        xpath: "//button[1]",
+        method: "click",
+        frameIndex: 0,
+        arguments: [],
+      },
+      maxSteps: 1,
+      tokenLimit: 8000,
+      llm: createMockLLM(),
+      mcpClient: undefined,
+      variables: [],
+      performFallback,
+    });
+
+    expect(result.status).toBe(TaskStatus.FAILED);
+    expect(result.output).toContain("Fallback perform failed");
+    expect(result.output).toContain("perform fallback crashed");
+    expect(result.replayStepMeta).toEqual(
+      expect.objectContaining({
+        usedCachedAction: true,
+        fallbackUsed: true,
+        retries: 1,
+        cachedXPath: "//button[1]",
+      })
+    );
+  });
 });

src/agent/shared/run-cached-action.ts

@@ -66,6 +66,22 @@ export async function runCachedStep(
       : undefined,
     page,
     retries: 1,
+  }).catch((error) => {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      taskId,
+      status: TaskStatus.FAILED,
+      steps: [],
+      output: `Failed to execute cached special action: ${message}`,
+      replayStepMeta: {
+        usedCachedAction: true,
+        fallbackUsed: false,
+        retries: 1,
+        cachedXPath: cachedAction.xpath ?? null,
+        fallbackXPath: null,
+        fallbackElementId: null,
+      },
+    } satisfies TaskOutput;
   });
   if (specialActionResult) {
     return specialActionResult;
@@ -138,7 +154,23 @@ export async function runCachedStep(
 
   // All cached attempts failed; optionally fall back to LLM perform
   if (params.performFallback) {
-    const fb = await params.performFallback(instruction);
+    const fb = await params.performFallback(instruction).catch((error) => {
+      const message = error instanceof Error ? error.message : String(error);
+      return {
+        taskId,
+        status: TaskStatus.FAILED,
+        steps: [],
+        output: `Fallback perform failed: ${message}`,
+        replayStepMeta: {
+          usedCachedAction: true,
+          fallbackUsed: true,
+          retries: maxSteps,
+          cachedXPath: cachedAction.xpath ?? null,
+          fallbackXPath: null,
+          fallbackElementId: null,
+        },
+      } satisfies TaskOutput;
+    });
     if (debug) {
       const cachedXPath = cachedAction.xpath || "N/A";
       const resolvedXPath = fb.replayStepMeta?.fallbackXPath || "N/A";