@playwright/mcp 0.0.14 → 0.0.15

package/lib/context.js

@@ -131,7 +131,7 @@ class Context {
     }
     async run(tool, params) {
         // Tab management is done outside of the action() call.
-        const toolResult = await tool.handle(this, params);
+        const toolResult = await tool.handle(this, tool.schema.inputSchema.parse(params));
         const { code, action, waitForNetwork, captureSnapshot, resultOverride } = toolResult;
         const racingAction = action ? () => this._raceAgainstModalDialogs(action) : undefined;
         if (resultOverride)
@@ -298,6 +298,7 @@ class Tab {
     context;
     page;
     _console = [];
+    _requests = new Map();
     _snapshot;
     _onPageClose;
     constructor(context, page, onPageClose) {
@@ -305,9 +306,11 @@ class Tab {
         this.page = page;
         this._onPageClose = onPageClose;
         page.on('console', event => this._console.push(event));
+        page.on('request', request => this._requests.set(request, null));
+        page.on('response', response => this._requests.set(response.request(), response));
         page.on('framenavigated', frame => {
             if (!frame.parentFrame())
-                this._console.length = 0;
+                this._clearCollectedArtifacts();
         });
         page.on('close', () => this._onClose());
         page.on('filechooser', chooser => {
@@ -321,8 +324,12 @@ class Tab {
         page.setDefaultNavigationTimeout(60000);
         page.setDefaultTimeout(5000);
     }
-    _onClose() {
+    _clearCollectedArtifacts() {
         this._console.length = 0;
+        this._requests.clear();
+    }
+    _onClose() {
+        this._clearCollectedArtifacts();
         this._onPageClose(this);
     }
     async navigate(url) {
@@ -338,9 +345,12 @@ class Tab {
             throw new Error('No snapshot available');
         return this._snapshot;
     }
-    async console() {
+    console() {
         return this._console;
     }
+    requests() {
+        return this._requests;
+    }
     async captureSnapshot() {
         this._snapshot = await PageSnapshot.create(this.page);
     }
@@ -370,7 +380,7 @@ class PageSnapshot {
     }
     async _snapshotFrame(frame) {
         const frameIndex = this._frameLocators.push(frame) - 1;
-        const snapshotString = await frame.locator('body').ariaSnapshot({ ref: true });
+        const snapshotString = await frame.locator('body').ariaSnapshot({ ref: true, emitGeneric: true });
         const snapshot = yaml_1.default.parseDocument(snapshotString);
         const visit = async (node) => {
             if (yaml_1.default.isPair(node)) {

package/lib/index.js

@@ -30,6 +30,7 @@ const files_1 = __importDefault(require("./tools/files"));
 const install_1 = __importDefault(require("./tools/install"));
 const keyboard_1 = __importDefault(require("./tools/keyboard"));
 const navigate_1 = __importDefault(require("./tools/navigate"));
+const network_1 = __importDefault(require("./tools/network"));
 const pdf_1 = __importDefault(require("./tools/pdf"));
 const snapshot_1 = __importDefault(require("./tools/snapshot"));
 const tabs_1 = __importDefault(require("./tools/tabs"));
@@ -42,6 +43,7 @@ const snapshotTools = [
     ...install_1.default,
     ...(0, keyboard_1.default)(true),
     ...(0, navigate_1.default)(true),
+    ...network_1.default,
     ...pdf_1.default,
     ...snapshot_1.default,
     ...(0, tabs_1.default)(true),
@@ -54,6 +56,7 @@ const screenshotTools = [
     ...install_1.default,
     ...(0, keyboard_1.default)(false),
     ...(0, navigate_1.default)(false),
+    ...network_1.default,
     ...pdf_1.default,
     ...screen_1.default,
     ...(0, tabs_1.default)(false),

package/lib/server.js

@@ -19,6 +19,7 @@ exports.ServerList = void 0;
 exports.createServerWithTools = createServerWithTools;
 const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
 const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
+const zod_to_json_schema_1 = require("zod-to-json-schema");
 const context_1 = require("./context");
 function createServerWithTools(options) {
     const { name, version, tools, resources } = options;
@@ -30,7 +31,13 @@ function createServerWithTools(options) {
         }
     });
     server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
-        return { tools: tools.map(tool => tool.schema) };
+        return {
+            tools: tools.map(tool => ({
+                name: tool.schema.name,
+                description: tool.schema.description,
+                inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(tool.schema.inputSchema)
+            })),
+        };
     });
     server.setRequestHandler(types_js_1.ListResourcesRequestSchema, async () => {
         return { resources: resources.map(resource => resource.schema) };

package/lib/tools/common.js

@@ -16,34 +16,31 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const waitSchema = zod_1.z.object({
-    time: zod_1.z.number().describe('The time to wait in seconds'),
-});
-const wait = captureSnapshot => ({
+const tool_1 = require("./tool");
+const wait = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'wait',
     schema: {
         name: 'browser_wait',
         description: 'Wait for a specified time in seconds',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(waitSchema),
+        inputSchema: zod_1.z.object({
+            time: zod_1.z.number().describe('The time to wait in seconds'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = waitSchema.parse(params);
-        await new Promise(f => setTimeout(f, Math.min(10000, validatedParams.time * 1000)));
+        await new Promise(f => setTimeout(f, Math.min(10000, params.time * 1000)));
         return {
-            code: [`// Waited for ${validatedParams.time} seconds`],
+            code: [`// Waited for ${params.time} seconds`],
             captureSnapshot,
             waitForNetwork: false,
         };
     },
 });
-const closeSchema = zod_1.z.object({});
-const close = {
+const close = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_close',
         description: 'Close the page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(closeSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         await context.close();
@@ -53,27 +50,25 @@ const close = {
             waitForNetwork: false,
         };
     },
-};
-const resizeSchema = zod_1.z.object({
-    width: zod_1.z.number().describe('Width of the browser window'),
-    height: zod_1.z.number().describe('Height of the browser window'),
 });
-const resize = captureSnapshot => ({
+const resize = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_resize',
         description: 'Resize the browser window',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(resizeSchema),
+        inputSchema: zod_1.z.object({
+            width: zod_1.z.number().describe('Width of the browser window'),
+            height: zod_1.z.number().describe('Height of the browser window'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = resizeSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Resize browser window to ${validatedParams.width}x${validatedParams.height}`,
-            `await page.setViewportSize({ width: ${validatedParams.width}, height: ${validatedParams.height} });`
+            `// Resize browser window to ${params.width}x${params.height}`,
+            `await page.setViewportSize({ width: ${params.width}, height: ${params.height} });`
         ];
         const action = async () => {
-            await tab.page.setViewportSize({ width: validatedParams.width, height: validatedParams.height });
+            await tab.page.setViewportSize({ width: params.width, height: params.height });
         };
         return {
             code,

package/lib/tools/console.js

@@ -16,17 +16,16 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const consoleSchema = zod_1.z.object({});
-const console = {
+const tool_1 = require("./tool");
+const console = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_console_messages',
         description: 'Returns all console messages',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(consoleSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
-        const messages = await context.currentTabOrDie().console();
+        const messages = context.currentTabOrDie().console();
         const log = messages.map(message => `[${message.type().toUpperCase()}] ${message.text()}`).join('\n');
         return {
             code: [`// <internal code to get console messages>`],
@@ -39,7 +38,7 @@ const console = {
             waitForNetwork: false,
         };
     },
-};
+});
 exports.default = [
     console,
 ];

package/lib/tools/dialogs.js

@@ -16,25 +16,23 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const handleDialogSchema = zod_1.z.object({
-    accept: zod_1.z.boolean().describe('Whether to accept the dialog.'),
-    promptText: zod_1.z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
-});
-const handleDialog = captureSnapshot => ({
+const tool_1 = require("./tool");
+const handleDialog = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_handle_dialog',
         description: 'Handle a dialog',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(handleDialogSchema),
+        inputSchema: zod_1.z.object({
+            accept: zod_1.z.boolean().describe('Whether to accept the dialog.'),
+            promptText: zod_1.z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = handleDialogSchema.parse(params);
         const dialogState = context.modalStates().find(state => state.type === 'dialog');
         if (!dialogState)
             throw new Error('No dialog visible');
-        if (validatedParams.accept)
-            await dialogState.dialog.accept(validatedParams.promptText);
+        if (params.accept)
+            await dialogState.dialog.accept(params.promptText);
         else
             await dialogState.dialog.dismiss();
         context.clearModalState(dialogState);

package/lib/tools/files.js

@@ -16,27 +16,25 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const uploadFileSchema = zod_1.z.object({
-    paths: zod_1.z.array(zod_1.z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
-});
-const uploadFile = captureSnapshot => ({
+const tool_1 = require("./tool");
+const uploadFile = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'files',
     schema: {
         name: 'browser_file_upload',
         description: 'Upload one or multiple files',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(uploadFileSchema),
+        inputSchema: zod_1.z.object({
+            paths: zod_1.z.array(zod_1.z.string()).describe('The absolute paths to the files to upload. Can be a single file or multiple files.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = uploadFileSchema.parse(params);
         const modalState = context.modalStates().find(state => state.type === 'fileChooser');
         if (!modalState)
             throw new Error('No file chooser visible');
         const code = [
-            `// <internal code to chose files ${validatedParams.paths.join(', ')}`,
+            `// <internal code to chose files ${params.paths.join(', ')}`,
         ];
         const action = async () => {
-            await modalState.fileChooser.setFiles(validatedParams.paths);
+            await modalState.fileChooser.setFiles(params.paths);
             context.clearModalState(modalState);
         };
         return {

package/lib/tools/install.js

@@ -21,13 +21,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const child_process_1 = require("child_process");
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const install = {
+const tool_1 = require("./tool");
+const install = (0, tool_1.defineTool)({
     capability: 'install',
     schema: {
         name: 'browser_install',
         description: 'Install the browser specified in the config. Call this if you get an error about the browser not being installed.',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const channel = context.options.launchOptions?.channel ?? context.options.browserName ?? 'chrome';
@@ -52,7 +52,7 @@ const install = {
             waitForNetwork: false,
         };
     },
-};
+});
 exports.default = [
     install,
 ];

package/lib/tools/keyboard.js

@@ -14,30 +14,25 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
-const pressKeySchema = zod_1.z.object({
-    key: zod_1.z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
-});
-const pressKey = captureSnapshot => ({
+const tool_1 = require("./tool");
+const pressKey = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_press_key',
         description: 'Press a key on the keyboard',
-        inputSchema: (0, zod_to_json_schema_1.default)(pressKeySchema),
+        inputSchema: zod_1.z.object({
+            key: zod_1.z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = pressKeySchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Press ${validatedParams.key}`,
-            `await page.keyboard.press('${validatedParams.key}');`,
+            `// Press ${params.key}`,
+            `await page.keyboard.press('${params.key}');`,
         ];
-        const action = () => tab.page.keyboard.press(validatedParams.key);
+        const action = () => tab.page.keyboard.press(params.key);
         return {
             code,
             action,

package/lib/tools/navigate.js

@@ -16,24 +16,22 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const navigateSchema = zod_1.z.object({
-    url: zod_1.z.string().describe('The URL to navigate to'),
-});
-const navigate = captureSnapshot => ({
+const tool_1 = require("./tool");
+const navigate = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_navigate',
         description: 'Navigate to a URL',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(navigateSchema),
+        inputSchema: zod_1.z.object({
+            url: zod_1.z.string().describe('The URL to navigate to'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = navigateSchema.parse(params);
         const tab = await context.ensureTab();
-        await tab.navigate(validatedParams.url);
+        await tab.navigate(params.url);
         const code = [
-            `// Navigate to ${validatedParams.url}`,
-            `await page.goto('${validatedParams.url}');`,
+            `// Navigate to ${params.url}`,
+            `await page.goto('${params.url}');`,
         ];
         return {
             code,
@@ -42,13 +40,12 @@ const navigate = captureSnapshot => ({
         };
     },
 });
-const goBackSchema = zod_1.z.object({});
-const goBack = captureSnapshot => ({
+const goBack = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'history',
     schema: {
         name: 'browser_navigate_back',
         description: 'Go back to the previous page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(goBackSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const tab = await context.ensureTab();
@@ -64,13 +61,12 @@ const goBack = captureSnapshot => ({
         };
     },
 });
-const goForwardSchema = zod_1.z.object({});
-const goForward = captureSnapshot => ({
+const goForward = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'history',
     schema: {
         name: 'browser_navigate_forward',
         description: 'Go forward to the next page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(goForwardSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const tab = context.currentTabOrDie();

package/lib/tools/network.js

@@ -0,0 +1,51 @@
+"use strict";
+/**
+ * Copyright (c) Microsoft Corporation.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const zod_1 = require("zod");
+const tool_1 = require("./tool");
+const requests = (0, tool_1.defineTool)({
+    capability: 'core',
+    schema: {
+        name: 'browser_network_requests',
+        description: 'Returns all network requests since loading the page',
+        inputSchema: zod_1.z.object({}),
+    },
+    handle: async (context) => {
+        const requests = context.currentTabOrDie().requests();
+        const log = [...requests.entries()].map(([request, response]) => renderRequest(request, response)).join('\n');
+        return {
+            code: [`// <internal code to list network requests>`],
+            action: async () => {
+                return {
+                    content: [{ type: 'text', text: log }]
+                };
+            },
+            captureSnapshot: false,
+            waitForNetwork: false,
+        };
+    },
+});
+function renderRequest(request, response) {
+    const result = [];
+    result.push(`[${request.method().toUpperCase()}] ${request.url()}`);
+    if (response)
+        result.push(`=> [${response.status()}] ${response.statusText()}`);
+    return result.join(' ');
+}
+exports.default = [
+    requests,
+];

package/lib/tools/pdf.js

@@ -54,16 +54,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const os_1 = __importDefault(require("os"));
 const path_1 = __importDefault(require("path"));
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const tool_1 = require("./tool");
 const utils_1 = require("./utils");
 const javascript = __importStar(require("../javascript"));
-const pdfSchema = zod_1.z.object({});
-const pdf = {
+const pdf = (0, tool_1.defineTool)({
     capability: 'pdf',
     schema: {
         name: 'browser_pdf_save',
         description: 'Save page as PDF',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(pdfSchema),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const tab = context.currentTabOrDie();
@@ -79,7 +78,7 @@ const pdf = {
             waitForNetwork: false,
         };
     },
-};
+});
 exports.default = [
     pdf,
 ];

package/lib/tools/screen.js

@@ -49,14 +49,17 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
+const tool_1 = require("./tool");
 const javascript = __importStar(require("../javascript"));
-const screenshot = {
+const elementSchema = zod_1.z.object({
+    element: zod_1.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
+});
+const screenshot = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_capture',
         description: 'Take a screenshot of the current page',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         const tab = await context.ensureTab();
@@ -77,29 +80,24 @@ const screenshot = {
             waitForNetwork: false
         };
     },
-};
-const elementSchema = zod_1.z.object({
-    element: zod_1.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
-});
-const moveMouseSchema = elementSchema.extend({
-    x: zod_1.z.number().describe('X coordinate'),
-    y: zod_1.z.number().describe('Y coordinate'),
 });
-const moveMouse = {
+const moveMouse = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_move_mouse',
         description: 'Move mouse to a given position',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(moveMouseSchema),
+        inputSchema: elementSchema.extend({
+            x: zod_1.z.number().describe('X coordinate'),
+            y: zod_1.z.number().describe('Y coordinate'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = moveMouseSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Move mouse to (${validatedParams.x}, ${validatedParams.y})`,
-            `await page.mouse.move(${validatedParams.x}, ${validatedParams.y});`,
+            `// Move mouse to (${params.x}, ${params.y})`,
+            `await page.mouse.move(${params.x}, ${params.y});`,
         ];
-        const action = () => tab.page.mouse.move(validatedParams.x, validatedParams.y);
+        const action = () => tab.page.mouse.move(params.x, params.y);
         return {
             code,
             action,
@@ -107,29 +105,27 @@ const moveMouse = {
             waitForNetwork: false
         };
     },
-};
-const clickSchema = elementSchema.extend({
-    x: zod_1.z.number().describe('X coordinate'),
-    y: zod_1.z.number().describe('Y coordinate'),
 });
-const click = {
+const click = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_click',
         description: 'Click left mouse button',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(clickSchema),
+        inputSchema: elementSchema.extend({
+            x: zod_1.z.number().describe('X coordinate'),
+            y: zod_1.z.number().describe('Y coordinate'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = clickSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Click mouse at coordinates (${validatedParams.x}, ${validatedParams.y})`,
-            `await page.mouse.move(${validatedParams.x}, ${validatedParams.y});`,
+            `// Click mouse at coordinates (${params.x}, ${params.y})`,
+            `await page.mouse.move(${params.x}, ${params.y});`,
             `await page.mouse.down();`,
             `await page.mouse.up();`,
         ];
         const action = async () => {
-            await tab.page.mouse.move(validatedParams.x, validatedParams.y);
+            await tab.page.mouse.move(params.x, params.y);
             await tab.page.mouse.down();
             await tab.page.mouse.up();
         };
@@ -140,34 +136,32 @@ const click = {
             waitForNetwork: true,
         };
     },
-};
-const dragSchema = elementSchema.extend({
-    startX: zod_1.z.number().describe('Start X coordinate'),
-    startY: zod_1.z.number().describe('Start Y coordinate'),
-    endX: zod_1.z.number().describe('End X coordinate'),
-    endY: zod_1.z.number().describe('End Y coordinate'),
 });
-const drag = {
+const drag = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_drag',
         description: 'Drag left mouse button',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(dragSchema),
+        inputSchema: elementSchema.extend({
+            startX: zod_1.z.number().describe('Start X coordinate'),
+            startY: zod_1.z.number().describe('Start Y coordinate'),
+            endX: zod_1.z.number().describe('End X coordinate'),
+            endY: zod_1.z.number().describe('End Y coordinate'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = dragSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Drag mouse from (${validatedParams.startX}, ${validatedParams.startY}) to (${validatedParams.endX}, ${validatedParams.endY})`,
-            `await page.mouse.move(${validatedParams.startX}, ${validatedParams.startY});`,
+            `// Drag mouse from (${params.startX}, ${params.startY}) to (${params.endX}, ${params.endY})`,
+            `await page.mouse.move(${params.startX}, ${params.startY});`,
             `await page.mouse.down();`,
-            `await page.mouse.move(${validatedParams.endX}, ${validatedParams.endY});`,
+            `await page.mouse.move(${params.endX}, ${params.endY});`,
             `await page.mouse.up();`,
         ];
         const action = async () => {
-            await tab.page.mouse.move(validatedParams.startX, validatedParams.startY);
+            await tab.page.mouse.move(params.startX, params.startY);
             await tab.page.mouse.down();
-            await tab.page.mouse.move(validatedParams.endX, validatedParams.endY);
+            await tab.page.mouse.move(params.endX, params.endY);
             await tab.page.mouse.up();
         };
         return {
@@ -177,31 +171,29 @@ const drag = {
             waitForNetwork: true,
         };
     },
-};
-const typeSchema = zod_1.z.object({
-    text: zod_1.z.string().describe('Text to type into the element'),
-    submit: zod_1.z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
 });
-const type = {
+const type = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_screen_type',
         description: 'Type text',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(typeSchema),
+        inputSchema: zod_1.z.object({
+            text: zod_1.z.string().describe('Text to type into the element'),
+            submit: zod_1.z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = typeSchema.parse(params);
         const tab = context.currentTabOrDie();
         const code = [
-            `// Type ${validatedParams.text}`,
-            `await page.keyboard.type('${validatedParams.text}');`,
+            `// Type ${params.text}`,
+            `await page.keyboard.type('${params.text}');`,
         ];
         const action = async () => {
-            await tab.page.keyboard.type(validatedParams.text);
-            if (validatedParams.submit)
+            await tab.page.keyboard.type(params.text);
+            if (params.submit)
                 await tab.page.keyboard.press('Enter');
         };
-        if (validatedParams.submit) {
+        if (params.submit) {
             code.push(`// Submit text`);
             code.push(`await page.keyboard.press('Enter');`);
         }
@@ -212,7 +204,7 @@ const type = {
             waitForNetwork: true,
         };
     },
-};
+});
 exports.default = [
     screenshot,
     moveMouse,

package/lib/tools/snapshot.js

@@ -54,16 +54,16 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = __importDefault(require("path"));
 const os_1 = __importDefault(require("os"));
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = __importDefault(require("zod-to-json-schema"));
 const utils_1 = require("./utils");
 const context_1 = require("../context");
 const javascript = __importStar(require("../javascript"));
-const snapshot = {
+const tool_1 = require("./tool");
+const snapshot = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_snapshot',
         description: 'Capture accessibility snapshot of the current page, this is better than screenshot',
-        inputSchema: (0, zod_to_json_schema_1.default)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         await context.ensureTab();
@@ -73,24 +73,23 @@ const snapshot = {
             waitForNetwork: false,
         };
     },
-};
+});
 const elementSchema = zod_1.z.object({
     element: zod_1.z.string().describe('Human-readable element description used to obtain permission to interact with the element'),
     ref: zod_1.z.string().describe('Exact target element reference from the page snapshot'),
 });
-const click = {
+const click = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_click',
         description: 'Perform click on a web page',
-        inputSchema: (0, zod_to_json_schema_1.default)(elementSchema),
+        inputSchema: elementSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = elementSchema.parse(params);
         const tab = context.currentTabOrDie();
-        const locator = tab.snapshotOrDie().refLocator(validatedParams.ref);
+        const locator = tab.snapshotOrDie().refLocator(params.ref);
         const code = [
-            `// Click ${validatedParams.element}`,
+            `// Click ${params.element}`,
             `await page.${await (0, context_1.generateLocator)(locator)}.click();`
         ];
         return {
@@ -100,27 +99,25 @@ const click = {
             waitForNetwork: true,
         };
     },
-};
-const dragSchema = zod_1.z.object({
-    startElement: zod_1.z.string().describe('Human-readable source element description used to obtain the permission to interact with the element'),
-    startRef: zod_1.z.string().describe('Exact source element reference from the page snapshot'),
-    endElement: zod_1.z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
-    endRef: zod_1.z.string().describe('Exact target element reference from the page snapshot'),
 });
-const drag = {
+const drag = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_drag',
         description: 'Perform drag and drop between two elements',
-        inputSchema: (0, zod_to_json_schema_1.default)(dragSchema),
+        inputSchema: zod_1.z.object({
+            startElement: zod_1.z.string().describe('Human-readable source element description used to obtain the permission to interact with the element'),
+            startRef: zod_1.z.string().describe('Exact source element reference from the page snapshot'),
+            endElement: zod_1.z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
+            endRef: zod_1.z.string().describe('Exact target element reference from the page snapshot'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = dragSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const startLocator = snapshot.refLocator(validatedParams.startRef);
-        const endLocator = snapshot.refLocator(validatedParams.endRef);
+        const startLocator = snapshot.refLocator(params.startRef);
+        const endLocator = snapshot.refLocator(params.endRef);
         const code = [
-            `// Drag ${validatedParams.startElement} to ${validatedParams.endElement}`,
+            `// Drag ${params.startElement} to ${params.endElement}`,
             `await page.${await (0, context_1.generateLocator)(startLocator)}.dragTo(page.${await (0, context_1.generateLocator)(endLocator)});`
         ];
         return {
@@ -130,20 +127,19 @@ const drag = {
             waitForNetwork: true,
         };
     },
-};
-const hover = {
+});
+const hover = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_hover',
         description: 'Hover over element on page',
-        inputSchema: (0, zod_to_json_schema_1.default)(elementSchema),
+        inputSchema: elementSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = elementSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const locator = snapshot.refLocator(validatedParams.ref);
+        const locator = snapshot.refLocator(params.ref);
         const code = [
-            `// Hover over ${validatedParams.element}`,
+            `// Hover over ${params.element}`,
             `await page.${await (0, context_1.generateLocator)(locator)}.hover();`
         ];
         return {
@@ -153,36 +149,35 @@ const hover = {
             waitForNetwork: true,
         };
     },
-};
+});
 const typeSchema = elementSchema.extend({
     text: zod_1.z.string().describe('Text to type into the element'),
     submit: zod_1.z.boolean().optional().describe('Whether to submit entered text (press Enter after)'),
     slowly: zod_1.z.boolean().optional().describe('Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.'),
 });
-const type = {
+const type = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_type',
         description: 'Type text into editable element',
-        inputSchema: (0, zod_to_json_schema_1.default)(typeSchema),
+        inputSchema: typeSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = typeSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const locator = snapshot.refLocator(validatedParams.ref);
+        const locator = snapshot.refLocator(params.ref);
         const code = [];
         const steps = [];
-        if (validatedParams.slowly) {
-            code.push(`// Press "${validatedParams.text}" sequentially into "${validatedParams.element}"`);
-            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.pressSequentially(${javascript.quote(validatedParams.text)});`);
-            steps.push(() => locator.pressSequentially(validatedParams.text));
+        if (params.slowly) {
+            code.push(`// Press "${params.text}" sequentially into "${params.element}"`);
+            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.pressSequentially(${javascript.quote(params.text)});`);
+            steps.push(() => locator.pressSequentially(params.text));
         }
         else {
-            code.push(`// Fill "${validatedParams.text}" into "${validatedParams.element}"`);
-            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.fill(${javascript.quote(validatedParams.text)});`);
-            steps.push(() => locator.fill(validatedParams.text));
+            code.push(`// Fill "${params.text}" into "${params.element}"`);
+            code.push(`await page.${await (0, context_1.generateLocator)(locator)}.fill(${javascript.quote(params.text)});`);
+            steps.push(() => locator.fill(params.text));
         }
-        if (validatedParams.submit) {
+        if (params.submit) {
             code.push(`// Submit text`);
             code.push(`await page.${await (0, context_1.generateLocator)(locator)}.press('Enter');`);
             steps.push(() => locator.press('Enter'));
@@ -194,33 +189,32 @@ const type = {
             waitForNetwork: true,
         };
     },
-};
+});
 const selectOptionSchema = elementSchema.extend({
     values: zod_1.z.array(zod_1.z.string()).describe('Array of values to select in the dropdown. This can be a single value or multiple values.'),
 });
-const selectOption = {
+const selectOption = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_select_option',
         description: 'Select an option in a dropdown',
-        inputSchema: (0, zod_to_json_schema_1.default)(selectOptionSchema),
+        inputSchema: selectOptionSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = selectOptionSchema.parse(params);
         const snapshot = context.currentTabOrDie().snapshotOrDie();
-        const locator = snapshot.refLocator(validatedParams.ref);
+        const locator = snapshot.refLocator(params.ref);
         const code = [
-            `// Select options [${validatedParams.values.join(', ')}] in ${validatedParams.element}`,
-            `await page.${await (0, context_1.generateLocator)(locator)}.selectOption(${javascript.formatObject(validatedParams.values)});`
+            `// Select options [${params.values.join(', ')}] in ${params.element}`,
+            `await page.${await (0, context_1.generateLocator)(locator)}.selectOption(${javascript.formatObject(params.values)});`
         ];
         return {
             code,
-            action: () => locator.selectOption(validatedParams.values).then(() => { }),
+            action: () => locator.selectOption(params.values).then(() => { }),
             captureSnapshot: true,
             waitForNetwork: true,
         };
     },
-};
+});
 const screenshotSchema = zod_1.z.object({
     raw: zod_1.z.boolean().optional().describe('Whether to return without compression (in PNG format). Default is false, which returns a JPEG image.'),
     element: zod_1.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.'),
@@ -231,25 +225,24 @@ const screenshotSchema = zod_1.z.object({
     message: 'Both element and ref must be provided or neither.',
     path: ['ref', 'element']
 });
-const screenshot = {
+const screenshot = (0, tool_1.defineTool)({
     capability: 'core',
     schema: {
         name: 'browser_take_screenshot',
         description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
-        inputSchema: (0, zod_to_json_schema_1.default)(screenshotSchema),
+        inputSchema: screenshotSchema,
     },
     handle: async (context, params) => {
-        const validatedParams = screenshotSchema.parse(params);
         const tab = context.currentTabOrDie();
         const snapshot = tab.snapshotOrDie();
-        const fileType = validatedParams.raw ? 'png' : 'jpeg';
+        const fileType = params.raw ? 'png' : 'jpeg';
         const fileName = path_1.default.join(os_1.default.tmpdir(), (0, utils_1.sanitizeForFilePath)(`page-${new Date().toISOString()}`)) + `.${fileType}`;
         const options = { type: fileType, quality: fileType === 'png' ? undefined : 50, scale: 'css', path: fileName };
-        const isElementScreenshot = validatedParams.element && validatedParams.ref;
+        const isElementScreenshot = params.element && params.ref;
         const code = [
-            `// Screenshot ${isElementScreenshot ? validatedParams.element : 'viewport'} and save it as ${fileName}`,
+            `// Screenshot ${isElementScreenshot ? params.element : 'viewport'} and save it as ${fileName}`,
         ];
-        const locator = validatedParams.ref ? snapshot.refLocator(validatedParams.ref) : null;
+        const locator = params.ref ? snapshot.refLocator(params.ref) : null;
         if (locator)
             code.push(`await page.${await (0, context_1.generateLocator)(locator)}.screenshot(${javascript.formatObject(options)});`);
         else
@@ -271,7 +264,7 @@ const screenshot = {
             waitForNetwork: false,
         };
     }
-};
+});
 exports.default = [
     snapshot,
     click,

package/lib/tools/tabs.js

@@ -16,13 +16,13 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const zod_to_json_schema_1 = require("zod-to-json-schema");
-const listTabs = {
+const tool_1 = require("./tool");
+const listTabs = (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_list',
         description: 'List browser tabs',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(zod_1.z.object({})),
+        inputSchema: zod_1.z.object({}),
     },
     handle: async (context) => {
         await context.ensureTab();
@@ -38,22 +38,20 @@ const listTabs = {
             },
         };
     },
-};
-const selectTabSchema = zod_1.z.object({
-    index: zod_1.z.number().describe('The index of the tab to select'),
 });
-const selectTab = captureSnapshot => ({
+const selectTab = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_select',
         description: 'Select a tab by index',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(selectTabSchema),
+        inputSchema: zod_1.z.object({
+            index: zod_1.z.number().describe('The index of the tab to select'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = selectTabSchema.parse(params);
-        await context.selectTab(validatedParams.index);
+        await context.selectTab(params.index);
         const code = [
-            `// <internal code to select tab ${validatedParams.index}>`,
+            `// <internal code to select tab ${params.index}>`,
         ];
         return {
             code,
@@ -62,21 +60,19 @@ const selectTab = captureSnapshot => ({
         };
     },
 });
-const newTabSchema = zod_1.z.object({
-    url: zod_1.z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
-});
-const newTab = captureSnapshot => ({
+const newTab = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_new',
         description: 'Open a new tab',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(newTabSchema),
+        inputSchema: zod_1.z.object({
+            url: zod_1.z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = newTabSchema.parse(params);
         await context.newTab();
-        if (validatedParams.url)
-            await context.currentTabOrDie().navigate(validatedParams.url);
+        if (params.url)
+            await context.currentTabOrDie().navigate(params.url);
         const code = [
             `// <internal code to open a new tab>`,
         ];
@@ -87,21 +83,19 @@ const newTab = captureSnapshot => ({
         };
     },
 });
-const closeTabSchema = zod_1.z.object({
-    index: zod_1.z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
-});
-const closeTab = captureSnapshot => ({
+const closeTab = captureSnapshot => (0, tool_1.defineTool)({
     capability: 'tabs',
     schema: {
         name: 'browser_tab_close',
         description: 'Close a tab',
-        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(closeTabSchema),
+        inputSchema: zod_1.z.object({
+            index: zod_1.z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
+        }),
     },
     handle: async (context, params) => {
-        const validatedParams = closeTabSchema.parse(params);
-        await context.closeTab(validatedParams.index);
+        await context.closeTab(params.index);
         const code = [
-            `// <internal code to close tab ${validatedParams.index}>`,
+            `// <internal code to close tab ${params.index}>`,
         ];
         return {
             code,

package/lib/tools/tool.js

@@ -15,3 +15,7 @@
  * limitations under the License.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.defineTool = defineTool;
+function defineTool(tool) {
+    return tool;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@playwright/mcp",
-  "version": "0.0.14",
+  "version": "0.0.15",
   "description": "Playwright Tools for MCP",
   "repository": {
     "type": "git",
@@ -36,14 +36,14 @@
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.6.1",
     "commander": "^13.1.0",
-    "playwright": "^1.52.0-alpha-1743163434000",
+    "playwright": "1.53.0-alpha-1745357020000",
     "yaml": "^2.7.1",
     "zod-to-json-schema": "^3.24.4"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
-    "@playwright/test": "^1.52.0-alpha-1743163434000",
+    "@playwright/test": "1.53.0-alpha-1745357020000",
     "@stylistic/eslint-plugin": "^3.0.1",
     "@types/node": "^22.13.10",
     "@typescript-eslint/eslint-plugin": "^8.26.1",