@one2x/playwright 1.57.0-alpha.10 → 1.57.0-alpha.11

package/lib/mcp/browser/browserServerBackend.js

@@ -59,7 +59,8 @@ class BrowserServerBackend {
       await response.finish();
       this._sessionLog?.logResponse(response);
     } catch (error) {
-      response.addError(String(error));
+      console.error("error", error);
+      response.addError(String(error.stack));
     } finally {
       context.setRunningTool(void 0);
     }

package/lib/mcp/browser/tools/actionRetry.js

@@ -21,7 +21,7 @@ __export(actionRetry_exports, {
   retryWithAllowIntercept: () => retryWithAllowIntercept
 });
 module.exports = __toCommonJS(actionRetry_exports);
-async function retryWithAllowIntercept(action, options, mode = "never") {
+async function retryWithAllowIntercept(action, options, mode = "auto") {
   if (mode === "always") {
     const optionsWithAllowIntercept = { ...options, allowIntercept: true };
     await action(optionsWithAllowIntercept);
@@ -40,9 +40,16 @@ async function retryWithAllowIntercept(action, options, mode = "never") {
       }
       if (mode === "never") {
         const enhancedError = new Error(
-          `InterceptionError: Element is covered by an intercepting element: ${interceptorInfo}.
-\u{1F4A1} To allow the action on the intercepting element, retry with \`allowIntercept: "always"\`
-\u{1F4A1} To automatically retry when intercepted, use \`allowIntercept: "auto"\``
+          `RETRYABLE ERROR: Element is covered by an overlay/modal.
+
+SOLUTION: Retry this tool call with allowIntercept option added:
+  Add parameter: allowIntercept: "always"
+
+This will click through the overlay to reach the target element.
+
+Alternative: Use allowIntercept: "auto" to automatically retry on interception.
+
+Technical details - Intercepting element: ${interceptorInfo}`
         );
         enhancedError.stack = error.stack;
         throw enhancedError;

package/lib/mcp/browser/tools/form.js

@@ -48,16 +48,12 @@ const fillForm = (0, import_tool.defineTabTool)({
         type: import_bundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
         ref: import_bundle.z.string().describe("Exact target field reference from the page snapshot"),
         value: import_bundle.z.string().describe("Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.")
-      })).describe("Fields to fill in"),
-      allowIntercept: import_bundle.z.enum(["never", "auto", "always"]).default("never").describe(
-        'How to handle element interception for checkbox/radio fields: "never" (default) - fail if element is intercepted; "auto" - automatically retry with allowIntercept if intercepted; "always" - use allowIntercept from the start'
-      )
+      })).describe("Fields to fill in")
     }),
     type: "input"
   },
   handle: async (tab, params, response) => {
     response.setIncludeSnapshot();
-    const mode = params.allowIntercept;
     for (const field of params.fields) {
       const { locator, resolved } = await tab.refLocator({ element: field.name, ref: field.ref });
       const locatorSource = `await page.${resolved}`;
@@ -68,12 +64,11 @@ const fillForm = (0, import_tool.defineTabTool)({
       } else if (field.type === "checkbox" || field.type === "radio") {
         const result = await (0, import_actionRetry.retryWithAllowIntercept)(
           async (opts) => await locator.setChecked(field.value === "true", opts),
-          {},
-          mode
+          {}
         );
         if (result.mode === "auto" && result.interceptorInfo)
           (0, import_utils.addInterceptorWarning)(response, resolved, ".setChecked(value, { allowIntercept: true })", result.interceptorInfo);
-        const needsAllowIntercept = result.mode === "auto" || result.mode === "always";
+        const needsAllowIntercept = result.mode === "auto" && result.interceptorInfo || result.mode === "always";
         const optionsAttr = needsAllowIntercept ? ", { allowIntercept: true }" : "";
         response.addCode(`${locatorSource}.setChecked(${field.value}${optionsAttr});`);
       } else if (field.type === "combobox") {

package/lib/mcp/browser/tools/snapshot.js

@@ -58,10 +58,7 @@ const elementSchema = import_bundle.z.object({
 const clickSchema = elementSchema.extend({
   doubleClick: import_bundle.z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
   button: import_bundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
-  modifiers: import_bundle.z.array(import_bundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press"),
-  allowIntercept: import_bundle.z.enum(["never", "auto", "always"]).default("never").describe(
-    'How to handle element interception: "never" (default) - fail if element is intercepted; "auto" - automatically retry with allowIntercept if intercepted; "always" - use allowIntercept from the start'
-  )
+  modifiers: import_bundle.z.array(import_bundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
 });
 const click = (0, import_tool.defineTabTool)({
   capability: "core",
@@ -75,7 +72,6 @@ const click = (0, import_tool.defineTabTool)({
   handle: async (tab, params, response) => {
     response.setIncludeSnapshot();
     const { locator, resolved } = await tab.refLocator(params);
-    const mode = params.allowIntercept;
     const options = {
       button: params.button,
       modifiers: params.modifiers
@@ -89,15 +85,17 @@ const click = (0, import_tool.defineTabTool)({
           else
             await locator.click(opts);
         },
-        options,
-        mode
+        options
       );
     });
+    if (!result) {
+      return;
+    }
     if (result.mode === "auto" && result.interceptorInfo) {
       const actionName = params.doubleClick ? ".dblclick({ allowIntercept: true })" : ".click({ allowIntercept: true })";
       (0, import_utils.addInterceptorWarning)(response, resolved, actionName, result.interceptorInfo);
     }
-    const needsAllowIntercept = result.mode === "auto" || result.mode === "always";
+    const needsAllowIntercept = result.mode === "auto" && result.interceptorInfo || result.mode === "always";
     const finalOptions = needsAllowIntercept ? { ...options, allowIntercept: true } : options;
     const formatted = javascript.formatObject(finalOptions, " ", "oneline");
     const optionsAttr = formatted !== "{}" ? formatted : "";
@@ -118,10 +116,7 @@ const drag = (0, import_tool.defineTabTool)({
       startElement: import_bundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
       startRef: import_bundle.z.string().describe("Exact source element reference from the page snapshot"),
       endElement: import_bundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
-      endRef: import_bundle.z.string().describe("Exact target element reference from the page snapshot"),
-      allowIntercept: import_bundle.z.enum(["never", "auto", "always"]).default("never").describe(
-        'How to handle element interception: "never" (default) - fail if element is intercepted; "auto" - automatically retry with allowIntercept if intercepted; "always" - use allowIntercept from the start'
-      )
+      endRef: import_bundle.z.string().describe("Exact target element reference from the page snapshot")
     }),
     type: "input"
   },
@@ -131,18 +126,19 @@ const drag = (0, import_tool.defineTabTool)({
       { ref: params.startRef, element: params.startElement },
       { ref: params.endRef, element: params.endElement }
     ]);
-    const mode = params.allowIntercept;
     let result;
     await tab.waitForCompletion(async () => {
       result = await (0, import_actionRetry.retryWithAllowIntercept)(
         async (opts) => await start.locator.dragTo(end.locator, opts),
-        {},
-        mode
+        {}
       );
     });
+    if (!result) {
+      return;
+    }
     if (result.mode === "auto" && result.interceptorInfo)
       (0, import_utils.addInterceptorWarning)(response, start.resolved, ".dragTo(target, { allowIntercept: true })", result.interceptorInfo);
-    const needsAllowIntercept = result.mode === "auto" || result.mode === "always";
+    const needsAllowIntercept = result.mode === "auto" && result.interceptorInfo || result.mode === "always";
     const optionsAttr = needsAllowIntercept ? ", { allowIntercept: true }" : "";
     response.addCode(`await page.${start.resolved}.dragTo(page.${end.resolved}${optionsAttr});`);
     response.setIncludeAutoScreenshot();
@@ -154,28 +150,25 @@ const hover = (0, import_tool.defineTabTool)({
     name: "browser_hover",
     title: "Hover mouse",
     description: "Hover over element on page",
-    inputSchema: elementSchema.extend({
-      allowIntercept: import_bundle.z.enum(["never", "auto", "always"]).default("never").describe(
-        'How to handle element interception: "never" (default) - fail if element is intercepted; "auto" - automatically retry with allowIntercept if intercepted; "always" - use allowIntercept from the start'
-      )
-    }),
+    inputSchema: elementSchema,
     type: "input"
   },
   handle: async (tab, params, response) => {
     response.setIncludeSnapshot();
     const { locator, resolved } = await tab.refLocator(params);
-    const mode = params.allowIntercept;
     let result;
     await tab.waitForCompletion(async () => {
       result = await (0, import_actionRetry.retryWithAllowIntercept)(
         async (opts) => await locator.hover(opts),
-        {},
-        mode
+        {}
       );
     });
+    if (!result) {
+      return;
+    }
     if (result.mode === "auto" && result.interceptorInfo)
       (0, import_utils.addInterceptorWarning)(response, resolved, ".hover({ allowIntercept: true })", result.interceptorInfo);
-    const needsAllowIntercept = result.mode === "auto" || result.mode === "always";
+    const needsAllowIntercept = result.mode === "auto" && result.interceptorInfo || result.mode === "always";
     const optionsAttr = needsAllowIntercept ? "{ allowIntercept: true }" : "";
     response.addCode(`await page.${resolved}.hover(${optionsAttr});`);
     response.setIncludeAutoScreenshot();

package/lib/mcp/browser/tools/utils.js

@@ -85,10 +85,10 @@ async function generateLocators(locator) {
   return selectors.map((s) => (0, import_utils.asLocator)("javascript", s));
 }
 function addInterceptorWarning(response, targetSelector, actionName, interceptorInfo) {
-  response.addResult(`\u26A0\uFE0F  Warning: An intercepting element appears above target element \`page.${targetSelector}\``);
+  response.addResult(`  Warning: An intercepting element was appearing above target element \`page.${targetSelector}\``);
+  response.addResult(`  \`${actionName}\` WAS fired to the intercepting element, not the target element`);
   if (interceptorInfo)
-    response.addResult(`   Intercepting element: ${interceptorInfo}`);
-  response.addResult(`\u2713  Retried action \`${actionName}\` and succeeded. The \`allowIntercept\` option is CRUCIAL`);
+    response.addResult(`  Intercepting element: ${interceptorInfo}`);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@one2x/playwright",
-  "version": "1.57.0-alpha.10",
+  "version": "1.57.0-alpha.11",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -65,7 +65,7 @@
   "license": "Apache-2.0",
   "dependencies": {
     "content-type": "^1.0.5",
-    "playwright-core": "npm:@one2x/playwright-core@1.57.0-alpha.10",
+    "playwright-core": "npm:@one2x/playwright-core@1.57.0-alpha.11",
     "raw-body": "^2.5.2"
   },
   "optionalDependencies": {