Expand replay special actions with load-state waits

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

Author: cursoragent

src/agent/shared/replay-special-actions.test.ts

@@ -26,6 +26,7 @@ function createPage(overrides?: Record<string, unknown>) {
     goto: jest.fn().mockResolvedValue(undefined),
     reload: jest.fn().mockResolvedValue(undefined),
     waitForTimeout: jest.fn().mockResolvedValue(undefined),
+    waitForLoadState: jest.fn().mockResolvedValue(undefined),
     ...overrides,
   };
 }
@@ -144,6 +145,43 @@ describe("executeReplaySpecialAction", () => {
     expect(result).toBeNull();
   });
 
+  it("replays waitForLoadState with timeout argument", async () => {
+    const page = createPage();
+
+    const result = await executeReplaySpecialAction({
+      taskId: "task-loadstate",
+      actionType: "waitForLoadState",
+      arguments: ["networkidle", 2500],
+      page: page as unknown as Page,
+    });
+
+    expect(page.waitForLoadState).toHaveBeenCalledWith("networkidle", {
+      timeout: 2500,
+    });
+    expect(markDomSnapshotDirty).toHaveBeenCalledWith(page);
+    expect(result?.status).toBe("completed");
+    expect(result?.output).toBe("Waited for load state: networkidle");
+  });
+
+  it("fails extract replay when extracted object cannot be serialized", async () => {
+    const circular: Record<string, unknown> = {};
+    circular.self = circular;
+    const extract = jest.fn().mockResolvedValue(circular);
+    const page = createPage({
+      extract,
+    });
+
+    const result = await executeReplaySpecialAction({
+      taskId: "task-circular-extract",
+      actionType: "extract",
+      instruction: "extract circular object",
+      page: page as unknown as Page,
+    });
+
+    expect(result?.status).toBe("failed");
+    expect(result?.output).toContain("could not serialize extracted output");
+  });
+
   it("honors explicit retry metadata value", async () => {
     const page = createPage();
 

src/agent/shared/replay-special-actions.ts

@@ -18,6 +18,7 @@ export const REPLAY_SPECIAL_ACTION_TYPES: ReadonlySet<string> = new Set([
   "complete",
   "refreshPage",
   "wait",
+  "waitForLoadState",
   "extract",
   "analyzePdf",
 ]);
@@ -55,6 +56,10 @@ function asNumber(value: unknown): number | undefined {
   return undefined;
 }
 
+function asFiniteNumber(value: unknown): number | undefined {
+  return typeof value === "number" && Number.isFinite(value) ? value : undefined;
+}
+
 function normalizeWaitMs(value: unknown): number {
   const parsed = asNumber(value);
   if (parsed === undefined) {
@@ -163,14 +168,28 @@ export async function executeReplaySpecialAction(
     }
     try {
       const extracted = await extractPage.extract(extractInstruction);
+      let serializedExtracted = "";
+      if (typeof extracted === "string") {
+        serializedExtracted = extracted;
+      } else {
+        try {
+          serializedExtracted = JSON.stringify(extracted);
+        } catch (error) {
+          const message = error instanceof Error ? error.message : String(error);
+          return {
+            taskId,
+            status: TaskStatus.FAILED,
+            steps: [],
+            output: `Extract failed: could not serialize extracted output (${message})`,
+            replayStepMeta: createReplayMeta(retries),
+          };
+        }
+      }
       return {
         taskId,
         status: TaskStatus.COMPLETED,
         steps: [],
-        output:
-          typeof extracted === "string"
-            ? extracted
-            : JSON.stringify(extracted),
+        output: serializedExtracted,
         replayStepMeta: createReplayMeta(retries),
       };
     } catch (error) {
@@ -195,5 +214,24 @@ export async function executeReplaySpecialAction(
     };
   }
 
+  if (actionType === "waitForLoadState") {
+    const waitUntil = asNonEmptyTrimmedString(actionArgs?.[0]) ?? "domcontentloaded";
+    const timeoutMs = asFiniteNumber(actionArgs?.[1]);
+    const options =
+      timeoutMs !== undefined ? { timeout: timeoutMs } : undefined;
+    await page.waitForLoadState(
+      waitUntil as "domcontentloaded" | "load" | "networkidle",
+      options
+    );
+    markDomSnapshotDirty(page);
+    return {
+      taskId,
+      status: TaskStatus.COMPLETED,
+      steps: [],
+      output: `Waited for load state: ${waitUntil}`,
+      replayStepMeta: createReplayMeta(retries),
+    };
+  }
+
   return null;
 }