@wordbricks/playwright-mcp 0.1.6 → 0.1.7

package/lib/context.js

@@ -21,6 +21,7 @@ import { buildHookRegistry } from './hooks/registry.js';
 import { setEventStore, createEventStore } from './hooks/events.js';
 import { setupNetworkTracking } from './hooks/networkSetup.js';
 import { outputFile } from './config.js';
+import * as codegen from './utils/codegen.js';
 const testDebug = debug('pw:mcp:test');
 export class Context {
     tools;
@@ -184,6 +185,14 @@ export class Context {
         }
         return result;
     }
+    lookupSecret(secretName) {
+        // if (!this.config.secrets?.[secretName])
+        return { value: secretName, code: codegen.quote(secretName) };
+        // return {
+        //   value: this.config.secrets[secretName]!,
+        //   code: `process.env['${secretName}']`,
+        // };
+    }
 }
 export class InputRecorder {
     _context;

package/lib/hooks/schema.js

@@ -15,6 +15,7 @@ export const hookNameSchema = z.enum([
 export const toolNameSchema = z.enum([
     'browser_click',
     'browser_extract_framework_state',
+    'browser_fill_form',
     'browser_get_snapshot',
     // 'browser_get_visible_html',
     'browser_navigate',
@@ -26,6 +27,7 @@ export const toolNameSchema = z.enum([
     'browser_reload',
     'browser_repl',
     'browser_scroll',
+    'browser_type',
     'browser_wait',
 ]);
 export const EventTypeSchema = z.enum([

package/lib/mcp/tool.js

@@ -14,16 +14,25 @@
  * limitations under the License.
  */
 import { zodToJsonSchema } from 'zod-to-json-schema';
-export function toMcpTool(tool) {
+import { z } from 'zod';
+const typesWithIntent = ['action', 'assertion', 'input'];
+export function toMcpTool(tool, options) {
+    const inputSchema = options?.addIntent && typesWithIntent.includes(tool.type) ? tool.inputSchema.extend({
+        intent: z.string().describe('The intent of the call, for example the test step description plan idea')
+    }) : tool.inputSchema;
+    const readOnly = tool.type === 'readOnly' || tool.type === 'assertion';
     return {
         name: tool.name,
         description: tool.description,
-        inputSchema: zodToJsonSchema(tool.inputSchema, { strictUnions: true }),
+        inputSchema: zodToJsonSchema(inputSchema, { strictUnions: true }),
         annotations: {
             title: tool.title,
-            readOnlyHint: tool.type === 'readOnly',
-            destructiveHint: tool.type === 'destructive',
+            readOnlyHint: readOnly,
+            destructiveHint: !readOnly,
             openWorldHint: true,
         },
     };
 }
+export function defineToolSchema(tool) {
+    return tool;
+}

package/lib/program.js

@@ -20,7 +20,6 @@ import { commaSeparatedList, resolveCLIConfig, semicolonSeparatedList } from './
 import { packageJSON } from './utils/package.js';
 import { Context } from './context.js';
 import { contextFactory } from './browserContextFactory.js';
-import { runLoopTools } from './loopTools/main.js';
 import { ProxyBackend } from './mcp/proxyBackend.js';
 import { BrowserServerBackend } from './browserServerBackend.js';
 import { ExtensionContextFactory } from './extension/extensionContextFactory.js';
@@ -71,10 +70,6 @@ program
         await mcpTransport.start(serverBackendFactory, config.server);
         return;
     }
-    if (options.loopTools) {
-        await runLoopTools(config);
-        return;
-    }
     const browserContextFactory = contextFactory(config);
     const providers = [mcpProviderForBrowserContextFactory(config, browserContextFactory)];
     if (options.connectTool)

package/lib/response.js

@@ -62,9 +62,9 @@ export class Response {
     images() {
         return this._images;
     }
-    setIncludeSnapshot() {
-        // Disabled: Page state logging not needed
-        // this._includeSnapshot = true;
+    // NOTE Wordbricks Disabled: Page state logging not needed
+    setIncludeSnapshot(full) {
+        // this._includeSnapshot = full ?? 'incremental';
     }
     setIncludeTabs() {
         this._includeTabs = true;

package/lib/tools/dialogs.js

@@ -15,7 +15,7 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-const handleDialog = defineTabTool({
+export const handleDialog = defineTabTool({
     capability: 'core',
     schema: {
         name: 'browser_handle_dialog',
@@ -25,7 +25,7 @@ const handleDialog = defineTabTool({
             accept: z.boolean().describe('Whether to accept the dialog.'),
             promptText: z.string().optional().describe('The text of the prompt in case of a prompt dialog.'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/evaluate.js

@@ -29,7 +29,7 @@ const evaluate = defineTabTool({
         title: 'Evaluate JavaScript',
         description: 'Evaluate JavaScript expression on page or element',
         inputSchema: evaluateSchema,
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/files.js

@@ -15,16 +15,16 @@
  */
 import { z } from 'zod';
 import { defineTabTool } from './tool.js';
-const uploadFile = defineTabTool({
+export const uploadFile = defineTabTool({
     capability: 'core',
     schema: {
         name: 'browser_file_upload',
         title: 'Upload files',
         description: 'Upload one or multiple files',
         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.'),
+            paths: z.array(z.string()).optional().describe('The absolute paths to the files to upload. Can be single file or multiple files. If omitted, file chooser is cancelled.'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -34,7 +34,8 @@ const uploadFile = defineTabTool({
         response.addCode(`await fileChooser.setFiles(${JSON.stringify(params.paths)})`);
         tab.clearModalState(modalState);
         await tab.waitForCompletion(async () => {
-            await modalState.fileChooser.setFiles(params.paths);
+            if (params.paths)
+                await modalState.fileChooser.setFiles(params.paths);
         });
     },
     clearsModalState: 'fileChooser',

package/lib/tools/form.js

@@ -0,0 +1,57 @@
+/**
+ * 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.
+ */
+import { z } from 'zod';
+import { defineTabTool } from './tool.js';
+import * as codegen from '../utils/codegen.js';
+import { generateLocator } from './utils.js';
+const fillForm = defineTabTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_fill_form',
+        title: 'Fill form',
+        description: 'Fill multiple form fields',
+        inputSchema: z.object({
+            fields: z.array(z.object({
+                name: z.string().describe('Human-readable field name'),
+                type: z.enum(['textbox', 'checkbox', 'radio', 'combobox', 'slider']).describe('Type of the field'),
+                ref: z.string().describe('Exact target field reference from the page snapshot'),
+                value: z.string().describe('Value to fill in the field. If the field is a checkbox, the value should be `true` or `false`. If the field is a combobox, the value should be the text of the option.'),
+            })).describe('Fields to fill in'),
+        }),
+        type: 'input',
+    },
+    handle: async (tab, params, response) => {
+        for (const field of params.fields) {
+            const locator = await tab.refLocator({ element: field.name, ref: field.ref });
+            if (field.type === 'textbox' || field.type === 'slider') {
+                const secret = tab.context.lookupSecret(field.value);
+                await locator.fill(secret.value);
+                response.addCode(`await page.${await generateLocator(locator)}.fill(${secret.code});`);
+            }
+            else if (field.type === 'checkbox' || field.type === 'radio') {
+                await locator.setChecked(field.value === 'true');
+                response.addCode(`await page.${await generateLocator(locator)}.setChecked(${field.value});`);
+            }
+            else if (field.type === 'combobox') {
+                await locator.selectOption({ label: field.value });
+                response.addCode(`await page.${await generateLocator(locator)}.selectOption(${codegen.quote(field.value)});`);
+            }
+        }
+    },
+});
+export default [
+    fillForm,
+];

package/lib/tools/install.js

@@ -15,7 +15,6 @@
  */
 import { fork } from 'child_process';
 import path from 'path';
-import { fileURLToPath } from 'url';
 import { z } from 'zod';
 import { defineTool } from './tool.js';
 const install = defineTool({
@@ -25,12 +24,11 @@ const install = defineTool({
         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',
+        type: 'action',
     },
     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 cliPath = path.join(require.resolve('playwright/package.json'), '../cli.js');
         const child = fork(cliPath, ['install', channel], {
             stdio: 'pipe',
         });

package/lib/tools/keyboard.js

@@ -27,7 +27,7 @@ const pressKey = defineTabTool({
         inputSchema: z.object({
             key: z.string().describe('Name of the key to press or a character to generate, such as `ArrowLeft` or `a`'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -50,7 +50,7 @@ const type = defineTabTool({
         title: 'Type text',
         description: 'Type text into editable element',
         inputSchema: typeSchema,
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         const locator = await tab.refLocator(params);

package/lib/tools/mouse.js

@@ -48,7 +48,7 @@ const mouseClick = defineTabTool({
             x: z.number().describe('X coordinate'),
             y: z.number().describe('Y coordinate'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -75,7 +75,7 @@ const mouseDrag = defineTabTool({
             endX: z.number().describe('End X coordinate'),
             endY: z.number().describe('End Y coordinate'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/navigate.js

@@ -24,7 +24,7 @@ const navigate = defineTool({
         inputSchema: z.object({
             url: z.string().describe('The URL to navigate to'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (context, params, response) => {
         const tab = await context.ensureTab();

package/lib/tools/repl.js

@@ -220,7 +220,7 @@ const repl = defineTabTool({
         title: 'Browser REPL',
         description: 'DevTools-like browser REPL. Per-tab state persists across calls (const/let/functions); supports top-level await. Survives SPA nav; resets on full reload or when switching tabs. Helpers available via window.mcp: JSON5, JSONPath, _, GraphQLClient, gql, graphqlRequest. No need for wrapping in IIFE.',
         inputSchema: replSchema,
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (tab, params, response) => {
         const page = tab.page;

package/lib/tools/scroll.js

@@ -56,7 +56,7 @@ const scrollWheel = defineTabTool({
         title: 'Scroll page',
         description: 'Scroll the page using mouse wheel with human-like behavior',
         inputSchema: scrollSchema,
-        type: 'destructive',
+        type: 'readOnly',
     },
     handle: async (tab, params, response) => {
         const requestedDeltaY = params.amount || 0;

package/lib/tools/snapshot.js

@@ -28,7 +28,7 @@ const snapshot = defineTool({
     },
     handle: async (context, params, response) => {
         await context.ensureTab();
-        response.setIncludeSnapshot();
+        response.setIncludeSnapshot('full');
     },
 });
 export const elementSchema = z.object({
@@ -38,6 +38,7 @@ export const elementSchema = z.object({
 const clickSchema = elementSchema.extend({
     doubleClick: z.boolean().optional().describe('Whether to perform a double click instead of a single click'),
     button: z.enum(['left', 'right', 'middle']).optional().describe('Button to click, defaults to left'),
+    modifiers: z.array(z.enum(['Alt', 'Control', 'ControlOrMeta', 'Meta', 'Shift'])).optional().describe('Modifier keys to press'),
 });
 const click = defineTabTool({
     capability: 'core',
@@ -46,22 +47,26 @@ const click = defineTabTool({
         title: 'Click',
         description: 'Perform click on a web page',
         inputSchema: clickSchema,
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
         const locator = await tab.refLocator(params);
-        const button = params.button;
-        const buttonAttr = button ? `{ button: '${button}' }` : '';
+        const options = {
+            button: params.button,
+            modifiers: params.modifiers,
+        };
+        const formatted = javascript.formatObject(options, ' ', 'oneline');
+        const optionsAttr = formatted !== '{}' ? formatted : '';
         if (params.doubleClick)
-            response.addCode(`await page.${await generateLocator(locator)}.dblclick(${buttonAttr});`);
+            response.addCode(`await page.${await generateLocator(locator)}.dblclick(${optionsAttr});`);
         else
-            response.addCode(`await page.${await generateLocator(locator)}.click(${buttonAttr});`);
+            response.addCode(`await page.${await generateLocator(locator)}.click(${optionsAttr});`);
         await tab.waitForCompletion(async () => {
             if (params.doubleClick)
-                await locator.dblclick({ button });
+                await locator.dblclick(options);
             else
-                await locator.click({ button });
+                await locator.click(options);
         });
     },
 });
@@ -77,7 +82,7 @@ const drag = defineTabTool({
             endElement: z.string().describe('Human-readable target element description used to obtain the permission to interact with the element'),
             endRef: z.string().describe('Exact target element reference from the page snapshot'),
         }),
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();
@@ -119,7 +124,7 @@ const selectOption = defineTabTool({
         title: 'Select option',
         description: 'Select an option in a dropdown',
         inputSchema: selectOptionSchema,
-        type: 'destructive',
+        type: 'input',
     },
     handle: async (tab, params, response) => {
         response.setIncludeSnapshot();

package/lib/tools/tabs.js

@@ -15,73 +15,45 @@
  */
 import { z } from 'zod';
 import { defineTool } from './tool.js';
-const listTabs = defineTool({
+const browserTabs = defineTool({
     capability: 'core-tabs',
     schema: {
-        name: 'browser_tab_list',
-        title: 'List tabs',
-        description: 'List browser tabs',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.ensureTab();
-        response.setIncludeTabs();
-    },
-});
-const selectTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_select',
-        title: 'Select a tab',
-        description: 'Select a tab by index',
-        inputSchema: z.object({
-            index: z.number().describe('The index of the tab to select'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        await context.selectTab(params.index);
-        response.setIncludeSnapshot();
-    },
-});
-const newTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_new',
-        title: 'Open a new tab',
-        description: 'Open a new tab',
-        inputSchema: z.object({
-            url: z.string().optional().describe('The URL to navigate to in the new tab. If not provided, the new tab will be blank.'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params, response) => {
-        const tab = await context.newTab();
-        if (params.url)
-            await tab.navigate(params.url);
-        response.setIncludeSnapshot();
-    },
-});
-const closeTab = defineTool({
-    capability: 'core-tabs',
-    schema: {
-        name: 'browser_tab_close',
-        title: 'Close a tab',
-        description: 'Close a tab',
+        name: 'browser_tabs',
+        title: 'Manage tabs',
+        description: 'List, create, close, or select a browser tab.',
         inputSchema: z.object({
-            index: z.number().optional().describe('The index of the tab to close. Closes current tab if not provided.'),
+            action: z.enum(['list', 'new', 'close', 'select']).describe('Operation to perform'),
+            index: z.number().optional().describe('Tab index, used for close/select. If omitted for close, current tab is closed.'),
         }),
-        type: 'destructive',
+        type: 'action',
     },
     handle: async (context, params, response) => {
-        await context.closeTab(params.index);
-        response.setIncludeSnapshot();
+        switch (params.action) {
+            case 'list': {
+                await context.ensureTab();
+                response.setIncludeTabs();
+                return;
+            }
+            case 'new': {
+                await context.newTab();
+                response.setIncludeTabs();
+                return;
+            }
+            case 'close': {
+                await context.closeTab(params.index);
+                response.setIncludeSnapshot('full');
+                return;
+            }
+            case 'select': {
+                if (params.index === undefined)
+                    throw new Error('Tab index is required');
+                await context.selectTab(params.index);
+                response.setIncludeSnapshot('full');
+                return;
+            }
+        }
     },
 });
 export default [
-    listTabs,
-    newTab,
-    selectTab,
-    closeTab,
+    browserTabs,
 ];

package/lib/tools/tool.js

@@ -20,7 +20,7 @@ export function defineTabTool(tool) {
     return {
         ...tool,
         handle: async (context, params, response) => {
-            const tab = context.currentTabOrDie();
+            const tab = await context.ensureTab();
             const modalStates = tab.modalStates().map(state => state.type);
             if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState))
                 response.addError(`Error: The tool "${tool.schema.name}" can only be used when there is related modal state present.\n` + tab.modalStatesMarkdown().join('\n'));

package/lib/utils/codegen.js

@@ -31,7 +31,7 @@ export function escapeWithQuotes(text, char = '\'') {
 export function quote(text) {
     return escapeWithQuotes(text, '\'');
 }
-export function formatObject(value, indent = '  ') {
+export function formatObject(value, indent = '  ', mode = 'multiline') {
     if (typeof value === 'string')
         return quote(value);
     if (Array.isArray(value))
@@ -43,7 +43,9 @@ export function formatObject(value, indent = '  ') {
         const tokens = [];
         for (const key of keys)
             tokens.push(`${key}: ${formatObject(value[key])}`);
-        return `{\n${indent}${tokens.join(`,\n${indent}`)}\n}`;
+        if (mode === 'multiline')
+            return `{\n${tokens.join(`,\n${indent}`)}\n}`;
+        return `{ ${tokens.join(', ')} }`;
     }
     return String(value);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wordbricks/playwright-mcp",
-  "version": "0.1.6",
+  "version": "0.1.7",
   "description": "Playwright Tools for MCP",
   "type": "module",
   "repository": {
@@ -60,8 +60,8 @@
     "lodash": "^4.17.21",
     "mime": "^4.0.7",
     "ms": "^2.1.3",
-    "playwright": "1.55.0-alpha-2025-08-12",
-    "playwright-core": "1.55.0-alpha-2025-08-12",
+    "playwright": "npm:rebrowser-playwright@1.56.1",
+    "playwright-core": "npm:rebrowser-playwright@1.56.1",
     "raw-body": "^3.0.0",
     "typescript-parsec": "0.3.4",
     "ws": "^8.18.1",
@@ -72,7 +72,7 @@
     "@anthropic-ai/sdk": "^0.57.0",
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.19.0",
-    "@playwright/test": "1.55.0-alpha-2025-08-12",
+    "@playwright/test": "1.56.1",
     "@stylistic/eslint-plugin": "^3.0.1",
     "@tomjs/unzip-crx": "1.1.3",
     "@types/chrome": "^0.0.315",

package/lib/loopTools/context.js

@@ -1,66 +0,0 @@
-/**
- * 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.
- */
-import { Client } from '@modelcontextprotocol/sdk/client/index.js';
-import { contextFactory } from '../browserContextFactory.js';
-import { BrowserServerBackend } from '../browserServerBackend.js';
-import { Context as BrowserContext } from '../context.js';
-import { runTask } from '../loop/loop.js';
-import { OpenAIDelegate } from '../loop/loopOpenAI.js';
-import { ClaudeDelegate } from '../loop/loopClaude.js';
-import { InProcessTransport } from '../mcp/inProcessTransport.js';
-import * as mcpServer from '../mcp/server.js';
-export class Context {
-    config;
-    _client;
-    _delegate;
-    constructor(config, client) {
-        this.config = config;
-        this._client = client;
-        if (process.env.OPENAI_API_KEY)
-            this._delegate = new OpenAIDelegate();
-        else if (process.env.ANTHROPIC_API_KEY)
-            this._delegate = new ClaudeDelegate();
-        else
-            throw new Error('No LLM API key found. Please set OPENAI_API_KEY or ANTHROPIC_API_KEY environment variable.');
-    }
-    static async create(config) {
-        const client = new Client({ name: 'Playwright Proxy', version: '1.0.0' });
-        const browserContextFactory = contextFactory(config);
-        const server = mcpServer.createServer(new BrowserServerBackend(config, browserContextFactory), false);
-        await client.connect(new InProcessTransport(server));
-        await client.ping();
-        return new Context(config, client);
-    }
-    async runTask(task, oneShot = false) {
-        const messages = await runTask(this._delegate, this._client, task, oneShot);
-        const lines = [];
-        // Skip the first message, which is the user's task.
-        for (const message of messages.slice(1)) {
-            // Trim out all page snapshots.
-            if (!message.content.trim())
-                continue;
-            const index = oneShot ? -1 : message.content.indexOf('### Page state');
-            const trimmedContent = index === -1 ? message.content : message.content.substring(0, index);
-            lines.push(`[${message.role}]:`, trimmedContent);
-        }
-        return {
-            content: [{ type: 'text', text: lines.join('\n') }],
-        };
-    }
-    async close() {
-        await BrowserContext.disposeAll();
-    }
-}

package/lib/loopTools/main.js

@@ -1,51 +0,0 @@
-/**
- * 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.
- */
-import dotenv from 'dotenv';
-import * as mcpTransport from '../mcp/transport.js';
-import { packageJSON } from '../utils/package.js';
-import { Context } from './context.js';
-import { perform } from './perform.js';
-import { snapshot } from './snapshot.js';
-import { toMcpTool } from '../mcp/tool.js';
-export async function runLoopTools(config) {
-    dotenv.config();
-    const serverBackendFactory = () => new LoopToolsServerBackend(config);
-    await mcpTransport.start(serverBackendFactory, config.server);
-}
-class LoopToolsServerBackend {
-    name = 'Playwright';
-    version = packageJSON.version;
-    _config;
-    _context;
-    _tools = [perform, snapshot];
-    constructor(config) {
-        this._config = config;
-    }
-    async initialize() {
-        this._context = await Context.create(this._config);
-    }
-    async listTools() {
-        return this._tools.map(tool => toMcpTool(tool.schema));
-    }
-    async callTool(name, args) {
-        const tool = this._tools.find(tool => tool.schema.name === name);
-        const parsedArguments = tool.schema.inputSchema.parse(args || {});
-        return await tool.handle(this._context, parsedArguments);
-    }
-    serverClosed() {
-        void this._context.close();
-    }
-}

package/lib/loopTools/perform.js

@@ -1,32 +0,0 @@
-/**
- * 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.
- */
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-const performSchema = z.object({
-    task: z.string().describe('The task to perform with the browser'),
-});
-export const perform = defineTool({
-    schema: {
-        name: 'browser_perform',
-        title: 'Perform a task with the browser',
-        description: 'Perform a task with the browser. It can click, type, export, capture screenshot, drag, hover, select options, etc.',
-        inputSchema: performSchema,
-        type: 'destructive',
-    },
-    handle: async (context, params) => {
-        return await context.runTask(params.task);
-    },
-});

package/lib/loopTools/snapshot.js

@@ -1,29 +0,0 @@
-/**
- * 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.
- */
-import { z } from 'zod';
-import { defineTool } from './tool.js';
-export const snapshot = defineTool({
-    schema: {
-        name: 'browser_snapshot',
-        title: 'Take a snapshot of the browser',
-        description: 'Take a snapshot of the browser to read what is on the page.',
-        inputSchema: z.object({}),
-        type: 'readOnly',
-    },
-    handle: async (context, params) => {
-        return await context.runTask('Capture browser snapshot', true);
-    },
-});

package/lib/loopTools/tool.js

@@ -1,18 +0,0 @@
-/**
- * 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.
- */
-export function defineTool(tool) {
-    return tool;
-}