@vibebrowser/chrome-devtools-mcp 0.26.0

package/build/src/tools/performance.js

@@ -0,0 +1,196 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import zlib from 'node:zlib';
+import { logger } from '../logger.js';
+import { zod, DevTools } from '../third_party/index.js';
+import { parseRawTraceBuffer, traceResultIsSuccess, } from '../trace-processing/parse.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+const filePathSchema = zod
+    .string()
+    .optional()
+    .describe('The absolute file path, or a file path relative to the current working directory, to save the raw trace data. For example, trace.json.gz (compressed) or trace.json (uncompressed).');
+export const startTrace = definePageTool({
+    name: 'performance_start_trace',
+    description: `Start a performance trace on the selected webpage. Use to find frontend performance issues, Core Web Vitals (LCP, INP, CLS), and improve page load speed.`,
+    annotations: {
+        category: ToolCategory.PERFORMANCE,
+        readOnlyHint: false,
+    },
+    schema: {
+        reload: zod
+            .boolean()
+            .default(true)
+            .describe('Determines if, once tracing has started, the current selected page should be automatically reloaded. Navigate the page to the right URL using the navigate_page tool BEFORE starting the trace if reload or autoStop is set to true.'),
+        autoStop: zod
+            .boolean()
+            .default(true)
+            .describe('Determines if the trace recording should be automatically stopped.'),
+        filePath: filePathSchema,
+    },
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
+        if (context.isRunningPerformanceTrace()) {
+            response.appendResponseLine('Error: a performance trace is already running. Use performance_stop_trace to stop it. Only one trace can be running at any given time.');
+            return;
+        }
+        context.setIsRunningPerformanceTrace(true);
+        const page = request.page;
+        const pageUrlForTracing = page.pptrPage.url();
+        if (request.params.reload) {
+            // Before starting the recording, navigate to about:blank to clear out any state.
+            await page.pptrPage.goto('about:blank', {
+                waitUntil: ['networkidle0'],
+            });
+        }
+        // Keep in sync with the categories arrays in:
+        // https://source.chromium.org/chromium/chromium/src/+/main:third_party/devtools-frontend/src/front_end/panels/timeline/TimelineController.ts
+        // https://github.com/GoogleChrome/lighthouse/blob/master/lighthouse-core/gather/gatherers/trace.js
+        const categories = [
+            '-*',
+            'blink.console',
+            'blink.user_timing',
+            'devtools.timeline',
+            'disabled-by-default-devtools.screenshot',
+            'disabled-by-default-devtools.timeline',
+            'disabled-by-default-devtools.timeline.invalidationTracking',
+            'disabled-by-default-devtools.timeline.frame',
+            'disabled-by-default-devtools.timeline.stack',
+            'disabled-by-default-v8.cpu_profiler',
+            'disabled-by-default-v8.cpu_profiler.hires',
+            'latencyInfo',
+            'loading',
+            'disabled-by-default-lighthouse',
+            'v8.execute',
+            'v8',
+        ];
+        await page.pptrPage.tracing.start({
+            categories,
+        });
+        if (request.params.reload) {
+            await page.pptrPage.goto(pageUrlForTracing, {
+                waitUntil: ['load'],
+            });
+        }
+        if (request.params.autoStop) {
+            await new Promise(resolve => setTimeout(resolve, 5_000));
+            await stopTracingAndAppendOutput(page.pptrPage, response, context, request.params.filePath);
+        }
+        else {
+            response.appendResponseLine(`The performance trace is being recorded. Use performance_stop_trace to stop it.`);
+        }
+    },
+});
+export const stopTrace = definePageTool({
+    name: 'performance_stop_trace',
+    description: 'Stop the active performance trace recording on the selected webpage.',
+    annotations: {
+        category: ToolCategory.PERFORMANCE,
+        readOnlyHint: false,
+    },
+    schema: {
+        filePath: filePathSchema,
+    },
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
+        if (!context.isRunningPerformanceTrace()) {
+            return;
+        }
+        const page = request.page;
+        await stopTracingAndAppendOutput(page.pptrPage, response, context, request.params.filePath);
+    },
+});
+export const analyzeInsight = definePageTool({
+    name: 'performance_analyze_insight',
+    description: 'Provides more detailed information on a specific Performance Insight of an insight set that was highlighted in the results of a trace recording.',
+    annotations: {
+        category: ToolCategory.PERFORMANCE,
+        readOnlyHint: true,
+    },
+    schema: {
+        insightSetId: zod
+            .string()
+            .describe('The id for the specific insight set. Only use the ids given in the "Available insight sets" list.'),
+        insightName: zod
+            .string()
+            .describe('The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"'),
+    },
+    blockedByDialog: false,
+    handler: async (request, response, context) => {
+        const lastRecording = context.recordedTraces().at(-1);
+        if (!lastRecording) {
+            response.appendResponseLine('No recorded traces found. Record a performance trace so you have Insights to analyze.');
+            return;
+        }
+        response.attachTraceInsight(lastRecording, request.params.insightSetId, request.params.insightName);
+    },
+});
+async function stopTracingAndAppendOutput(page, response, context, filePath) {
+    try {
+        const traceEventsBuffer = await page.tracing.stop();
+        if (filePath && traceEventsBuffer) {
+            let dataToWrite = traceEventsBuffer;
+            if (filePath.endsWith('.gz')) {
+                dataToWrite = await new Promise((resolve, reject) => {
+                    zlib.gzip(traceEventsBuffer, (error, result) => {
+                        if (error) {
+                            reject(error);
+                        }
+                        else {
+                            resolve(result);
+                        }
+                    });
+                });
+            }
+            const file = await context.saveFile(dataToWrite, filePath, filePath.endsWith('.gz') ? '.json.gz' : '.json');
+            response.appendResponseLine(`The raw trace data was saved to ${file.filename}.`);
+        }
+        const result = await parseRawTraceBuffer(traceEventsBuffer);
+        response.appendResponseLine('The performance trace has been stopped.');
+        if (traceResultIsSuccess(result)) {
+            if (context.isCruxEnabled()) {
+                await populateCruxData(result);
+            }
+            context.storeTraceRecording(result);
+            response.attachTraceSummary(result);
+        }
+        else {
+            throw new Error(`There was an unexpected error parsing the trace: ${result.error}`);
+        }
+    }
+    finally {
+        context.setIsRunningPerformanceTrace(false);
+    }
+}
+/** We tell CrUXManager to fetch data so it's available when DevTools.PerformanceTraceFormatter is invoked */
+async function populateCruxData(result) {
+    logger('populateCruxData called');
+    const cruxManager = DevTools.CrUXManager.instance();
+    // go/jtfbx. Yes, we're aware this API key is public. ;)
+    cruxManager.setEndpointForTesting('https://chromeuxreport.googleapis.com/v1/records:queryRecord?key=AIzaSyBn5gimNjhiEyA_euicSKko6IlD3HdgUfk');
+    const cruxSetting = DevTools.Common.Settings.Settings.instance().createSetting('field-data', {
+        enabled: true,
+    });
+    cruxSetting.set({ enabled: true });
+    // Gather URLs to fetch CrUX data for
+    const urls = [...(result.parsedTrace.insights?.values() ?? [])].map(c => c.url.toString());
+    urls.push(result.parsedTrace.data.Meta.mainFrameURL);
+    const urlSet = new Set(urls);
+    if (urlSet.size === 0) {
+        logger('No URLs found for CrUX data');
+        return;
+    }
+    logger(`Fetching CrUX data for ${urlSet.size} URLs: ${Array.from(urlSet).join(', ')}`);
+    const cruxData = await Promise.all(Array.from(urlSet).map(async (url) => {
+        const data = await cruxManager.getFieldDataForPage(url);
+        logger(`CrUX data for ${url}: ${data ? 'found' : 'not found'}`);
+        return data;
+    }));
+    result.parsedTrace.metadata.cruxFieldData = cruxData;
+}
+//# sourceMappingURL=performance.js.map

