@gabrielbryk/arc-devtools-mcp 1.3.0

package/build/src/tools/screencast.js

@@ -0,0 +1,117 @@
+/**
+ * @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,
+    verifyFilesSchema: ['filePath'],
+    handler: async (request, response, context) => {
+        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 requestedFilePath = request.params.filePath;
+        const filePath = requestedFilePath ?? (await generateTempFilePath());
+        // Match the extension case-insensitively so e.g. `.WEBM` is recognized as
+        // WebM. An explicitly requested but unsupported extension is rejected
+        // rather than being silently rewritten to `.mp4` (which would change both
+        // the format and the output path from what was requested). A missing
+        // extension falls back to `.mp4`. The matched extension is normalized to
+        // lower case.
+        const requestedExtension = path.extname(filePath);
+        const matchedExtension = supportedExtensions.find(supportedExtension => supportedExtension === requestedExtension.toLowerCase());
+        if (!matchedExtension && requestedExtension !== '') {
+            throw new Error(`Unsupported screencast file extension "${requestedExtension}". ` +
+                `Supported formats: ${supportedExtensions.join(', ')} (case-insensitive).`);
+        }
+        const enforcedExtension = matchedExtension ?? '.mp4';
+        const format = (matchedExtension?.substring(1) ??
+            'mp4');
+        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) {
+            // If we generated a temporary directory for this recording, remove it so
+            // a failed start (e.g. ffmpeg missing) does not leak an empty directory.
+            if (requestedFilePath === undefined) {
+                try {
+                    await fs.rm(path.dirname(resolvedPath), {
+                        recursive: true,
+                        force: true,
+                    });
+                }
+                catch {
+                    // no-op
+                }
+            }
+            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,
+    verifyFilesSchema: [],
+    handler: async (_request, response, context) => {
+        const data = context.getScreenRecorder();
+        if (!data) {
+            response.appendResponseLine('Error: no active screencast recording to stop.');
+            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,169 @@
+/**
+ * @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';
+async function getSourceBox(page, element, fullPage) {
+    if (element) {
+        const box = await element.boundingBox();
+        return box ?? undefined;
+    }
+    if (fullPage) {
+        const dims = await page.evaluate(() => ({
+            width: Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0),
+            height: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0),
+        }));
+        if (dims.width <= 0 || dims.height <= 0) {
+            return undefined;
+        }
+        return { x: 0, y: 0, width: dims.width, height: dims.height };
+    }
+    const viewport = page.viewport();
+    if (!viewport) {
+        return undefined;
+    }
+    return { x: 0, y: 0, width: viewport.width, height: viewport.height };
+}
+function computeDownscaleClip(box, maxWidth, maxHeight) {
+    const widthScale = maxWidth !== undefined ? Math.min(1, maxWidth / box.width) : 1;
+    const heightScale = maxHeight !== undefined ? Math.min(1, maxHeight / box.height) : 1;
+    const scale = Math.min(widthScale, heightScale);
+    if (scale >= 1) {
+        return undefined;
+    }
+    // Skip degenerate sub-pixel results.
+    if (Math.round(box.width * scale) < 1 || Math.round(box.height * scale) < 1) {
+        return undefined;
+    }
+    return {
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: box.height,
+        scale,
+    };
+}
+export const screenshot = definePageTool(args => {
+    const { screenshotFormat, screenshotQuality, screenshotMaxWidth, screenshotMaxHeight, } = args ?? {};
+    const defaultFormat = screenshotFormat ?? 'png';
+    return {
+        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(defaultFormat)
+                .describe(`Type of format to save the screenshot as. Default is "${defaultFormat}"`),
+            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,
+        verifyFilesSchema: ['filePath'],
+        handler: async (request, response, context) => {
+            if (request.params.uid && request.params.fullPage) {
+                throw new Error('Providing both "uid" and "fullPage" is not allowed.');
+            }
+            const page = request.page.pptrPage;
+            const element = request.params.uid
+                ? await request.page.getElementByUid(request.params.uid)
+                : undefined;
+            const format = request.params.format;
+            const quality = format === 'png'
+                ? undefined
+                : (request.params.quality ?? screenshotQuality);
+            const fullPage = request.params.fullPage ?? false;
+            // Compute a downscale clip when --screenshot-max-width or
+            // --screenshot-max-height is set and the source exceeds either bound.
+            // The smaller scale factor wins so both bounds are respected while
+            // preserving aspect ratio.
+            let clip;
+            if (screenshotMaxWidth !== undefined ||
+                screenshotMaxHeight !== undefined) {
+                const box = await getSourceBox(page, element, fullPage);
+                if (box) {
+                    clip = computeDownscaleClip(box, screenshotMaxWidth, screenshotMaxHeight);
+                }
+            }
+            let screenshot;
+            if (clip) {
+                // page.screenshot with clip lets the CDP scale param downscale the
+                // capture for viewport, full-page and element shots alike. We rely on
+                // Puppeteer's default of captureBeyondViewport=true when a clip is
+                // present so element/full-page captures below the fold still work.
+                screenshot = await page.screenshot({
+                    type: format,
+                    quality,
+                    optimizeForSpeed: true,
+                    clip,
+                });
+            }
+            else if (element) {
+                screenshot = await element.screenshot({
+                    type: format,
+                    quality,
+                    optimizeForSpeed: true,
+                });
+            }
+            else {
+                screenshot = await page.screenshot({
+                    type: format,
+                    fullPage,
+                    quality,
+                    optimizeForSpeed: true,
+                });
+            }
+            if (request.params.uid) {
+                response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
+            }
+            else if (fullPage) {
+                response.appendResponseLine('Took a screenshot of the full current page.');
+            }
+            else {
+                response.appendResponseLine("Took a screenshot of the current page's viewport.");
+            }
+            // Narrow `format` at the point of use: in the factory form of
+            // definePageTool TS widens the Schema generic, which loses the literal
+            // union from zod.enum on request.params.format.
+            const extension = format === 'jpeg' ? '.jpeg' : format === 'webp' ? '.webp' : '.png';
+            if (request.params.filePath) {
+                const result = await context.saveFile(screenshot, request.params.filePath, extension);
+                response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
+            }
+            else if (screenshot.length >= 2_000_000) {
+                const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot${extension}`);
+                response.appendResponseLine(`Saved screenshot to ${filepath}.`);
+            }
+            else {
+                response.attachImage({
+                    mimeType: `image/${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: {
+            ...(cliArgs?.experimentalPageIdRouting ? pageIdSchema : {}),
+            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?.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,
+        verifyFilesSchema: ['filePath'],
+        handler: async (request, response, context) => {
+            const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, filePath, } = request.params;
+            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,88 @@
+/**
+ * @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,
+    verifyFilesSchema: [],
+    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,
+    verifyFilesSchema: [],
+    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,
+    verifyFilesSchema: [],
+    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,61 @@
+/**
+ * @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,
+    verifyFilesSchema: ['filePath'],
+    handler: async (request, response) => {
+        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,
+    verifyFilesSchema: [],
+    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

package/build/src/tools/thirdPartyDeveloper.js

@@ -0,0 +1,85 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { zod, ajv } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
+import { definePageTool } from './ToolDefinition.js';
+export const listThirdPartyDeveloperTools = definePageTool({
+    name: 'list_3p_developer_tools',
+    description: `Lists all third-party developer tools the page exposes for providing runtime information.
+  Third-party developer tools can be called via the 'execute_3p_developer_tool()' MCP tool.
+  Alternatively, third-party developer tools can be executed by calling 'evaluate_script' and adding the
+  following command to the script:
+  'window.__dtmcp.executeTool(toolName, params)'
+  This might be helpful when the third-party developer tools return non-serializable values or when composing
+  third-party developer tools with additional functionality.`,
+    annotations: {
+        category: ToolCategory.THIRD_PARTY,
+        readOnlyHint: true,
+    },
+    schema: {},
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (_request, response, _context) => {
+        response.setListThirdPartyDeveloperTools();
+    },
+});
+export const executeThirdPartyDeveloperTool = definePageTool({
+    name: 'execute_3p_developer_tool',
+    description: `Executes a tool exposed by the page.`,
+    annotations: {
+        category: ToolCategory.THIRD_PARTY,
+        readOnlyHint: false,
+    },
+    schema: {
+        toolName: zod.string().describe('The name of the tool to execute'),
+        params: zod
+            .string()
+            .optional()
+            .describe('The JSON-stringified parameters to pass to the tool'),
+    },
+    blockedByDialog: false,
+    verifyFilesSchema: [],
+    handler: async (request, response) => {
+        const toolName = request.params.toolName;
+        let params = {};
+        if (request.params.params) {
+            try {
+                const parsed = JSON.parse(request.params.params);
+                if (typeof parsed === 'object' && parsed !== null) {
+                    params = parsed;
+                }
+                else {
+                    throw new Error('Parsed params is not an object');
+                }
+            }
+            catch (e) {
+                const errorMessage = e instanceof Error ? e.message : String(e);
+                throw new Error(`Failed to parse params as JSON: ${errorMessage}`);
+            }
+        }
+        const toolGroups = request.page.getThirdPartyDeveloperTools();
+        let tool;
+        if (toolGroups) {
+            for (const group of toolGroups) {
+                tool = group.tools?.find(t => t.name === toolName);
+                if (tool) {
+                    break;
+                }
+            }
+        }
+        if (!tool) {
+            throw new Error(`Tool ${toolName} not found`);
+        }
+        const ajvInstance = new ajv();
+        const validate = ajvInstance.compile(tool.inputSchema);
+        const valid = validate(params);
+        if (!valid) {
+            throw new Error(`Invalid parameters for tool ${toolName}: ${ajvInstance.errorsText(validate.errors)}`);
+        }
+        await request.page.executeThirdPartyDeveloperTool(toolName, params, response);
+    },
+});
+//# sourceMappingURL=thirdPartyDeveloper.js.map