@tontoko/fast-playwright-mcp 0.1.1 → 0.1.2

package/lib/tools/evaluate.js

@@ -20,13 +20,14 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/tools/evaluate.ts
 import { z } from "zod";
 import { expectationSchema } from "../schemas/expectation.js";
+import { elementSelectorSchema } from "../types/selectors.js";
 import { quote } from "../utils/codegen.js";
 import { defineTabTool } from "./tool.js";
 import { generateLocator } from "./utils.js";
+var selectorsSchema = z.array(elementSelectorSchema).min(1).max(5).describe("Array of element selectors (max 5) supporting ref, role, CSS, or text-based selection");
 var evaluateSchema = z.object({
   function: z.string().describe("JS function: () => {...} or (element) => {...}"),
-  element: z.string().optional().describe("Human-readable element description used to obtain permission to interact with the element"),
-  ref: z.string().optional().describe('System-generated element ID from previous tool results (e.g., "rNODE-45-1"). Never use custom values.'),
+  selectors: selectorsSchema.optional().describe("Optional element selectors. If provided, function receives element as parameter"),
   expectation: expectationSchema.describe("Page state config. false for data extraction, true for DOM changes")
 });
 var evaluate = defineTabTool({
@@ -40,11 +41,14 @@ var evaluate = defineTabTool({
   },
   handle: async (tab, params, response) => {
     let locator;
-    if (params.ref && params.element) {
-      locator = await tab.refLocator({
-        ref: params.ref,
-        element: params.element
-      });
+    if (params.selectors && params.selectors.length > 0) {
+      const resolutionResults = await tab.resolveElementLocators(params.selectors);
+      const successfulResults = resolutionResults.filter((r) => r.locator && !r.error);
+      if (successfulResults.length === 0) {
+        const errors = resolutionResults.map((r) => r.error || "Unknown error").join(", ");
+        throw new Error(`Failed to resolve element selectors: ${errors}`);
+      }
+      locator = successfulResults[0].locator;
       response.addCode(`await page.${await generateLocator(locator)}.evaluate(${quote(params.function)});`);
     } else {
       response.addCode(`await page.evaluate(${quote(params.function)});`);

package/lib/tools/inspect-html.js

@@ -0,0 +1,238 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/inspect-html.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { htmlInspectionOptionsSchema } from "../types/html-inspection.js";
+import { HTMLInspector } from "../utilities/html-inspector.js";
+import { defineTabTool } from "./tool.js";
+var browserInspectHtmlSchema = htmlInspectionOptionsSchema.extend({
+  includeSuggestions: z.boolean().optional().default(false).describe("Include CSS selector suggestions in output"),
+  includeChildren: z.boolean().optional().default(true).describe("Include child elements in extraction"),
+  optimizeForLLM: z.boolean().optional().default(false).describe("Optimize extracted HTML for LLM consumption"),
+  expectation: expectationSchema.optional().describe("Page state config (minimal for HTML inspection)")
+});
+function formatConfiguration(params) {
+  let text = `**Configuration:**
+`;
+  text += `- selectors: ${params.selectors.length} selector(s)
+`;
+  text += `- depth: ${params.depth || 2}
+`;
+  text += `- format: ${params.format || "html"}
+`;
+  text += `- maxSize: ${params.maxSize || 50000} bytes
+`;
+  text += `- includeAttributes: ${params.includeAttributes !== false}
+`;
+  text += `- optimizeForLLM: ${params.optimizeForLLM}
+
+`;
+  return text;
+}
+function formatTiming(timing) {
+  let text = `**Timing:**
+`;
+  text += `- total: ${timing.totalMs}ms
+`;
+  text += `- selector resolution: ${timing.selectorResolutionMs}ms
+`;
+  text += `- extraction: ${timing.extractionMs}ms
+
+`;
+  return text;
+}
+function formatStatistics(stats, totalSizeBytes, truncated) {
+  let text = `**Statistics:**
+`;
+  text += `- elements found: ${stats.elementsFound}
+`;
+  text += `- selectors not found: ${stats.selectorsNotFound}
+`;
+  text += `- average depth: ${stats.averageDepth.toFixed(1)}
+`;
+  text += `- Total size: ${totalSizeBytes} bytes
+`;
+  text += `- truncated: ${truncated}
+
+`;
+  return text;
+}
+function formatElementInfo(index, element, includeChildren = false) {
+  let selectorInfo = "unknown";
+  if ("ref" in element.matchedSelector && element.matchedSelector.ref) {
+    selectorInfo = `ref=${element.matchedSelector.ref}`;
+  } else if ("css" in element.matchedSelector && element.matchedSelector.css) {
+    selectorInfo = element.matchedSelector.css;
+  } else if ("role" in element.matchedSelector && element.matchedSelector.role) {
+    selectorInfo = element.matchedSelector.role;
+  } else if ("text" in element.matchedSelector && element.matchedSelector.text) {
+    selectorInfo = element.matchedSelector.text;
+  }
+  let text = `### Element ${index} (${selectorInfo})
+`;
+  text += `**Tag:** ${element.metadata.tagName}
+`;
+  text += `**Size:** ${element.metadata.sizeBytes} bytes
+`;
+  if (element.error) {
+    text += `**Error:** ${element.error}
+
+`;
+    return text;
+  }
+  if (element.metadata.attributes && Object.keys(element.metadata.attributes).length > 0) {
+    text += `**Attributes:** ${JSON.stringify(element.metadata.attributes)}
+`;
+  }
+  text += "\n```html\n";
+  text += element.html;
+  text += "\n```\n\n";
+  if (includeChildren && element.children && element.children.length > 0) {
+    text += formatChildren(element.children);
+  }
+  return text;
+}
+function formatChildren(children) {
+  let text = `**Children (${children.length}):**
+`;
+  for (const child of children) {
+    text += `- <${child.metadata.tagName}`;
+    if (child.metadata.attributes?.id) {
+      text += ` id="${child.metadata.attributes.id}"`;
+    }
+    if (child.metadata.attributes?.class) {
+      text += ` class="${child.metadata.attributes.class}"`;
+    }
+    text += `> (${child.metadata.sizeBytes} bytes)
+`;
+  }
+  text += `
+`;
+  return text;
+}
+function formatFullResponse(params, result, suggestions) {
+  let text = `## HTML Inspection Results
+
+`;
+  text += formatConfiguration(params);
+  text += formatTiming(result.timing);
+  text += formatStatistics(result.stats, result.totalSizeBytes, result.truncated);
+  if (result.stats.elementsFound > 0) {
+    text += `**Extracted HTML Content:**
+
+`;
+    for (const [index, element] of Object.entries(result.elements)) {
+      text += formatElementInfo(index, element, params.includeChildren);
+    }
+  } else {
+    text += `**No elements found matching the provided selectors.**
+
+`;
+  }
+  if (params.includeSuggestions && suggestions.length > 0) {
+    text += `**CSS Selector Suggestions:**
+`;
+    const limitedSuggestions = suggestions.slice(0, 10);
+    for (const suggestion of limitedSuggestions) {
+      text += `- ${suggestion}
+`;
+    }
+    text += `
+`;
+  }
+  if (result.suggestions && result.suggestions.length > 0) {
+    text += `**Suggestions:**
+`;
+    for (const suggestion of result.suggestions) {
+      text += `- ${suggestion}
+`;
+    }
+    text += `
+`;
+  }
+  return text;
+}
+async function performInspection(inspector, params) {
+  const inspectionOptions = {
+    selectors: params.selectors,
+    depth: params.depth,
+    includeStyles: params.includeStyles,
+    maxSize: params.maxSize,
+    format: params.format,
+    includeAttributes: params.includeAttributes,
+    preserveWhitespace: params.preserveWhitespace,
+    excludeSelector: params.excludeSelector
+  };
+  const inspectionResult = await inspector.extractHTML(inspectionOptions);
+  const finalResult = params.optimizeForLLM ? await inspector.optimizeForLLM(inspectionResult) : inspectionResult;
+  let suggestions = [];
+  if (params.includeSuggestions) {
+    const cssSuggestions = inspector.suggestCSSSelectors(finalResult);
+    suggestions = cssSuggestions.map((s) => `${s.selector} (confidence: ${s.confidence}) - ${s.description}`);
+  }
+  return { result: finalResult, suggestions };
+}
+var browserInspectHtml = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_inspect_html",
+    title: "HTML inspection",
+    description: "Extract and analyze HTML content from web pages with intelligent filtering and size control. Optimized for LLM consumption with configurable depth, format options, and automatic truncation.",
+    inputSchema: browserInspectHtmlSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    try {
+      const inspector = new HTMLInspector(tab.page);
+      const { result: finalResult, suggestions } = await performInspection(inspector, params);
+      const responseText = formatFullResponse(params, finalResult, suggestions);
+      response.addResult(responseText);
+      response.addCode("// HTML inspection completed");
+      if (finalResult.stats.elementsFound > 0) {
+        response.addCode(`// Extracted ${finalResult.stats.elementsFound} element(s) in ${finalResult.timing.totalMs}ms`);
+      }
+      if (params.expectation?.includeSnapshot) {
+        const snapshot = await tab.captureSnapshot();
+        response.setTabSnapshot(snapshot);
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      response.addResult(`## HTML Inspection Error
+
+An error occurred during HTML inspection: ${errorMessage}
+
+**Troubleshooting:**
+- Verify that the page has loaded completely
+- Check that the provided selectors are valid CSS selectors or roles
+- Ensure the elements exist on the current page
+- Consider reducing the depth or size limits if the page is very large
+
+Use browser_snapshot to see the current page state.`);
+      response.addCode(`// HTML inspection failed: ${errorMessage}`);
+      throw error;
+    }
+  }
+});
+var inspect_html_default = [browserInspectHtml];
+export {
+  inspect_html_default as default,
+  browserInspectHtml
+};

package/lib/tools/keyboard.js

@@ -20,9 +20,13 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/tools/keyboard.ts
 import { z } from "zod";
 import { expectationSchema } from "../schemas/expectation.js";
+import { elementSelectorSchema } from "../types/selectors.js";
 import { quote } from "../utils/codegen.js";
 import { generateKeyPressCode } from "../utils/common-formatters.js";
-import { baseElementSchema as elementSchema } from "./base-tool-handler.js";
+import {
+  handleSnapshotExpectation,
+  resolveFirstElement
+} from "./shared-element-utils.js";
 import { defineTabTool } from "./tool.js";
 import { generateLocator } from "./utils.js";
 var pressKey = defineTabTool({
@@ -43,16 +47,13 @@ var pressKey = defineTabTool({
     await tab.waitForCompletion(async () => {
       await tab.page.keyboard.press(params.key);
     });
-    if (params.expectation?.includeSnapshot) {
-      const newSnapshot = await tab.captureSnapshot();
-      response.setTabSnapshot(newSnapshot);
-    }
+    await handleSnapshotExpectation(tab, params.expectation, response);
   }
 });
-var typeSchema = elementSchema.extend({
-  element: z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
-  ref: z.string().describe("System-generated element ID from previous tool results. Never use custom values."),
-  text: z.string(),
+var selectorsSchema = z.array(elementSelectorSchema).min(1).max(5).describe("Array of element selectors (max 5) supporting ref, role, CSS, or text-based selection");
+var typeSchema = z.object({
+  selectors: selectorsSchema,
+  text: z.string().describe("Text to type into the element"),
   submit: z.boolean().optional().describe("Press Enter after typing if true"),
   slowly: z.boolean().optional().describe("Type slowly for auto-complete if true"),
   expectation: expectationSchema.describe("Page state config. Use batch_execute for forms")
@@ -67,7 +68,7 @@ var type = defineTabTool({
     type: "destructive"
   },
   handle: async (tab, params, response) => {
-    const locator = await tab.refLocator(params);
+    const { locator } = await resolveFirstElement(tab, params.selectors);
     await tab.waitForCompletion(async () => {
       if (params.slowly) {
         response.addCode(`await page.${await generateLocator(locator)}.pressSequentially(${quote(params.text)});`);
@@ -81,10 +82,7 @@ var type = defineTabTool({
         await locator.press("Enter");
       }
     });
-    if (params.expectation?.includeSnapshot) {
-      const newSnapshot = await tab.captureSnapshot();
-      response.setTabSnapshot(newSnapshot);
-    }
+    await handleSnapshotExpectation(tab, params.expectation, response);
   }
 });
 var keyboard_default = [pressKey, type];

package/lib/tools/screenshot.js

@@ -20,23 +20,19 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/tools/screenshot.ts
 import { z } from "zod";
 import { expectationSchema } from "../schemas/expectation.js";
+import { elementSelectorSchema } from "../types/selectors.js";
 import { formatObject } from "../utils/codegen.js";
 import { defineTabTool } from "./tool.js";
 import { generateLocator } from "./utils.js";
+var selectorsSchema = z.array(elementSelectorSchema).min(1).max(5).describe("Array of element selectors (max 5) supporting ref, role, CSS, or text-based selection");
 var screenshotSchema = z.object({
   type: z.enum(["png", "jpeg"]).default("png").describe("Image format for the screenshot. Default is png."),
   filename: z.string().optional().describe("File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified."),
-  element: z.string().optional().describe("Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too."),
-  ref: z.string().optional().describe('System-generated element ID from previous tool results (e.g., "rNODE-45-1"). Never use custom values. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too.'),
+  selectors: selectorsSchema.optional().describe("Optional element selectors for element screenshots. If not provided, viewport screenshot will be taken."),
   fullPage: z.boolean().optional().describe("When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots."),
   expectation: expectationSchema.describe("Additional page state config")
 }).refine((data) => {
-  return !!data.element === !!data.ref;
-}, {
-  message: "Both element and ref must be provided or neither.",
-  path: ["ref", "element"]
-}).refine((data) => {
-  return !(data.fullPage && (data.element || data.ref));
+  return !(data.fullPage && data.selectors && data.selectors.length > 0);
 }, {
   message: "fullPage cannot be used with element screenshots.",
   path: ["fullPage"]
@@ -55,19 +51,25 @@ function createScreenshotOptions(fileType, fileName, fullPage) {
   };
 }
 function isElementScreenshotRequest(params) {
-  return !!(params.element && params.ref);
+  return !!(params.selectors && params.selectors.length > 0);
 }
 function getScreenshotTarget(params, isElementScreenshot) {
-  if (isElementScreenshot && params.element) {
-    return params.element;
+  if (isElementScreenshot) {
+    return "element";
   }
   return params.fullPage ? "full page" : "viewport";
 }
 async function getScreenshotLocator(tab, params, isElementScreenshot) {
-  if (!(isElementScreenshot && params.element && params.ref)) {
+  if (!(isElementScreenshot && params.selectors)) {
     return null;
   }
-  return await tab.refLocator({ element: params.element, ref: params.ref });
+  const resolutionResults = await tab.resolveElementLocators(params.selectors);
+  const successfulResults = resolutionResults.filter((r) => r.locator && !r.error);
+  if (successfulResults.length === 0) {
+    const errors = resolutionResults.map((r) => r.error || "Unknown error").join(", ");
+    throw new Error(`Failed to resolve element selectors for screenshot: ${errors}`);
+  }
+  return successfulResults[0].locator;
 }
 async function addScreenshotCode(response, locator, options) {
   if (locator) {

package/lib/tools/shared-element-utils.js

@@ -0,0 +1,60 @@
+import { createRequire } from "node:module";
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/tools/shared-element-utils.ts
+async function resolveFirstElement(tab, selectors, errorMessage = "Failed to resolve element selectors") {
+  const resolutionResults = await tab.resolveElementLocators(selectors);
+  const successfulResults = resolutionResults.filter((r) => r.locator && !r.error);
+  if (successfulResults.length === 0) {
+    const errors = resolutionResults.map((r) => r.error || "Unknown error").join(", ");
+    throw new Error(`${errorMessage}: ${errors}`);
+  }
+  return { locator: successfulResults[0].locator };
+}
+async function handleSnapshotExpectation(tab, expectation, response) {
+  if (expectation?.includeSnapshot) {
+    const newSnapshot = await tab.captureSnapshot();
+    response.setTabSnapshot(newSnapshot);
+  }
+}
+async function resolveDragElements(tab, startSelectors, endSelectors) {
+  const [startResults, endResults] = await Promise.all([
+    tab.resolveElementLocators(startSelectors),
+    tab.resolveElementLocators(endSelectors)
+  ]);
+  const startSuccessful = startResults.filter((r) => r.locator && !r.error);
+  const endSuccessful = endResults.filter((r) => r.locator && !r.error);
+  if (startSuccessful.length === 0) {
+    const errors = startResults.map((r) => r.error || "Unknown error").join(", ");
+    throw new Error(`Failed to resolve start element selectors: ${errors}`);
+  }
+  if (endSuccessful.length === 0) {
+    const errors = endResults.map((r) => r.error || "Unknown error").join(", ");
+    throw new Error(`Failed to resolve end element selectors: ${errors}`);
+  }
+  return {
+    startLocator: startSuccessful[0].locator,
+    endLocator: endSuccessful[0].locator
+  };
+}
+export {
+  resolveFirstElement,
+  resolveDragElements,
+  handleSnapshotExpectation
+};

package/lib/tools/snapshot.js

@@ -20,7 +20,13 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 // src/tools/snapshot.ts
 import { z } from "zod";
 import { expectationSchema } from "../schemas/expectation.js";
+import { elementSelectorSchema } from "../types/selectors.js";
 import { formatObject } from "../utils/codegen.js";
+import {
+  handleSnapshotExpectation,
+  resolveDragElements,
+  resolveFirstElement
+} from "./shared-element-utils.js";
 import { defineTabTool, defineTool } from "./tool.js";
 import { generateLocator } from "./utils.js";
 var snapshot = defineTool({
@@ -45,11 +51,9 @@ var snapshot = defineTool({
     }
   }
 });
-var elementSchema = z.object({
-  element: z.string().describe("Human-readable element description used to obtain permission to interact with the element"),
-  ref: z.string().describe("System-generated element ID from previous tool results. Never use custom values.")
-});
-var clickSchema = elementSchema.extend({
+var selectorsSchema = z.array(elementSelectorSchema).min(1).max(5).describe("Array of element selectors (max 5). Selectors are tried in order until one succeeds (fallback mechanism). " + "Multiple matches trigger an error with candidate list. " + "Supports: ref (highest priority), CSS (#id, .class, tag), role (button, textbox, etc.), text content. " + 'Example: [{css: "#submit"}, {role: "button", text: "Submit"}] - tries ID first, falls back to role+text');
+var clickSchema = z.object({
+  selectors: selectorsSchema,
   doubleClick: z.boolean().optional().describe("Double-click if true"),
   button: z.enum(["left", "right", "middle"]).optional().describe("Mouse button (default: left)"),
   expectation: expectationSchema.describe("Page state capture config. Use batch_execute for multi-clicks")
@@ -64,7 +68,7 @@ var click = defineTabTool({
     type: "destructive"
   },
   handle: async (tab, params, response) => {
-    const locator = await tab.refLocator(params);
+    const { locator } = await resolveFirstElement(tab, params.selectors, "Failed to resolve any element selectors");
     const button = params.button;
     const buttonAttr = button ? `{ button: '${button}' }` : "";
     if (params.doubleClick) {
@@ -79,10 +83,7 @@ var click = defineTabTool({
         await locator.click({ button });
       }
     });
-    if (params.expectation?.includeSnapshot) {
-      const newSnapshot = await tab.captureSnapshot();
-      response.setTabSnapshot(newSnapshot);
-    }
+    await handleSnapshotExpectation(tab, params.expectation, response);
   }
 });
 var drag = defineTabTool({
@@ -92,19 +93,14 @@ var drag = defineTabTool({
     title: "Drag mouse",
     description: "Perform drag and drop between two elements",
     inputSchema: z.object({
-      startElement: z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
-      startRef: z.string().describe("System-generated source element ID from previous tool results. Never use custom values."),
-      endElement: z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
-      endRef: z.string().describe("System-generated target element ID from previous tool results. Never use custom values."),
+      startSelectors: selectorsSchema.describe("Source element selectors for drag start"),
+      endSelectors: selectorsSchema.describe("Target element selectors for drag end"),
       expectation: expectationSchema.describe("Page state after drag. Use batch_execute for workflows")
     }),
     type: "destructive"
   },
   handle: async (tab, params, response) => {
-    const [startLocator, endLocator] = await tab.refLocators([
-      { ref: params.startRef, element: params.startElement },
-      { ref: params.endRef, element: params.endElement }
-    ]);
+    const { startLocator, endLocator } = await resolveDragElements(tab, params.startSelectors, params.endSelectors);
     await tab.waitForCompletion(async () => {
       await startLocator.dragTo(endLocator);
     });
@@ -117,20 +113,22 @@ var hover = defineTabTool({
     name: "browser_hover",
     title: "Hover mouse",
     description: "Hover over element on page",
-    inputSchema: elementSchema.extend({
+    inputSchema: z.object({
+      selectors: selectorsSchema,
       expectation: expectationSchema.describe("Page state after hover. Use batch_execute for hover→click")
     }),
     type: "readOnly"
   },
   handle: async (tab, params, response) => {
-    const locator = await tab.refLocator(params);
+    const { locator } = await resolveFirstElement(tab, params.selectors);
     response.addCode(`await page.${await generateLocator(locator)}.hover();`);
     await tab.waitForCompletion(async () => {
       await locator.hover();
     });
   }
 });
-var selectOptionSchema = elementSchema.extend({
+var selectOptionSchema = z.object({
+  selectors: selectorsSchema,
   values: z.array(z.string()).describe("Values to select (array)"),
   expectation: expectationSchema.describe("Page state after selection. Use batch_execute for forms")
 });
@@ -144,7 +142,7 @@ var selectOption = defineTabTool({
     type: "destructive"
   },
   handle: async (tab, params, response) => {
-    const locator = await tab.refLocator(params);
+    const { locator } = await resolveFirstElement(tab, params.selectors);
     response.addCode(`await page.${await generateLocator(locator)}.selectOption(${formatObject(params.values)});`);
     await tab.waitForCompletion(async () => {
       await locator.selectOption(params.values);
@@ -153,6 +151,6 @@ var selectOption = defineTabTool({
 });
 var snapshot_default = [snapshot, click, drag, hover, selectOption];
 export {
-  elementSchema,
+  selectorsSchema,
   snapshot_default as default
 };

package/lib/tools.js

@@ -26,6 +26,7 @@ import dialogs from "./tools/dialogs.js";
 import evaluate from "./tools/evaluate.js";
 import files from "./tools/files.js";
 import { browserFindElements } from "./tools/find-elements.js";
+import inspectHtml from "./tools/inspect-html.js";
 import install from "./tools/install.js";
 import keyboard from "./tools/keyboard.js";
 import mouse from "./tools/mouse.js";
@@ -43,6 +44,7 @@ var allTools = [
   ...evaluate,
   ...files,
   ...install,
+  ...inspectHtml,
   ...keyboard,
   ...navigate,
   ...network,

package/lib/types/batch.js

@@ -37,7 +37,7 @@ var batchStepSchema = z.object({
   expectation: expectationSchema.describe("Expected output configuration for this step")
 });
 var batchExecuteSchema = z.object({
-  steps: z.array(batchStepSchema).min(1).describe('Array of steps to execute in sequence. Recommended for form filling (multiple type→click), multi-step navigation, any workflow with 2+ known steps. Saves 90% tokens vs individual calls. Example: [{tool:"browser_navigate",arguments:{url:"https://example.com"}},{tool:"browser_type",arguments:{element:"username",ref:"#user",text:"john"}},{tool:"browser_click",arguments:{element:"submit",ref:"#btn"}}]'),
+  steps: z.array(batchStepSchema).min(1).describe('Array of steps to execute in sequence. Recommended for form filling (multiple type→click), multi-step navigation, any workflow with 2+ known steps. Saves 90% tokens vs individual calls. Example: [{tool:"browser_navigate",arguments:{url:"https://example.com"}},{tool:"browser_type",arguments:{selectors:[{css:"#user"}],text:"john"}},{tool:"browser_click",arguments:{selectors:[{css:"#btn"}]}}]'),
   stopOnFirstError: z.boolean().optional().default(false).describe("Stop entire batch on first error"),
   globalExpectation: z.preprocess(parseJsonString, expectationSchema).optional().describe('Default expectation for all steps. Recommended: {includeSnapshot:false,snapshotOptions:{selector:"#app"},diffOptions:{enabled:true}}. Per-step override with steps[].expectation')
 });