@playwright/mcp 0.0.22 → 0.0.25

package/config.d.ts

@@ -28,6 +28,11 @@ export type Config = {
      */
     browserName?: 'chromium' | 'firefox' | 'webkit';
 
+    /**
+     * Keep the browser profile in memory, do not save it to disk.
+     */
+    isolated?: boolean;
+
     /**
      * Path to a user data directory for browser profile persistence.
      * Temporary directory is created by default.
@@ -40,7 +45,7 @@ export type Config = {
      *
      * This is useful for settings options like `channel`, `headless`, `executablePath`, etc.
      */
-    launchOptions?: playwright.BrowserLaunchOptions;
+    launchOptions?: playwright.LaunchOptions;
 
     /**
      * Context options for the browser context.

package/index.js

@@ -16,4 +16,4 @@
  */
 
 import { createConnection } from './lib/index';
-export default { createConnection };
+export { createConnection };

package/lib/config.js

@@ -25,6 +25,7 @@ const defaultConfig = {
         launchOptions: {
             channel: 'chrome',
             headless: os.platform() === 'linux' && !process.env.DISPLAY,
+            chromiumSandbox: true,
         },
         contextOptions: {
             viewport: null,
@@ -66,17 +67,51 @@ export async function configFromCLIOptions(cliOptions) {
             browserName = 'chromium';
             channel = 'chrome';
     }
+    // Launch options
     const launchOptions = {
         channel,
         executablePath: cliOptions.executablePath,
         headless: cliOptions.headless,
     };
-    if (browserName === 'chromium')
-        launchOptions.webSocketPort = await findFreePort();
-    const contextOptions = cliOptions.device ? devices[cliOptions.device] : undefined;
-    return {
+    if (browserName === 'chromium') {
+        launchOptions.cdpPort = await findFreePort();
+        if (!cliOptions.sandbox) {
+            // --no-sandbox was passed, disable the sandbox
+            launchOptions.chromiumSandbox = false;
+        }
+    }
+    if (cliOptions.proxyServer) {
+        launchOptions.proxy = {
+            server: cliOptions.proxyServer
+        };
+        if (cliOptions.proxyBypass)
+            launchOptions.proxy.bypass = cliOptions.proxyBypass;
+    }
+    // Context options
+    const contextOptions = cliOptions.device ? devices[cliOptions.device] : {};
+    if (cliOptions.storageState)
+        contextOptions.storageState = cliOptions.storageState;
+    if (cliOptions.userAgent)
+        contextOptions.userAgent = cliOptions.userAgent;
+    if (cliOptions.viewportSize) {
+        try {
+            const [width, height] = cliOptions.viewportSize.split(',').map(n => +n);
+            if (isNaN(width) || isNaN(height))
+                throw new Error('bad values');
+            contextOptions.viewport = { width, height };
+        }
+        catch (e) {
+            throw new Error('Invalid viewport size format: use "width,height", for example --viewport-size="800,600"');
+        }
+    }
+    if (cliOptions.ignoreHttpsErrors)
+        contextOptions.ignoreHTTPSErrors = true;
+    if (cliOptions.blockServiceWorkers)
+        contextOptions.serviceWorkers = 'block';
+    const result = {
         browser: {
             browserName,
+            isolated: cliOptions.isolated,
             userDataDir: cliOptions.userDataDir,
             launchOptions,
             contextOptions,
@@ -94,6 +129,11 @@ export async function configFromCLIOptions(cliOptions) {
         },
         outputDir: cliOptions.outputDir,
     };
+    if (!cliOptions.imageResponses) {
+        // --no-image-responses was passed, disable image responses
+        result.noImageResponses = true;
+    }
+    return result;
 }
 async function findFreePort() {
     return new Promise((resolve, reject) => {
@@ -138,7 +178,7 @@ function mergeConfig(base, overrides) {
             ...pickDefined(overrides.browser?.contextOptions),
         },
     };
-    if (browser.browserName !== 'chromium')
+    if (browser.browserName !== 'chromium' && browser.launchOptions)
         delete browser.launchOptions.channel;
     return {
         ...pickDefined(base),

package/lib/connection.js

@@ -17,9 +17,9 @@ import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
 import { zodToJsonSchema } from 'zod-to-json-schema';
 import { Context, packageJSON } from './context.js';
-import { snapshotTools, screenshotTools } from './tools.js';
+import { snapshotTools, visionTools } from './tools.js';
 export async function createConnection(config) {
-    const allTools = config.vision ? screenshotTools : snapshotTools;
+    const allTools = config.vision ? visionTools : snapshotTools;
     const tools = allTools.filter(tool => !config.capabilities || tool.capability === 'core' || config.capabilities.includes(tool.capability));
     const context = new Context(tools, config);
     const server = new Server({ name: 'Playwright', version: packageJSON.version }, {

package/lib/context.js

@@ -25,9 +25,7 @@ import { outputFile } from './config.js';
 export class Context {
     tools;
     config;
-    _browser;
-    _browserContext;
-    _createBrowserContextPromise;
+    _browserContextPromise;
     _tabs = [];
     _currentTab;
     _modalStates = [];
@@ -65,7 +63,7 @@ export class Context {
         return this._currentTab;
     }
     async newTab() {
-        const browserContext = await this._ensureBrowserContext();
+        const { browserContext } = await this._ensureBrowserContext();
         const page = await browserContext.newPage();
         this._currentTab = this._tabs.find(t => t.page === page);
         return this._currentTab;
@@ -75,9 +73,9 @@ export class Context {
         await this._currentTab.page.bringToFront();
     }
     async ensureTab() {
-        const context = await this._ensureBrowserContext();
+        const { browserContext } = await this._ensureBrowserContext();
         if (!this._currentTab)
-            await context.newPage();
+            await browserContext.newPage();
         return this._currentTab;
     }
     async listTabsMarkdown() {
@@ -100,7 +98,7 @@ export class Context {
     }
     async run(tool, params) {
         // Tab management is done outside of the action() call.
-        const toolResult = await tool.handle(this, tool.schema.inputSchema.parse(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)
@@ -226,20 +224,19 @@ ${code.join('\n')}
         this._tabs.splice(index, 1);
         if (this._currentTab === tab)
             this._currentTab = this._tabs[Math.min(index, this._tabs.length - 1)];
-        if (this._browserContext && !this._tabs.length)
+        if (!this._tabs.length)
             void this.close();
     }
     async close() {
-        if (!this._browserContext)
+        if (!this._browserContextPromise)
             return;
-        const browserContext = this._browserContext;
-        const browser = this._browser;
-        this._createBrowserContextPromise = undefined;
-        this._browserContext = undefined;
-        this._browser = undefined;
-        await browserContext?.close().then(async () => {
-            await browser?.close();
-        }).catch(() => { });
+        const promise = this._browserContextPromise;
+        this._browserContextPromise = undefined;
+        await promise.then(async ({ browserContext, browser }) => {
+            await browserContext.close().then(async () => {
+                await browser?.close();
+            }).catch(() => { });
+        });
     }
     async _setupRequestInterception(context) {
         if (this.config.network?.allowedOrigins?.length) {
@@ -252,28 +249,24 @@ ${code.join('\n')}
                 await context.route(`*://${origin}/**`, route => route.abort('blockedbyclient'));
         }
     }
-    async _ensureBrowserContext() {
-        if (!this._browserContext) {
-            const context = await this._createBrowserContext();
-            this._browser = context.browser;
-            this._browserContext = context.browserContext;
-            await this._setupRequestInterception(this._browserContext);
-            for (const page of this._browserContext.pages())
-                this._onPageCreated(page);
-            this._browserContext.on('page', page => this._onPageCreated(page));
-        }
-        return this._browserContext;
-    }
-    async _createBrowserContext() {
-        if (!this._createBrowserContextPromise) {
-            this._createBrowserContextPromise = this._innerCreateBrowserContext();
-            void this._createBrowserContextPromise.catch(() => {
-                this._createBrowserContextPromise = undefined;
+    _ensureBrowserContext() {
+        if (!this._browserContextPromise) {
+            this._browserContextPromise = this._setupBrowserContext();
+            this._browserContextPromise.catch(() => {
+                this._browserContextPromise = undefined;
             });
         }
-        return this._createBrowserContextPromise;
+        return this._browserContextPromise;
+    }
+    async _setupBrowserContext() {
+        const { browser, browserContext } = await this._createBrowserContext();
+        await this._setupRequestInterception(browserContext);
+        for (const page of browserContext.pages())
+            this._onPageCreated(page);
+        browserContext.on('page', page => this._onPageCreated(page));
+        return { browser, browserContext };
     }
-    async _innerCreateBrowserContext() {
+    async _createBrowserContext() {
         if (this.config.browser?.remoteEndpoint) {
             const url = new URL(this.config.browser?.remoteEndpoint);
             if (this.config.browser.browserName)
@@ -286,11 +279,26 @@ ${code.join('\n')}
         }
         if (this.config.browser?.cdpEndpoint) {
             const browser = await playwright.chromium.connectOverCDP(this.config.browser.cdpEndpoint);
-            const browserContext = browser.contexts()[0];
+            const browserContext = this.config.browser.isolated ? await browser.newContext() : browser.contexts()[0];
             return { browser, browserContext };
         }
-        const browserContext = await launchPersistentContext(this.config.browser);
-        return { browserContext };
+        return this.config.browser?.isolated ?
+            await createIsolatedContext(this.config.browser) :
+            await launchPersistentContext(this.config.browser);
+    }
+}
+async function createIsolatedContext(browserConfig) {
+    try {
+        const browserName = browserConfig?.browserName ?? 'chromium';
+        const browserType = playwright[browserName];
+        const browser = await browserType.launch(browserConfig?.launchOptions);
+        const browserContext = await browser.newContext(browserConfig?.contextOptions);
+        return { browser, browserContext };
+    }
+    catch (error) {
+        if (error.message.includes('Executable doesn\'t exist'))
+            throw new Error(`Browser specified in your config is not installed. Either install it (likely) or change the config.`);
+        throw error;
     }
 }
 async function launchPersistentContext(browserConfig) {
@@ -298,7 +306,8 @@ async function launchPersistentContext(browserConfig) {
         const browserName = browserConfig?.browserName ?? 'chromium';
         const userDataDir = browserConfig?.userDataDir ?? await createUserDataDir({ ...browserConfig, browserName });
         const browserType = playwright[browserName];
-        return await browserType.launchPersistentContext(userDataDir, { ...browserConfig?.launchOptions, ...browserConfig?.contextOptions });
+        const browserContext = await browserType.launchPersistentContext(userDataDir, { ...browserConfig?.launchOptions, ...browserConfig?.contextOptions });
+        return { browserContext };
     }
     catch (error) {
         if (error.message.includes('Executable doesn\'t exist'))
@@ -316,7 +325,7 @@ async function createUserDataDir(browserConfig) {
         cacheDirectory = process.env.LOCALAPPDATA || path.join(os.homedir(), 'AppData', 'Local');
     else
         throw new Error('Unsupported platform: ' + process.platform);
-    const result = path.join(cacheDirectory, 'ms-playwright', `mcp-${browserConfig?.launchOptions.channel ?? browserConfig?.browserName}-profile`);
+    const result = path.join(cacheDirectory, 'ms-playwright', `mcp-${browserConfig?.launchOptions?.channel ?? browserConfig?.browserName}-profile`);
     await fs.promises.mkdir(result, { recursive: true });
     return result;
 }

package/lib/index.js

@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+import { createConnection as createConnectionImpl } from './connection.js';
 export async function createConnection(config = {}) {
-    return createConnection(config);
+    return createConnectionImpl(config);
 }

package/lib/pageSnapshot.js

@@ -13,22 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import yaml from 'yaml';
 export class PageSnapshot {
-    _frameLocators = [];
+    _page;
     _text;
-    constructor() {
+    constructor(page) {
+        this._page = page;
     }
     static async create(page) {
-        const snapshot = new PageSnapshot();
-        await snapshot._build(page);
+        const snapshot = new PageSnapshot(page);
+        await snapshot._build();
         return snapshot;
     }
     text() {
         return this._text;
     }
-    async _build(page) {
-        const yamlDocument = await this._snapshotFrame(page);
+    async _build() {
+        const yamlDocument = await this._page._snapshotForAI();
         this._text = [
             `- Page Snapshot`,
             '```yaml',
@@ -36,54 +36,7 @@ export class PageSnapshot {
             '```',
         ].join('\n');
     }
-    async _snapshotFrame(frame) {
-        const frameIndex = this._frameLocators.push(frame) - 1;
-        const snapshotString = await frame.locator('body').ariaSnapshot({ ref: true, emitGeneric: true });
-        const snapshot = yaml.parseDocument(snapshotString);
-        const visit = async (node) => {
-            if (yaml.isPair(node)) {
-                await Promise.all([
-                    visit(node.key).then(k => node.key = k),
-                    visit(node.value).then(v => node.value = v)
-                ]);
-            }
-            else if (yaml.isSeq(node) || yaml.isMap(node)) {
-                node.items = await Promise.all(node.items.map(visit));
-            }
-            else if (yaml.isScalar(node)) {
-                if (typeof node.value === 'string') {
-                    const value = node.value;
-                    if (frameIndex > 0)
-                        node.value = value.replace('[ref=', `[ref=f${frameIndex}`);
-                    if (value.startsWith('iframe ')) {
-                        const ref = value.match(/\[ref=(.*)\]/)?.[1];
-                        if (ref) {
-                            try {
-                                const childSnapshot = await this._snapshotFrame(frame.frameLocator(`aria-ref=${ref}`));
-                                return snapshot.createPair(node.value, childSnapshot);
-                            }
-                            catch (error) {
-                                return snapshot.createPair(node.value, '<could not take iframe snapshot>');
-                            }
-                        }
-                    }
-                }
-            }
-            return node;
-        };
-        await visit(snapshot.contents);
-        return snapshot;
-    }
     refLocator(ref) {
-        let frame = this._frameLocators[0];
-        const match = ref.match(/^f(\d+)(.*)/);
-        if (match) {
-            const frameIndex = parseInt(match[1], 10);
-            frame = this._frameLocators[frameIndex];
-            ref = match[2];
-        }
-        if (!frame)
-            throw new Error(`Frame does not exist. Provide ref from the most current snapshot.`);
-        return frame.locator(`aria-ref=${ref}`);
+        return this._page.locator(`aria-ref=${ref}`);
     }
 }

package/lib/program.js

@@ -20,21 +20,30 @@ import { packageJSON } from './context.js';
 program
     .version('Version ' + packageJSON.version)
     .name(packageJSON.name)
-    .option('--browser <browser>', 'Browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.')
-    .option('--caps <caps>', 'Comma-separated list of capabilities to enable, possible values: tabs, pdf, history, wait, files, install. Default is all.')
+    .option('--allowed-origins <origins>', 'semicolon-separated list of origins to allow the browser to request. Default is to allow all.', semicolonSeparatedList)
+    .option('--blocked-origins <origins>', 'semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed.', semicolonSeparatedList)
+    .option('--block-service-workers', 'block service workers')
+    .option('--browser <browser>', 'browser or chrome channel to use, possible values: chrome, firefox, webkit, msedge.')
+    .option('--caps <caps>', 'comma-separated list of capabilities to enable, possible values: tabs, pdf, history, wait, files, install. Default is all.')
     .option('--cdp-endpoint <endpoint>', 'CDP endpoint to connect to.')
-    .option('--executable-path <path>', 'Path to the browser executable.')
-    .option('--headless', 'Run browser in headless mode, headed by default')
-    .option('--device <device>', 'Device to emulate, for example: "iPhone 15"')
-    .option('--user-data-dir <path>', 'Path to the user data directory')
-    .option('--port <port>', 'Port to listen on for SSE transport.')
-    .option('--host <host>', 'Host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.')
-    .option('--allowed-origins <origins>', 'Semicolon-separated list of origins to allow the browser to request. Default is to allow all.', semicolonSeparatedList)
-    .option('--blocked-origins <origins>', 'Semicolon-separated list of origins to block the browser from requesting. Blocklist is evaluated before allowlist. If used without the allowlist, requests not matching the blocklist are still allowed.', semicolonSeparatedList)
+    .option('--config <path>', 'path to the configuration file.')
+    .option('--device <device>', 'device to emulate, for example: "iPhone 15"')
+    .option('--executable-path <path>', 'path to the browser executable.')
+    .option('--headless', 'run browser in headless mode, headed by default')
+    .option('--host <host>', 'host to bind server to. Default is localhost. Use 0.0.0.0 to bind to all interfaces.')
+    .option('--ignore-https-errors', 'ignore https errors')
+    .option('--isolated', 'keep the browser profile in memory, do not save it to disk.')
+    .option('--no-image-responses', 'do not send image responses to the client.')
+    .option('--no-sandbox', 'disable the sandbox for all process types that are normally sandboxed.')
+    .option('--output-dir <path>', 'path to the directory for output files.')
+    .option('--port <port>', 'port to listen on for SSE transport.')
+    .option('--proxy-bypass <bypass>', 'comma-separated domains to bypass proxy, for example ".com,chromium.org,.domain.com"')
+    .option('--proxy-server <proxy>', 'specify proxy server, for example "http://myproxy:3128" or "socks5://myproxy:8080"')
+    .option('--storage-state <path>', 'path to the storage state file for isolated sessions.')
+    .option('--user-agent <ua string>', 'specify user agent string')
+    .option('--user-data-dir <path>', 'path to the user data directory. If not specified, a temporary directory will be created.')
+    .option('--viewport-size <size>', 'specify browser viewport size in pixels, for example "1280, 720"')
     .option('--vision', 'Run server that uses screenshots (Aria snapshots are used by default)')
-    .option('--no-image-responses', 'Do not send image responses to the client.')
-    .option('--output-dir <path>', 'Path to the directory for output files.')
-    .option('--config <path>', 'Path to the configuration file.')
     .action(async (options) => {
     const config = await resolveConfig(options);
     const connectionList = [];

package/lib/tab.js

@@ -17,7 +17,7 @@ import { PageSnapshot } from './pageSnapshot.js';
 export class Tab {
     context;
     page;
-    _console = [];
+    _consoleMessages = [];
     _requests = new Map();
     _snapshot;
     _onPageClose;
@@ -25,13 +25,9 @@ export class Tab {
         this.context = context;
         this.page = page;
         this._onPageClose = onPageClose;
-        page.on('console', event => this._console.push(event));
+        page.on('console', event => this._consoleMessages.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._clearCollectedArtifacts();
-        });
         page.on('close', () => this._onClose());
         page.on('filechooser', chooser => {
             this.context.setModalState({
@@ -48,7 +44,7 @@ export class Tab {
         page.setDefaultTimeout(5000);
     }
     _clearCollectedArtifacts() {
-        this._console.length = 0;
+        this._consoleMessages.length = 0;
         this._requests.clear();
     }
     _onClose() {
@@ -56,6 +52,7 @@ export class Tab {
         this._onPageClose(this);
     }
     async navigate(url) {
+        this._clearCollectedArtifacts();
         const downloadEvent = this.page.waitForEvent('download').catch(() => { });
         try {
             await this.page.goto(url, { waitUntil: 'domcontentloaded' });
@@ -85,8 +82,8 @@ export class Tab {
             throw new Error('No snapshot available');
         return this._snapshot;
     }
-    console() {
-        return this._console;
+    consoleMessages() {
+        return this._consoleMessages;
     }
     requests() {
         return this._requests;

package/lib/tools/common.js

@@ -15,26 +15,6 @@
  */
 import { z } from 'zod';
 import { defineTool } from './tool.js';
-const wait = captureSnapshot => defineTool({
-    capability: 'wait',
-    schema: {
-        name: 'browser_wait',
-        title: 'Wait',
-        description: 'Wait for a specified time in seconds',
-        inputSchema: z.object({
-            time: z.number().describe('The time to wait in seconds'),
-        }),
-        type: 'readOnly',
-    },
-    handle: async (context, params) => {
-        await new Promise(f => setTimeout(f, Math.min(10000, params.time * 1000)));
-        return {
-            code: [`// Waited for ${params.time} seconds`],
-            captureSnapshot,
-            waitForNetwork: false,
-        };
-    },
-});
 const close = defineTool({
     capability: 'core',
     schema: {
@@ -47,7 +27,7 @@ const close = defineTool({
     handle: async (context) => {
         await context.close();
         return {
-            code: [`// Internal to close the page`],
+            code: [`await page.close()`],
             captureSnapshot: false,
             waitForNetwork: false,
         };
@@ -84,6 +64,5 @@ const resize = captureSnapshot => defineTool({
 });
 export default (captureSnapshot) => [
     close,
-    wait(captureSnapshot),
     resize(captureSnapshot)
 ];

package/lib/tools/console.js

@@ -25,7 +25,7 @@ const console = defineTool({
         type: 'readOnly',
     },
     handle: async (context) => {
-        const messages = context.currentTabOrDie().console();
+        const messages = context.currentTabOrDie().consoleMessages();
         const log = messages.map(message => `[${message.type().toUpperCase()}] ${message.text()}`).join('\n');
         return {
             code: [`// <internal code to get console messages>`],

package/lib/tools/install.js

@@ -28,7 +28,7 @@ const install = defineTool({
         type: 'destructive',
     },
     handle: async (context) => {
-        const channel = context.config.browser?.launchOptions?.channel ?? context.config.browser?.launchOptions.browserName ?? 'chrome';
+        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], {

package/lib/tools/pdf.js

@@ -17,18 +17,21 @@ import { z } from 'zod';
 import { defineTool } from './tool.js';
 import * as javascript from '../javascript.js';
 import { outputFile } from '../config.js';
+const pdfSchema = z.object({
+    filename: z.string().optional().describe('File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified.'),
+});
 const pdf = defineTool({
     capability: 'pdf',
     schema: {
         name: 'browser_pdf_save',
         title: 'Save as PDF',
         description: 'Save page as PDF',
-        inputSchema: z.object({}),
+        inputSchema: pdfSchema,
         type: 'readOnly',
     },
-    handle: async (context) => {
+    handle: async (context, params) => {
         const tab = context.currentTabOrDie();
-        const fileName = await outputFile(context.config, `page-${new Date().toISOString()}.pdf`);
+        const fileName = await outputFile(context.config, params.filename ?? `page-${new Date().toISOString()}.pdf`);
         const code = [
             `// Save page as ${fileName}`,
             `await page.pdf(${javascript.formatObject({ path: fileName })});`,

package/lib/tools/screenshot.js

@@ -0,0 +1,77 @@
+/**
+ * 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';
+import * as javascript from '../javascript.js';
+import { outputFile } from '../config.js';
+import { generateLocator } from './utils.js';
+const screenshotSchema = z.object({
+    raw: z.boolean().optional().describe('Whether to return without compression (in PNG format). Default is false, which returns a JPEG image.'),
+    filename: z.string().optional().describe('File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified.'),
+    element: z.string().optional().describe('Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too.'),
+    ref: z.string().optional().describe('Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too.'),
+}).refine(data => {
+    return !!data.element === !!data.ref;
+}, {
+    message: 'Both element and ref must be provided or neither.',
+    path: ['ref', 'element']
+});
+const screenshot = defineTool({
+    capability: 'core',
+    schema: {
+        name: 'browser_take_screenshot',
+        title: 'Take a screenshot',
+        description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
+        inputSchema: screenshotSchema,
+        type: 'readOnly',
+    },
+    handle: async (context, params) => {
+        const tab = context.currentTabOrDie();
+        const snapshot = tab.snapshotOrDie();
+        const fileType = params.raw ? 'png' : 'jpeg';
+        const fileName = await outputFile(context.config, params.filename ?? `page-${new Date().toISOString()}.${fileType}`);
+        const options = { type: fileType, quality: fileType === 'png' ? undefined : 50, scale: 'css', path: fileName };
+        const isElementScreenshot = params.element && params.ref;
+        const code = [
+            `// Screenshot ${isElementScreenshot ? params.element : 'viewport'} and save it as ${fileName}`,
+        ];
+        const locator = params.ref ? snapshot.refLocator(params.ref) : null;
+        if (locator)
+            code.push(`await page.${await generateLocator(locator)}.screenshot(${javascript.formatObject(options)});`);
+        else
+            code.push(`await page.screenshot(${javascript.formatObject(options)});`);
+        const includeBase64 = !context.config.noImageResponses;
+        const action = async () => {
+            const screenshot = locator ? await locator.screenshot(options) : await tab.page.screenshot(options);
+            return {
+                content: includeBase64 ? [{
+                        type: 'image',
+                        data: screenshot.toString('base64'),
+                        mimeType: fileType === 'png' ? 'image/png' : 'image/jpeg',
+                    }] : []
+            };
+        };
+        return {
+            code,
+            action,
+            captureSnapshot: true,
+            waitForNetwork: false,
+        };
+    }
+});
+export default [
+    screenshot,
+];