package/build/src/tools/screencast.js

@@ -0,0 +1,95 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { zod } from '../third_party/index.js';
+import { ensureExtension } from '../utils/files.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+async function generateTempFilePath() {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), 'chrome-devtools-mcp-'));
+    return path.join(dir, `screencast.mp4`);
+}
+const supportedExtensions = ['.webm', '.mp4'];
+export const startScreencast = definePageTool(args => ({
+    name: 'screencast_start',
+    description: `Starts recording a screencast (video) of the selected page in specified format.`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+        conditions: ['experimentalScreencast'],
+    },
+    schema: {
+        filePath: zod
+            .string()
+            .optional()
+            .describe(`Output file path (${supportedExtensions.join(',')} are supported). Uses mkdtemp to generate a unique path if not provided.`),
+    },
+    blockedByDialog: false,
+    handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
+        if (context.getScreenRecorder() !== null) {
+            response.appendResponseLine('Error: a screencast recording is already in progress. Use screencast_stop to stop it before starting a new one.');
+            return;
+        }
+        const filePath = request.params.filePath ?? (await generateTempFilePath());
+        let enforcedExtension = '.mp4';
+        let format = 'mp4';
+        for (const supportedExtension of supportedExtensions) {
+            if (filePath.endsWith(supportedExtension)) {
+                enforcedExtension = supportedExtension;
+                format = supportedExtension.substring(1);
+                break;
+            }
+        }
+        const resolvedPath = ensureExtension(path.resolve(filePath), enforcedExtension);
+        const page = request.page;
+        let recorder;
+        try {
+            recorder = await page.pptrPage.screencast({
+                path: resolvedPath,
+                format: format,
+                ffmpegPath: args?.experimentalFfmpegPath,
+            });
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            if (message.includes('ENOENT') && message.includes('ffmpeg')) {
+                throw new Error('ffmpeg is required for screencast recording but was not found. ' +
+                    'Install ffmpeg (https://ffmpeg.org/) and ensure it is available in your PATH.');
+            }
+            throw err;
+        }
+        context.setScreenRecorder({ recorder, filePath: resolvedPath });
+        response.appendResponseLine(`Screencast recording started. The recording will be saved to ${resolvedPath}. Use ${stopScreencast.name} to stop recording.`);
+    },
+}));
+export const stopScreencast = definePageTool({
+    name: 'screencast_stop',
+    description: 'Stops the active screencast recording on the selected page.',
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+        conditions: ['experimentalScreencast'],
+    },
+    schema: {},
+    blockedByDialog: false,
+    handler: async (_request, response, context) => {
+        const data = context.getScreenRecorder();
+        if (!data) {
+            return;
+        }
+        try {
+            await data.recorder.stop();
+            response.appendResponseLine(`The screencast recording has been stopped and saved to ${data.filePath}.`);
+        }
+        finally {
+            context.setScreenRecorder(null);
+        }
+    },
+});
+//# sourceMappingURL=screencast.js.map

