[chore] rm old performPlaywrightMethod (#875)

# why
- it is not good practice to maintain two separate implementations of
the same function
# what changed
- removed a duplicate implementation of `performPlaywrightMethod` which
was being used by the `observe_simple_google_search` eval
- replaced the function call with a call to `page.act(ObserveResult)`
which targets the implementation of `performPlaywrightMethod` that is
actually being used (and is therefore the implementation that we should
be testing
# test plan
- `regression` evals
- `observe` evals

Author: seanmcguire12

evals/tasks/observe_simple_google_search.ts

@@ -1,5 +1,4 @@
 import { EvalFunction } from "@/types/evals";
-import { performPlaywrightMethod } from "@/lib/a11y/utils";
 
 export const observe_simple_google_search: EvalFunction = async ({
   debugUrl,
@@ -18,27 +17,15 @@ export const observe_simple_google_search: EvalFunction = async ({
 
     if (observation1.length > 0) {
       const action1 = observation1[0];
-      await performPlaywrightMethod(
-        stagehand.page,
-        stagehand.logger,
-        action1.method,
-        action1.arguments,
-        action1.selector.replace("xpath=", ""),
-      );
+      await stagehand.page.act(action1);
     }
     const observation2 = await stagehand.page.observe({
       instruction: "Click the search button in the suggestions dropdown",
     });
 
     if (observation2.length > 0) {
       const action2 = observation2[0];
-      await performPlaywrightMethod(
-        stagehand.page,
-        stagehand.logger,
-        action2.method,
-        action2.arguments,
-        action2.selector.replace("xpath=", ""),
-      );
+      await stagehand.page.act(action2);
     }
 
     const expectedUrl =

lib/a11y/utils.ts

@@ -14,11 +14,6 @@ import {
 } from "../../types/context";
 import { StagehandPage } from "../StagehandPage";
 import { LogLine } from "../../types/log";
-import { Page, Locator } from "playwright";
-import {
-  PlaywrightCommandMethodNotSupportedException,
-  PlaywrightCommandException,
-} from "@/types/playwright";
 import {
   ContentFrameNotFoundError,
   StagehandDomProcessError,
@@ -1210,315 +1205,3 @@ export async function resolveFrameChain(
     }
   }
 }
-
-export async function performPlaywrightMethod(
-  stagehandPage: Page,
-  logger: (logLine: LogLine) => void,
-  method: string,
-  args: unknown[],
-  xpath: string,
-) {
-  const locator = stagehandPage.locator(`xpath=${xpath}`).first();
-  const initialUrl = stagehandPage.url();
-
-  logger({
-    category: "action",
-    message: "performing playwright method",
-    level: 2,
-    auxiliary: {
-      xpath: {
-        value: xpath,
-        type: "string",
-      },
-      method: {
-        value: method,
-        type: "string",
-      },
-    },
-  });
-
-  if (method === "scrollIntoView") {
-    logger({
-      category: "action",
-      message: "scrolling element into view",
-      level: 2,
-      auxiliary: {
-        xpath: {
-          value: xpath,
-          type: "string",
-        },
-      },
-    });
-    try {
-      await locator
-        .evaluate((element: HTMLElement) => {
-          element.scrollIntoView({ behavior: "smooth", block: "center" });
-        })
-        .catch((e: Error) => {
-          logger({
-            category: "action",
-            message: "error scrolling element into view",
-            level: 1,
-            auxiliary: {
-              error: {
-                value: e.message,
-                type: "string",
-              },
-              trace: {
-                value: e.stack,
-                type: "string",
-              },
-              xpath: {
-                value: xpath,
-                type: "string",
-              },
-            },
-          });
-        });
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error scrolling element into view",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-  } else if (method === "fill" || method === "type") {
-    try {
-      await locator.fill("");
-      await locator.click();
-      const text = args[0]?.toString();
-      for (const char of text) {
-        await stagehandPage.keyboard.type(char, {
-          delay: Math.random() * 50 + 25,
-        });
-      }
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error filling element",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-  } else if (method === "press") {
-    try {
-      const key = args[0]?.toString();
-      await stagehandPage.keyboard.press(key);
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error pressing key",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          key: {
-            value: args[0]?.toString() ?? "unknown",
-            type: "string",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-  } else if (typeof locator[method as keyof typeof locator] === "function") {
-    // Log current URL before action
-    logger({
-      category: "action",
-      message: "page URL before action",
-      level: 2,
-      auxiliary: {
-        url: {
-          value: stagehandPage.url(),
-          type: "string",
-        },
-      },
-    });
-
-    // Perform the action
-    try {
-      await (
-        locator[method as keyof Locator] as unknown as (
-          ...args: string[]
-        ) => Promise<void>
-      )(...args.map((arg) => arg?.toString() || ""));
-    } catch (e) {
-      logger({
-        category: "action",
-        message: "error performing method",
-        level: 1,
-        auxiliary: {
-          error: {
-            value: e.message,
-            type: "string",
-          },
-          trace: {
-            value: e.stack,
-            type: "string",
-          },
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-          method: {
-            value: method,
-            type: "string",
-          },
-          args: {
-            value: JSON.stringify(args),
-            type: "object",
-          },
-        },
-      });
-
-      throw new PlaywrightCommandException(e.message);
-    }
-
-    // Handle navigation if a new page is opened
-    if (method === "click") {
-      logger({
-        category: "action",
-        message: "clicking element, checking for page navigation",
-        level: 1,
-        auxiliary: {
-          xpath: {
-            value: xpath,
-            type: "string",
-          },
-        },
-      });
-
-      const newOpenedTab = await Promise.race([
-        new Promise<Page | null>((resolve) => {
-          Promise.resolve(stagehandPage.context()).then((context) => {
-            context.once("page", (page: Page) => resolve(page));
-            setTimeout(() => resolve(null), 1_500);
-          });
-        }),
-      ]);
-
-      logger({
-        category: "action",
-        message: "clicked element",
-        level: 1,
-        auxiliary: {
-          newOpenedTab: {
-            value: newOpenedTab ? "opened a new tab" : "no new tabs opened",
-            type: "string",
-          },
-        },
-      });
-
-      if (newOpenedTab) {
-        logger({
-          category: "action",
-          message: "new page detected (new tab) with URL",
-          level: 1,
-          auxiliary: {
-            url: {
-              value: newOpenedTab.url(),
-              type: "string",
-            },
-          },
-        });
-        await newOpenedTab.close();
-        await stagehandPage.goto(newOpenedTab.url());
-        await stagehandPage.waitForLoadState("domcontentloaded");
-      }
-
-      await Promise.race([
-        stagehandPage.waitForLoadState("networkidle"),
-        new Promise((resolve) => setTimeout(resolve, 5_000)),
-      ]).catch((e) => {
-        logger({
-          category: "action",
-          message: "network idle timeout hit",
-          level: 1,
-          auxiliary: {
-            trace: {
-              value: e.stack,
-              type: "string",
-            },
-            message: {
-              value: e.message,
-              type: "string",
-            },
-          },
-        });
-      });
-
-      logger({
-        category: "action",
-        message: "finished waiting for (possible) page navigation",
-        level: 1,
-      });
-
-      if (stagehandPage.url() !== initialUrl) {
-        logger({
-          category: "action",
-          message: "new page detected with URL",
-          level: 1,
-          auxiliary: {
-            url: {
-              value: stagehandPage.url(),
-              type: "string",
-            },
-          },
-        });
-      }
-    }
-  } else {
-    logger({
-      category: "action",
-      message: "chosen method is invalid",
-      level: 1,
-      auxiliary: {
-        method: {
-          value: method,
-          type: "string",
-        },
-      },
-    });
-
-    throw new PlaywrightCommandMethodNotSupportedException(
-      `Method ${method} not supported`,
-    );
-  }
-}