@tontoko/fast-playwright-mcp 0.0.4

package/lib/tools/files.js

@@ -0,0 +1,53 @@
+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/files.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import { defineTabTool } from "./tool.js";
+var uploadFile = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_file_upload",
+    title: "Upload files",
+    description: `Upload one or multiple files to file input.paths:["/path/file1.jpg","/path/file2.pdf"] for multiple files.expectation:{includeSnapshot:true,snapshotOptions:{selector:"form"}} to verify upload.Must be triggered after file input interaction.USE batch_execute for click→upload workflows.`,
+    inputSchema: z.object({
+      paths: z.array(z.string()).describe("The absolute paths to the files to upload. Can be a single file or multiple files."),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const modalState = tab.modalStates().find((state) => state.type === "fileChooser");
+    if (!modalState) {
+      throw new Error("No file chooser visible");
+    }
+    response.addCode(`await fileChooser.setFiles(${JSON.stringify(params.paths)})`);
+    tab.clearModalState(modalState);
+    await tab.waitForCompletion(async () => {
+      await modalState.fileChooser.setFiles(params.paths);
+    });
+  },
+  clearsModalState: "fileChooser"
+});
+var files_default = [uploadFile];
+export {
+  files_default as default
+};

package/lib/tools/find-elements.js

@@ -0,0 +1,307 @@
+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/find-elements.ts
+import { z } from "zod";
+import { ElementDiscovery } from "../diagnostics/element-discovery.js";
+import { PageAnalyzer } from "../diagnostics/page-analyzer.js";
+import { ArrayBuilder } from "../utils/code-deduplication-utils.js";
+import { UnifiedDiagnosticSystem } from "../diagnostics/unified-system.js";
+import { expectationSchema } from "../schemas/expectation.js";
+import { getErrorMessage } from "../utils/common-formatters.js";
+import {
+  DiagnosticReportBuilder,
+  formatConfidencePercentage
+} from "../utils/report-builder.js";
+import { defineTabTool } from "./tool.js";
+var findElementsSchema = z.object({
+  searchCriteria: z.object({
+    text: z.string().optional().describe("Text content to search for"),
+    role: z.string().optional().describe("ARIA role to search for"),
+    tagName: z.string().optional().describe("HTML tag name to search for"),
+    attributes: z.record(z.string()).optional().describe("Attributes to match")
+  }).describe("Search criteria for finding elements"),
+  maxResults: z.number().optional().default(10).describe("Maximum number of results to return"),
+  includeDiagnosticInfo: z.boolean().optional().default(false).describe("Include diagnostic information about the page"),
+  useUnifiedSystem: z.boolean().optional().default(true).describe("Use unified diagnostic system for enhanced error handling"),
+  enableEnhancedDiscovery: z.boolean().optional().default(true).describe("Enable enhanced element discovery with contextual suggestions"),
+  performanceThreshold: z.number().optional().default(500).describe("Performance threshold in milliseconds for element discovery"),
+  expectation: expectationSchema.optional()
+}).describe("Find elements using multiple search criteria");
+var browserFindElements = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_find_elements",
+    title: "Find elements",
+    type: "readOnly",
+    description: "Find elements on the page using multiple search criteria such as text, role, tag name, or attributes. Returns matching elements sorted by confidence.",
+    inputSchema: findElementsSchema
+  },
+  handle: async (tab, params, response) => {
+    const context = new FindElementsContext(params);
+    contextInstance = context;
+    try {
+      const alternatives = await findElements(tab, context);
+      if (alternatives.length === 0) {
+        response.addResult("No elements found matching the specified criteria.");
+        return;
+      }
+      const resultsText = formatElementResults(alternatives);
+      await addDiagnosticInfoIfRequested(tab, context, resultsText);
+      addPerformanceInfoIfAvailable(context, resultsText);
+      response.addResult(resultsText.join(`
+`));
+    } catch (error) {
+      response.addError(`Error finding elements: ${getErrorMessage(error)}`);
+    } finally {
+      await cleanupResources();
+    }
+  }
+});
+
+class FindElementsContext {
+  unifiedSystem = null;
+  elementDiscovery = null;
+  operationResult;
+  params;
+  constructor(params) {
+    this.params = params;
+  }
+  get useUnifiedSystem() {
+    return this.params.useUnifiedSystem ?? true;
+  }
+  get enableEnhancedDiscovery() {
+    return this.params.enableEnhancedDiscovery ?? true;
+  }
+  get performanceThreshold() {
+    return this.params.performanceThreshold ?? 500;
+  }
+  get includeDiagnosticInfo() {
+    return this.params.includeDiagnosticInfo ?? false;
+  }
+  get searchCriteria() {
+    return this.params.searchCriteria;
+  }
+  get maxResults() {
+    return this.params.maxResults;
+  }
+}
+async function findElements(tab, context) {
+  if (context.useUnifiedSystem) {
+    return await findElementsWithUnifiedSystem(tab, context);
+  }
+  return await findElementsWithLegacySystem(tab, context);
+}
+async function findElementsWithUnifiedSystem(tab, context) {
+  const configOverrides = buildUnifiedSystemConfig(context);
+  context.unifiedSystem = UnifiedDiagnosticSystem.getInstance(tab.page, configOverrides);
+  const operationResult = await context.unifiedSystem.findAlternativeElements(context.searchCriteria);
+  context.operationResult = operationResult;
+  if (!operationResult.success) {
+    throw new Error(buildErrorMessage(operationResult.error));
+  }
+  return operationResult.data ?? [];
+}
+async function findElementsWithLegacySystem(tab, context) {
+  context.elementDiscovery = new ElementDiscovery(tab.page);
+  const legacyResults = await context.elementDiscovery.findAlternativeElements({
+    originalSelector: "",
+    searchCriteria: context.searchCriteria,
+    maxResults: context.maxResults
+  });
+  const alternatives = legacyResults.map((result) => ({
+    ref: result.selector,
+    element: result.selector,
+    description: `Element with selector ${result.selector}`,
+    confidence: result.confidence,
+    textContent: "",
+    attributes: {},
+    selector: result.selector
+  }));
+  context.operationResult = {
+    success: true,
+    data: alternatives,
+    executionTime: 0
+  };
+  return alternatives;
+}
+function buildUnifiedSystemConfig(context) {
+  return {
+    features: {
+      enableParallelAnalysis: true,
+      enableSmartHandleManagement: true,
+      enableAdvancedElementDiscovery: context.enableEnhancedDiscovery,
+      enableResourceLeakDetection: true,
+      enableRealTimeMonitoring: false
+    },
+    performance: {
+      enableMetricsCollection: true,
+      enableResourceMonitoring: true,
+      enablePerformanceWarnings: true,
+      autoOptimization: true,
+      thresholds: {
+        executionTime: {
+          elementDiscovery: context.performanceThreshold,
+          pageAnalysis: 1000,
+          resourceMonitoring: 200,
+          parallelAnalysis: 2000
+        },
+        memory: {
+          maxMemoryUsage: 100 * 1024 * 1024,
+          memoryLeakThreshold: 50 * 1024 * 1024,
+          gcTriggerThreshold: 80 * 1024 * 1024
+        },
+        performance: {
+          domElementLimit: 1e4,
+          maxDepthLimit: 50,
+          largeSubtreeThreshold: 1000
+        },
+        dom: {
+          totalElements: 1e4,
+          maxDepth: 50,
+          largeSubtrees: 10,
+          elementsWarning: 1500,
+          elementsDanger: 3000,
+          depthWarning: 15,
+          depthDanger: 20,
+          largeSubtreeThreshold: 500
+        },
+        interaction: {
+          clickableElements: 100,
+          formElements: 50,
+          clickableHigh: 100
+        },
+        layout: {
+          fixedElements: 10,
+          highZIndexElements: 5,
+          highZIndexThreshold: 1000,
+          excessiveZIndexThreshold: 9999
+        }
+      }
+    }
+  };
+}
+function buildErrorMessage(errorInfo) {
+  let errorMessage = `Element discovery failed: ${errorInfo?.message ?? "Unknown error"}`;
+  if (errorInfo?.suggestions && errorInfo.suggestions.length > 0) {
+    errorMessage += `
+
+Suggestions:`;
+    for (const suggestion of errorInfo.suggestions) {
+      errorMessage += `
+- ${suggestion}`;
+    }
+  }
+  return errorMessage;
+}
+function formatElementResults(alternatives) {
+  const builder = new DiagnosticReportBuilder;
+  builder.addLine(`Found ${alternatives.length} elements matching the criteria:`);
+  builder.addEmptyLine();
+  for (const [index, alt] of alternatives.entries()) {
+    builder.addLine(`${index + 1}. Selector: ${alt.selector}`);
+    builder.addLine(`   Confidence: ${formatConfidencePercentage(alt.confidence)}`);
+    builder.addLine(`   Reason: ${alt.reason ?? "No reason provided"}`);
+    if (index < alternatives.length - 1) {
+      builder.addEmptyLine();
+    }
+  }
+  return builder.getSections();
+}
+async function addDiagnosticInfoIfRequested(tab, context, resultsText) {
+  if (!context.includeDiagnosticInfo) {
+    return;
+  }
+  if (context.unifiedSystem) {
+    await addUnifiedDiagnosticInfo(context.unifiedSystem, resultsText);
+  } else {
+    await addLegacyDiagnosticInfo(tab, resultsText);
+  }
+}
+async function addUnifiedDiagnosticInfo(unifiedSystem, resultsText) {
+  const diagResult = await unifiedSystem.analyzePageStructure();
+  const builder = new DiagnosticReportBuilder;
+  if (diagResult.success) {
+    const diagnosticInfo = diagResult.data;
+    builder.addSection("Enhanced Diagnostic Information", (b) => {
+      b.addKeyValue("Analysis time", `${diagResult.executionTime ?? 0}ms`);
+      addStructuralDiagnosticInfo(diagnosticInfo, b.getSections());
+    });
+  } else {
+    builder.addSection("Diagnostic Information", (b) => {
+      b.addListItem(`Error getting diagnostic information: ${diagResult.error?.message ?? "Unknown error"}`);
+    });
+  }
+  resultsText.push("", ...builder.getSections());
+}
+function addStructuralDiagnosticInfo(diagnosticInfo, resultsText) {
+  if (diagnosticInfo?.structureAnalysis) {
+    addParallelAnalysisInfo(diagnosticInfo.structureAnalysis, resultsText);
+  } else {
+    addStandardAnalysisInfo(diagnosticInfo, resultsText);
+  }
+}
+function addParallelAnalysisInfo(structure, resultsText) {
+  const analysisInfo = new ArrayBuilder().add(`- Page has ${structure.iframes?.count ?? 0} iframes detected: ${structure.iframes?.detected}`).add(`- Total visible elements: ${structure.elements?.totalVisible ?? 0}`).add(`- Total interactable elements: ${structure.elements?.totalInteractable ?? 0}`).addIf(!!(structure.modalStates?.blockedBy && structure.modalStates.blockedBy.length > 0), `- Page blocked by: ${structure.modalStates?.blockedBy?.join(", ") ?? ""}`).build();
+  resultsText.push(...analysisInfo);
+}
+function addStandardAnalysisInfo(diagnosticInfo, resultsText) {
+  const analysisInfo = new ArrayBuilder().add(`- Page has ${diagnosticInfo?.iframes?.count ?? 0} iframes detected: ${diagnosticInfo?.iframes?.detected}`).add(`- Total visible elements: ${diagnosticInfo?.elements?.totalVisible ?? 0}`).add(`- Total interactable elements: ${diagnosticInfo?.elements?.totalInteractable ?? 0}`).addIf(!!(diagnosticInfo?.modalStates?.blockedBy && diagnosticInfo.modalStates.blockedBy.length > 0), `- Page blocked by: ${diagnosticInfo?.modalStates?.blockedBy?.join(", ") ?? ""}`).build();
+  resultsText.push(...analysisInfo);
+}
+async function addLegacyDiagnosticInfo(tab, resultsText) {
+  const pageAnalyzer = new PageAnalyzer(tab.page);
+  try {
+    const diagnosticInfo = await pageAnalyzer.analyzePageStructure();
+    resultsText.push("", "### Diagnostic Information");
+    resultsText.push(`- Page has ${diagnosticInfo.iframes.count} iframes detected: ${diagnosticInfo.iframes.detected}`);
+    resultsText.push(`- Total visible elements: ${diagnosticInfo.elements.totalVisible}`);
+    resultsText.push(`- Total interactable elements: ${diagnosticInfo.elements.totalInteractable}`);
+    if (diagnosticInfo.modalStates.blockedBy.length > 0) {
+      resultsText.push(`- Page blocked by: ${diagnosticInfo.modalStates.blockedBy.join(", ")}`);
+    }
+  } finally {
+    await pageAnalyzer.dispose();
+  }
+}
+function addPerformanceInfoIfAvailable(context, resultsText) {
+  if (!(context.useUnifiedSystem && context.operationResult && context.enableEnhancedDiscovery)) {
+    return;
+  }
+  const builder = new DiagnosticReportBuilder;
+  builder.addSection("Enhanced Discovery Information", (b) => {
+    b.addKeyValue("Discovery execution time", `${context.operationResult?.executionTime ?? 0}ms`);
+    if (context.operationResult?.executionTime && context.operationResult?.executionTime > context.performanceThreshold) {
+      b.addListItem(`⚠️ Discovery exceeded performance threshold (${context.performanceThreshold}ms)`);
+    } else {
+      b.addListItem("✅ Discovery within performance threshold");
+    }
+  });
+  resultsText.push("", ...builder.getSections());
+}
+var contextInstance = null;
+async function cleanupResources() {
+  if (contextInstance?.elementDiscovery) {
+    await contextInstance.elementDiscovery.dispose();
+  }
+  contextInstance = null;
+}
+export {
+  browserFindElements
+};