package/build/src/tools/screenshot.js

@@ -0,0 +1,87 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+export const screenshot = definePageTool({
+    name: 'take_screenshot',
+    description: `Take a screenshot of the page or element.`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        // Not read-only due to filePath param.
+        readOnlyHint: false,
+    },
+    schema: {
+        format: zod
+            .enum(['png', 'jpeg', 'webp'])
+            .default('png')
+            .describe('Type of format to save the screenshot as. Default is "png"'),
+        quality: zod
+            .number()
+            .min(0)
+            .max(100)
+            .optional()
+            .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
+        uid: zod
+            .string()
+            .optional()
+            .describe('The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.'),
+        fullPage: zod
+            .boolean()
+            .optional()
+            .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
+        filePath: zod
+            .string()
+            .optional()
+            .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
+    },
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
+        if (request.params.uid && request.params.fullPage) {
+            throw new Error('Providing both "uid" and "fullPage" is not allowed.');
+        }
+        let pageOrHandle;
+        if (request.params.uid) {
+            pageOrHandle = await request.page.getElementByUid(request.params.uid);
+        }
+        else {
+            pageOrHandle = request.page.pptrPage;
+        }
+        const format = request.params.format;
+        const quality = format === 'png' ? undefined : request.params.quality;
+        const screenshot = await pageOrHandle.screenshot({
+            type: format,
+            fullPage: request.params.fullPage,
+            quality,
+            optimizeForSpeed: true, // Bonus: optimize encoding for speed
+        });
+        if (request.params.uid) {
+            response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
+        }
+        else if (request.params.fullPage) {
+            response.appendResponseLine('Took a screenshot of the full current page.');
+        }
+        else {
+            response.appendResponseLine("Took a screenshot of the current page's viewport.");
+        }
+        if (request.params.filePath) {
+            const result = await context.saveFile(screenshot, request.params.filePath, `.${format}`);
+            response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
+        }
+        else if (screenshot.length >= 2_000_000) {
+            const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.${request.params.format}`);
+            response.appendResponseLine(`Saved screenshot to ${filepath}.`);
+        }
+        else {
+            response.attachImage({
+                mimeType: `image/${request.params.format}`,
+                data: Buffer.from(screenshot).toString('base64'),
+            });
+        }
+    },
+});
+//# sourceMappingURL=screenshot.js.map

package/build/src/tools/script.js

@@ -0,0 +1,151 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { defineTool, pageIdSchema } from './ToolDefinition.js';
+export const evaluateScript = defineTool(cliArgs => {
+    return {
+        name: 'evaluate_script',
+        description: `Evaluate a JavaScript function inside the currently selected page${cliArgs?.categoryExtensions ? ' or service worker' : ''}. Returns the response as JSON,
+so returned values have to be JSON-serializable.`,
+        annotations: {
+            category: ToolCategory.DEBUGGING,
+            readOnlyHint: false,
+        },
+        schema: {
+            function: zod.string().describe(`A JavaScript function declaration to be executed by the tool in the currently selected page.
+Example without arguments: \`() => {
+  return document.title
+}\` or \`async () => {
+  return await fetch("example.com")
+}\`.
+Example with arguments: \`(el) => {
+  return el.innerText;
+}\`
+`),
+            args: zod
+                .array(zod
+                .string()
+                .describe('The uid of an element on the page from the page content snapshot'))
+                .optional()
+                .describe(`An optional list of arguments to pass to the function.`),
+            filePath: zod
+                .string()
+                .optional()
+                .describe('The absolute or relative path to a file to save the script output to. If omitted, the output is returned inline.'),
+            dialogAction: zod
+                .string()
+                .optional()
+                .describe('Handle dialogs while execution. "accept", "dismiss", or string for response of window.prompt. Defaults to accept.'),
+            ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
+            ...(cliArgs?.categoryExtensions
+                ? {
+                    serviceWorkerId: zod
+                        .string()
+                        .optional()
+                        .describe(`The optional service worker id to evaluate the script in. If provided, 'pageId' should be omitted. Note: 'args' (element UIDs) cannot be used when evaluating in a service worker.`),
+                }
+                : {}),
+        },
+        blockedByDialog: true,
+        handler: async (request, response, context) => {
+            const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, filePath, } = request.params;
+            context.validatePath(filePath);
+            if (cliArgs?.categoryExtensions && serviceWorkerId) {
+                if (uidArgs && uidArgs.length > 0) {
+                    throw new Error('args (element uids) cannot be used when evaluating in a service worker.');
+                }
+                if (pageId) {
+                    throw new Error('specify either a pageId or a serviceWorkerId.');
+                }
+                const worker = await getWebWorker(context, serviceWorkerId);
+                const result = await context
+                    .getSelectedMcpPage()
+                    .waitForEventsAfterAction(async () => {
+                    await performEvaluation(worker, fnString, [], response, {
+                        filePath,
+                        context,
+                    });
+                }, { handleDialog: dialogAction ?? 'accept' });
+                response.attachWaitForResult(result);
+                return;
+            }
+            const mcpPage = cliArgs?.experimentalPageIdRouting
+                ? context.getPageById(request.params.pageId)
+                : context.getSelectedMcpPage();
+            const page = mcpPage.pptrPage;
+            const args = [];
+            try {
+                const frames = new Set();
+                for (const uid of uidArgs ?? []) {
+                    const handle = await mcpPage.getElementByUid(uid);
+                    frames.add(handle.frame);
+                    args.push(handle);
+                }
+                const evaluatable = await getPageOrFrame(page, frames);
+                const result = await mcpPage.waitForEventsAfterAction(async () => {
+                    await performEvaluation(evaluatable, fnString, args, response, {
+                        filePath,
+                        context,
+                    });
+                }, { handleDialog: dialogAction ?? 'accept' });
+                response.attachWaitForResult(result);
+            }
+            finally {
+                void Promise.allSettled(args.map(arg => arg.dispose()));
+            }
+        },
+    };
+});
+const performEvaluation = async (evaluatable, fnString, args, response, options) => {
+    const fn = await evaluatable.evaluateHandle(`(${fnString})`);
+    try {
+        const result = await evaluatable.evaluate(async (fn, ...args) => {
+            // @ts-expect-error no types for function fn
+            return JSON.stringify(await fn(...args));
+        }, fn, ...args);
+        if (options?.filePath) {
+            const data = new TextEncoder().encode(result ?? 'undefined');
+            const { filename } = await options.context.saveFile(data, options.filePath, '.json');
+            response.appendResponseLine(`Script ran on page. Output saved to ${filename}.`);
+        }
+        else {
+            response.appendResponseLine('Script ran on page and returned:');
+            response.appendResponseLine('```json');
+            response.appendResponseLine(`${result}`);
+            response.appendResponseLine('```');
+        }
+    }
+    finally {
+        void fn.dispose();
+    }
+};
+const getPageOrFrame = async (page, frames) => {
+    let pageOrFrame;
+    // We can't evaluate the element handle across frames
+    if (frames.size > 1) {
+        throw new Error("Elements from different frames can't be evaluated together.");
+    }
+    else {
+        pageOrFrame = [...frames.values()][0] ?? page;
+    }
+    return pageOrFrame;
+};
+const getWebWorker = async (context, serviceWorkerId) => {
+    const serviceWorkers = context.getExtensionServiceWorkers();
+    const serviceWorker = serviceWorkers.find((sw) => context.getExtensionServiceWorkerId(sw) === serviceWorkerId);
+    if (serviceWorker && serviceWorker.target) {
+        const worker = await serviceWorker.target.worker();
+        if (!worker) {
+            throw new Error('Service worker target not found.');
+        }
+        return worker;
+    }
+    else {
+        throw new Error('Service worker not found.');
+    }
+};
+//# sourceMappingURL=script.js.map

package/build/src/tools/slim/tools.js

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../../third_party/index.js';
+import { ToolCategory } from '../categories.js';
+import { definePageTool } from '../ToolDefinition.js';
+export const screenshot = definePageTool({
+    name: 'screenshot',
+    description: `Takes a screenshot`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        // Not read-only due to filePath param.
+        readOnlyHint: false,
+    },
+    schema: {},
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        const page = request.page;
+        const screenshot = await page.pptrPage.screenshot({
+            type: 'png',
+            optimizeForSpeed: true,
+        });
+        const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.png`);
+        response.appendResponseLine(filepath);
+    },
+});
+export const navigate = definePageTool({
+    name: 'navigate',
+    description: `Loads a URL`,
+    annotations: {
+        category: ToolCategory.NAVIGATION,
+        readOnlyHint: false,
+    },
+    schema: {
+        url: zod.string().describe('URL to navigate to'),
+    },
+    blockedByDialog: false,
+    handler: async (request, response) => {
+        const page = request.page;
+        const options = {
+            timeout: 30_000,
+        };
+        const dialogHandler = (dialog) => {
+            if (dialog.type() === 'beforeunload') {
+                response.appendResponseLine(`Accepted a beforeunload dialog.`);
+                void dialog.accept();
+                // We are not going to report the dialog like regular dialogs.
+                page.clearDialog();
+            }
+        };
+        page.pptrPage.on('dialog', dialogHandler);
+        try {
+            await page.pptrPage.goto(request.params.url, options);
+            response.appendResponseLine(`Navigated to ${page.pptrPage.url()}.`);
+        }
+        finally {
+            page.pptrPage.off('dialog', dialogHandler);
+        }
+    },
+});
+export const evaluate = definePageTool({
+    name: 'evaluate',
+    description: `Evaluates a JavaScript script`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: false,
+    },
+    schema: {
+        script: zod.string().describe(`JS script to run on the page`),
+    },
+    blockedByDialog: true,
+    handler: async (request, response) => {
+        const page = request.page;
+        try {
+            const result = await page.pptrPage.evaluate(request.params.script);
+            response.appendResponseLine(JSON.stringify(result));
+        }
+        catch (err) {
+            response.appendResponseLine(String(err.message));
+        }
+    },
+});
+//# sourceMappingURL=tools.js.map

package/build/src/tools/snapshot.js

@@ -0,0 +1,60 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool, timeoutSchema } from './ToolDefinition.js';
+export const takeSnapshot = definePageTool({
+    name: 'take_snapshot',
+    description: `Take a text snapshot of the currently selected page based on the a11y tree. The snapshot lists page elements along with a unique
+identifier (uid). Always use the latest snapshot. Prefer taking a snapshot over taking a screenshot. The snapshot indicates the element selected
+in the DevTools Elements panel (if any).`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        // Not read-only due to filePath param.
+        readOnlyHint: false,
+    },
+    schema: {
+        verbose: zod
+            .boolean()
+            .optional()
+            .describe('Whether to include all possible information available in the full a11y tree. Default is false.'),
+        filePath: zod
+            .string()
+            .optional()
+            .describe('The absolute path, or a path relative to the current working directory, to save the snapshot to instead of attaching it to the response.'),
+    },
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        context.validatePath(request.params.filePath);
+        response.includeSnapshot({
+            verbose: request.params.verbose ?? false,
+            filePath: request.params.filePath,
+        });
+    },
+});
+export const waitFor = definePageTool({
+    name: 'wait_for',
+    description: `Wait for the specified text to appear on the selected page.`,
+    annotations: {
+        category: ToolCategory.NAVIGATION,
+        readOnlyHint: true,
+    },
+    schema: {
+        text: zod
+            .array(zod.string())
+            .min(1)
+            .describe('Non-empty list of texts. Resolves when any value appears on the page.'),
+        ...timeoutSchema,
+    },
+    blockedByDialog: true,
+    handler: async (request, response, context) => {
+        const page = request.page;
+        await context.waitForTextOnPage(request.params.text, request.params.timeout, page.pptrPage);
+        response.appendResponseLine(`Element matching one of ${JSON.stringify(request.params.text)} found.`);
+        response.includeSnapshot();
+    },
+});
+//# sourceMappingURL=snapshot.js.map