package/lib/tools/install.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/install.ts
+import { fork } from "node:child_process";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { z } from "zod";
+import { defineTool } from "./tool.js";
+var install = defineTool({
+  capability: "core-install",
+  schema: {
+    name: "browser_install",
+    title: "Install the browser specified in the config",
+    description: "Install the browser specified in the config. Call this if you get an error about the browser not being installed.",
+    inputSchema: z.object({}),
+    type: "destructive"
+  },
+  handle: async (context, _params, response) => {
+    const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.browserName ?? "chrome";
+    const cliUrl = import.meta.resolve("playwright/package.json");
+    const cliPath = path.join(fileURLToPath(cliUrl), "..", "cli.js");
+    const child = fork(cliPath, ["install", channel], {
+      stdio: "pipe"
+    });
+    const output = [];
+    child.stdout?.on("data", (data) => output.push(data.toString()));
+    child.stderr?.on("data", (data) => output.push(data.toString()));
+    await new Promise((resolve, reject) => {
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve();
+        } else {
+          reject(new Error(`Failed to install browser: ${output.join("")}`));
+        }
+      });
+    });
+    response.setIncludeTabs();
+  }
+});
+var install_default = [install];
+export {
+  install_default as default
+};

package/lib/tools/keyboard.js

@@ -0,0 +1,93 @@
+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/keyboard.ts
+import { z } from "zod";
+import { quote } from "../javascript.js";
+import { expectationSchema } from "../schemas/expectation.js";
+import { generateKeyPressCode } from "../utils/common-formatters.js";
+import { baseElementSchema as elementSchema } from "./base-tool-handler.js";
+import { defineTabTool } from "./tool.js";
+import { generateLocator } from "./utils.js";
+var pressKey = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_press_key",
+    title: "Press a key",
+    description: "Press a key on the keyboard.Common keys:Enter,Escape,ArrowUp/Down/Left/Right,Tab,Backspace.expectation:{includeSnapshot:false} for navigation keys,true for content changes.CONSIDER batch_execute for multiple key presses.",
+    inputSchema: z.object({
+      key: z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`"),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`// Press ${params.key}`);
+    response.addCode(generateKeyPressCode(params.key));
+    await tab.waitForCompletion(async () => {
+      await tab.page.keyboard.press(params.key);
+    });
+    if (params.expectation?.includeSnapshot) {
+      const newSnapshot = await tab.captureSnapshot();
+      response.setTabSnapshot(newSnapshot);
+    }
+  }
+});
+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("Exact target element reference from the page snapshot"),
+  text: z.string().describe("Text to type into the element"),
+  submit: z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
+  slowly: z.boolean().optional().describe("Whether type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once."),
+  expectation: expectationSchema
+});
+var type = defineTabTool({
+  capability: "core",
+  schema: {
+    name: "browser_type",
+    title: "Type text",
+    description: `Type text into editable element.FOR FORMS:Use batch_execute to fill multiple fields efficiently.slowly:true for auto-complete fields,submit:true to press Enter after.expectation:{includeSnapshot:false} when filling multiple fields(use batch),true for final verification.snapshotOptions:{selector:"form"} to focus on form only.diffOptions:{enabled:true} shows only what changed in form.`,
+    inputSchema: typeSchema,
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    const locator = await tab.refLocator(params);
+    await tab.waitForCompletion(async () => {
+      if (params.slowly) {
+        response.addCode(`await page.${await generateLocator(locator)}.pressSequentially(${quote(params.text)});`);
+        await locator.pressSequentially(params.text);
+      } else {
+        response.addCode(`await page.${await generateLocator(locator)}.fill(${quote(params.text)});`);
+        await locator.fill(params.text);
+      }
+      if (params.submit) {
+        response.addCode(`await page.${await generateLocator(locator)}.press('Enter');`);
+        await locator.press("Enter");
+      }
+    });
+    if (params.expectation?.includeSnapshot) {
+      const newSnapshot = await tab.captureSnapshot();
+      response.setTabSnapshot(newSnapshot);
+    }
+  }
+});
+var keyboard_default = [pressKey, type];
+export {
+  keyboard_default as default
+};

package/lib/tools/mouse.js

@@ -0,0 +1,110 @@
+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/mouse.ts
+import { z } from "zod";
+import { expectationSchema } from "../schemas/expectation.js";
+import {
+  generateMouseClickCode,
+  generateMouseDragCode,
+  generateMouseMoveCode
+} from "../utils/common-formatters.js";
+import { baseElementSchema } from "./base-tool-handler.js";
+import { defineTabTool } from "./tool.js";
+var elementSchema = baseElementSchema.pick({ element: true }).required({ element: true });
+var mouseMove = defineTabTool({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_move_xy",
+    title: "Move mouse",
+    description: "Move mouse to specific coordinates.Requires --caps=vision.x,y:coordinates.expectation:{includeSnapshot:false} for simple move,true to see hover effects.PREFER element-based interactions over coordinates when possible.",
+    inputSchema: elementSchema.extend({
+      x: z.number().describe("X coordinate"),
+      y: z.number().describe("Y coordinate"),
+      expectation: expectationSchema
+    }),
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`// Move mouse to (${params.x}, ${params.y})`);
+    response.addCode(generateMouseMoveCode(params.x, params.y));
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.x, params.y);
+    });
+  }
+});
+var mouseClick = defineTabTool({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_click_xy",
+    title: "Click",
+    description: "Click at specific coordinates.Requires --caps=vision.x,y:click position.expectation:{includeSnapshot:true} to verify result.PREFER browser_click with element ref over coordinates.USE batch_execute for coordinate-based workflows.",
+    inputSchema: elementSchema.extend({
+      x: z.number().describe("X coordinate"),
+      y: z.number().describe("Y coordinate"),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    response.addCode(`// Click mouse at coordinates (${params.x}, ${params.y})`);
+    response.addCode(generateMouseMoveCode(params.x, params.y));
+    for (const code of generateMouseClickCode()) {
+      response.addCode(code);
+    }
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.x, params.y);
+      await tab.page.mouse.down();
+      await tab.page.mouse.up();
+    });
+  }
+});
+var mouseDrag = defineTabTool({
+  capability: "vision",
+  schema: {
+    name: "browser_mouse_drag_xy",
+    title: "Drag mouse",
+    description: `Drag from one coordinate to another.Requires --caps=vision.startX,startY→endX,endY.expectation:{includeSnapshot:true,snapshotOptions:{selector:".drop-zone"}} to verify.PREFER browser_drag with element refs over coordinates.`,
+    inputSchema: elementSchema.extend({
+      startX: z.number().describe("Start X coordinate"),
+      startY: z.number().describe("Start Y coordinate"),
+      endX: z.number().describe("End X coordinate"),
+      endY: z.number().describe("End Y coordinate"),
+      expectation: expectationSchema
+    }),
+    type: "destructive"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    for (const code of generateMouseDragCode(params.startX, params.startY, params.endX, params.endY)) {
+      response.addCode(code);
+    }
+    await tab.waitForCompletion(async () => {
+      await tab.page.mouse.move(params.startX, params.startY);
+      await tab.page.mouse.down();
+      await tab.page.mouse.move(params.endX, params.endY);
+      await tab.page.mouse.up();
+    });
+  }
+});
+var mouse_default = [mouseMove, mouseClick, mouseDrag];
+export {
+  mouse_default as default
+};