chrome-devtools-mcp 0.8.1 → 0.9.0

package/build/src/tools/ToolDefinition.js

@@ -3,13 +3,13 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import z from 'zod';
+import { zod } from '../third_party/index.js';
 export function defineTool(definition) {
     return definition;
 }
 export const CLOSE_PAGE_ERROR = 'The last open page cannot be closed. It is fine to keep it open.';
 export const timeoutSchema = {
-    timeout: z
+    timeout: zod
         .number()
         .int()
         .optional()

package/build/src/tools/categories.js

@@ -3,12 +3,20 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-export var ToolCategories;
-(function (ToolCategories) {
-    ToolCategories["INPUT_AUTOMATION"] = "Input automation";
-    ToolCategories["NAVIGATION_AUTOMATION"] = "Navigation automation";
-    ToolCategories["EMULATION"] = "Emulation";
-    ToolCategories["PERFORMANCE"] = "Performance";
-    ToolCategories["NETWORK"] = "Network";
-    ToolCategories["DEBUGGING"] = "Debugging";
-})(ToolCategories || (ToolCategories = {}));
+export var ToolCategory;
+(function (ToolCategory) {
+    ToolCategory["INPUT"] = "input";
+    ToolCategory["NAVIGATION"] = "navigation";
+    ToolCategory["EMULATION"] = "emulation";
+    ToolCategory["PERFORMANCE"] = "performance";
+    ToolCategory["NETWORK"] = "network";
+    ToolCategory["DEBUGGING"] = "debugging";
+})(ToolCategory || (ToolCategory = {}));
+export const labels = {
+    [ToolCategory.INPUT]: 'Input automation',
+    [ToolCategory.NAVIGATION]: 'Navigation automation',
+    [ToolCategory.EMULATION]: 'Emulation',
+    [ToolCategory.PERFORMANCE]: 'Performance',
+    [ToolCategory.NETWORK]: 'Network',
+    [ToolCategory.DEBUGGING]: 'Debugging',
+};

package/build/src/tools/console.js

@@ -3,17 +3,82 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { ToolCategories } from './categories.js';
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
-export const consoleTool = defineTool({
+const FILTERABLE_MESSAGE_TYPES = [
+    'log',
+    'debug',
+    'info',
+    'error',
+    'warn',
+    'dir',
+    'dirxml',
+    'table',
+    'trace',
+    'clear',
+    'startGroup',
+    'startGroupCollapsed',
+    'endGroup',
+    'assert',
+    'profile',
+    'profileEnd',
+    'count',
+    'timeEnd',
+    'verbose',
+];
+export const listConsoleMessages = defineTool({
     name: 'list_console_messages',
     description: 'List all console messages for the currently selected page since the last navigation.',
     annotations: {
-        category: ToolCategories.DEBUGGING,
+        category: ToolCategory.DEBUGGING,
         readOnlyHint: true,
     },
-    schema: {},
-    handler: async (_request, response) => {
-        response.setIncludeConsoleData(true);
+    schema: {
+        pageSize: zod
+            .number()
+            .int()
+            .positive()
+            .optional()
+            .describe('Maximum number of messages to return. When omitted, returns all requests.'),
+        pageIdx: zod
+            .number()
+            .int()
+            .min(0)
+            .optional()
+            .describe('Page number to return (0-based). When omitted, returns the first page.'),
+        types: zod
+            .array(zod.enum(FILTERABLE_MESSAGE_TYPES))
+            .optional()
+            .describe('Filter messages to only return messages of the specified resource types. When omitted or empty, returns all messages.'),
+        includePreservedMessages: zod
+            .boolean()
+            .default(false)
+            .optional()
+            .describe('Set to true to return the preserved messages over the last 3 navigations.'),
+    },
+    handler: async (request, response) => {
+        response.setIncludeConsoleData(true, {
+            pageSize: request.params.pageSize,
+            pageIdx: request.params.pageIdx,
+            types: request.params.types,
+            includePreservedMessages: request.params.includePreservedMessages,
+        });
+    },
+});
+export const getConsoleMessage = defineTool({
+    name: 'get_console_message',
+    description: `Gets a console message by its ID. You can get all messages by calling ${listConsoleMessages.name}.`,
+    annotations: {
+        category: ToolCategory.DEBUGGING,
+        readOnlyHint: true,
+    },
+    schema: {
+        msgid: zod
+            .number()
+            .describe('The msgid of a console message on the page from the listed console messages'),
+    },
+    handler: async (request, response) => {
+        response.attachConsoleMessage(request.params.msgid);
     },
 });

package/build/src/tools/emulation.js

@@ -3,9 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { PredefinedNetworkConditions } from 'puppeteer-core';
-import z from 'zod';
-import { ToolCategories } from './categories.js';
+import { zod, PredefinedNetworkConditions } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
 const throttlingOptions = [
     'No emulation',
@@ -16,11 +15,11 @@ export const emulateNetwork = defineTool({
     name: 'emulate_network',
     description: `Emulates network conditions such as throttling or offline mode on the selected page.`,
     annotations: {
-        category: ToolCategories.EMULATION,
+        category: ToolCategory.EMULATION,
         readOnlyHint: false,
     },
     schema: {
-        throttlingOption: z
+        throttlingOption: zod
             .enum(throttlingOptions)
             .describe(`The network throttling option to emulate. Available throttling options are: ${throttlingOptions.join(', ')}. Set to "No emulation" to disable. Set to "Offline" to simulate offline network conditions.`),
     },
@@ -53,11 +52,11 @@ export const emulateCpu = defineTool({
     name: 'emulate_cpu',
     description: `Emulates CPU throttling by slowing down the selected page's execution.`,
     annotations: {
-        category: ToolCategories.EMULATION,
+        category: ToolCategory.EMULATION,
         readOnlyHint: false,
     },
     schema: {
-        throttlingRate: z
+        throttlingRate: zod
             .number()
             .min(1)
             .max(20)

package/build/src/tools/input.js

@@ -3,21 +3,21 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import z from 'zod';
-import { ToolCategories } from './categories.js';
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
 export const click = defineTool({
     name: 'click',
     description: `Clicks on the provided element`,
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        uid: z
+        uid: zod
             .string()
             .describe('The uid of an element on the page from the page content snapshot'),
-        dblClick: z
+        dblClick: zod
             .boolean()
             .optional()
             .describe('Set to true for double clicks. Default is false.'),
@@ -45,11 +45,11 @@ export const hover = defineTool({
     name: 'hover',
     description: `Hover over the provided element`,
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        uid: z
+        uid: zod
             .string()
             .describe('The uid of an element on the page from the page content snapshot'),
     },
@@ -121,14 +121,14 @@ export const fill = defineTool({
     name: 'fill',
     description: `Type text into a input, text area or select an option from a <select> element.`,
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        uid: z
+        uid: zod
             .string()
             .describe('The uid of an element on the page from the page content snapshot'),
-        value: z.string().describe('The value to fill in'),
+        value: zod.string().describe('The value to fill in'),
     },
     handler: async (request, response, context) => {
         await context.waitForEventsAfterAction(async () => {
@@ -142,12 +142,12 @@ export const drag = defineTool({
     name: 'drag',
     description: `Drag an element onto another element`,
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        from_uid: z.string().describe('The uid of the element to drag'),
-        to_uid: z.string().describe('The uid of the element to drop into'),
+        from_uid: zod.string().describe('The uid of the element to drag'),
+        to_uid: zod.string().describe('The uid of the element to drop into'),
     },
     handler: async (request, response, context) => {
         const fromHandle = await context.getElementByUid(request.params.from_uid);
@@ -171,14 +171,14 @@ export const fillForm = defineTool({
     name: 'fill_form',
     description: `Fill out multiple form elements at once`,
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        elements: z
-            .array(z.object({
-            uid: z.string().describe('The uid of the element to fill out'),
-            value: z.string().describe('Value for the element'),
+        elements: zod
+            .array(zod.object({
+            uid: zod.string().describe('The uid of the element to fill out'),
+            value: zod.string().describe('Value for the element'),
         }))
             .describe('Elements from snapshot to fill out.'),
     },
@@ -196,14 +196,14 @@ export const uploadFile = defineTool({
     name: 'upload_file',
     description: 'Upload a file through a provided element.',
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        uid: z
+        uid: zod
             .string()
             .describe('The uid of the file input element or an element that will open file chooser on the page from the page content snapshot'),
-        filePath: z.string().describe('The local path of the file to upload'),
+        filePath: zod.string().describe('The local path of the file to upload'),
     },
     handler: async (request, response, context) => {
         const { uid, filePath } = request.params;

package/build/src/tools/network.js

@@ -3,8 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import z from 'zod';
-import { ToolCategories } from './categories.js';
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
 const FILTERABLE_RESOURCE_TYPES = [
     'document',
@@ -31,32 +31,38 @@ export const listNetworkRequests = defineTool({
     name: 'list_network_requests',
     description: `List all requests for the currently selected page since the last navigation.`,
     annotations: {
-        category: ToolCategories.NETWORK,
+        category: ToolCategory.NETWORK,
         readOnlyHint: true,
     },
     schema: {
-        pageSize: z
+        pageSize: zod
             .number()
             .int()
             .positive()
             .optional()
             .describe('Maximum number of requests to return. When omitted, returns all requests.'),
-        pageIdx: z
+        pageIdx: zod
             .number()
             .int()
             .min(0)
             .optional()
             .describe('Page number to return (0-based). When omitted, returns the first page.'),
-        resourceTypes: z
-            .array(z.enum(FILTERABLE_RESOURCE_TYPES))
+        resourceTypes: zod
+            .array(zod.enum(FILTERABLE_RESOURCE_TYPES))
             .optional()
             .describe('Filter requests to only return requests of the specified resource types. When omitted or empty, returns all requests.'),
+        includePreservedRequests: zod
+            .boolean()
+            .default(false)
+            .optional()
+            .describe('Set to true to return the preserved requests over the last 3 navigations.'),
     },
     handler: async (request, response) => {
         response.setIncludeNetworkRequests(true, {
             pageSize: request.params.pageSize,
             pageIdx: request.params.pageIdx,
             resourceTypes: request.params.resourceTypes,
+            includePreservedRequests: request.params.includePreservedRequests,
         });
     },
 });
@@ -64,13 +70,15 @@ export const getNetworkRequest = defineTool({
     name: 'get_network_request',
     description: `Gets a network request by URL. You can get all requests by calling ${listNetworkRequests.name}.`,
     annotations: {
-        category: ToolCategories.NETWORK,
+        category: ToolCategory.NETWORK,
         readOnlyHint: true,
     },
     schema: {
-        url: z.string().describe('The URL of the request.'),
+        reqid: zod
+            .number()
+            .describe('The reqid of a request on the page from the listed network requests'),
     },
     handler: async (request, response, _context) => {
-        response.attachNetworkRequest(request.params.url);
+        response.attachNetworkRequest(request.params.reqid);
     },
 });

package/build/src/tools/pages.js

@@ -3,15 +3,15 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import z from 'zod';
 import { logger } from '../logger.js';
-import { ToolCategories } from './categories.js';
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
 import { CLOSE_PAGE_ERROR, defineTool, timeoutSchema } from './ToolDefinition.js';
 export const listPages = defineTool({
     name: 'list_pages',
     description: `Get a list of pages open in the browser.`,
     annotations: {
-        category: ToolCategories.NAVIGATION_AUTOMATION,
+        category: ToolCategory.NAVIGATION,
         readOnlyHint: true,
     },
     schema: {},
@@ -23,11 +23,11 @@ export const selectPage = defineTool({
     name: 'select_page',
     description: `Select a page as a context for future tool calls.`,
     annotations: {
-        category: ToolCategories.NAVIGATION_AUTOMATION,
+        category: ToolCategory.NAVIGATION,
         readOnlyHint: true,
     },
     schema: {
-        pageIdx: z
+        pageIdx: zod
             .number()
             .describe('The index of the page to select. Call list_pages to list pages.'),
     },
@@ -42,11 +42,11 @@ export const closePage = defineTool({
     name: 'close_page',
     description: `Closes the page by its index. The last open page cannot be closed.`,
     annotations: {
-        category: ToolCategories.NAVIGATION_AUTOMATION,
+        category: ToolCategory.NAVIGATION,
         readOnlyHint: false,
     },
     schema: {
-        pageIdx: z
+        pageIdx: zod
             .number()
             .describe('The index of the page to close. Call list_pages to list pages.'),
     },
@@ -69,11 +69,11 @@ export const newPage = defineTool({
     name: 'new_page',
     description: `Creates a new page`,
     annotations: {
-        category: ToolCategories.NAVIGATION_AUTOMATION,
+        category: ToolCategory.NAVIGATION,
         readOnlyHint: false,
     },
     schema: {
-        url: z.string().describe('URL to load in a new page.'),
+        url: zod.string().describe('URL to load in a new page.'),
         ...timeoutSchema,
     },
     handler: async (request, response, context) => {
@@ -90,11 +90,11 @@ export const navigatePage = defineTool({
     name: 'navigate_page',
     description: `Navigates the currently selected page to a URL.`,
     annotations: {
-        category: ToolCategories.NAVIGATION_AUTOMATION,
+        category: ToolCategory.NAVIGATION,
         readOnlyHint: false,
     },
     schema: {
-        url: z.string().describe('URL to navigate the page to'),
+        url: zod.string().describe('URL to navigate the page to'),
         ...timeoutSchema,
     },
     handler: async (request, response, context) => {
@@ -111,11 +111,11 @@ export const navigatePageHistory = defineTool({
     name: 'navigate_page_history',
     description: `Navigates the currently selected page.`,
     annotations: {
-        category: ToolCategories.NAVIGATION_AUTOMATION,
+        category: ToolCategory.NAVIGATION,
         readOnlyHint: false,
     },
     schema: {
-        navigate: z
+        navigate: zod
             .enum(['back', 'forward'])
             .describe('Whether to navigate back or navigate forward in the selected pages history'),
         ...timeoutSchema,
@@ -143,12 +143,12 @@ export const resizePage = defineTool({
     name: 'resize_page',
     description: `Resizes the selected page's window so that the page has specified dimension`,
     annotations: {
-        category: ToolCategories.EMULATION,
+        category: ToolCategory.EMULATION,
         readOnlyHint: false,
     },
     schema: {
-        width: z.number().describe('Page width'),
-        height: z.number().describe('Page height'),
+        width: zod.number().describe('Page width'),
+        height: zod.number().describe('Page height'),
     },
     handler: async (request, response, context) => {
         const page = context.getSelectedPage();
@@ -164,14 +164,14 @@ export const handleDialog = defineTool({
     name: 'handle_dialog',
     description: `If a browser dialog was opened, use this command to handle it`,
     annotations: {
-        category: ToolCategories.INPUT_AUTOMATION,
+        category: ToolCategory.INPUT,
         readOnlyHint: false,
     },
     schema: {
-        action: z
+        action: zod
             .enum(['accept', 'dismiss'])
             .describe('Whether to dismiss or accept the dialog'),
-        promptText: z
+        promptText: zod
             .string()
             .optional()
             .describe('Optional prompt text to enter into the dialog.'),

package/build/src/tools/performance.js

@@ -3,23 +3,23 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import z from 'zod';
 import { logger } from '../logger.js';
+import { zod } from '../third_party/index.js';
 import { getInsightOutput, getTraceSummary, parseRawTraceBuffer, traceResultIsSuccess, } from '../trace-processing/parse.js';
-import { ToolCategories } from './categories.js';
+import { ToolCategory } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
 export const startTrace = defineTool({
     name: 'performance_start_trace',
     description: 'Starts a performance trace recording on the selected page. This can be used to look for performance problems and insights to improve the performance of the page. It will also report Core Web Vital (CWV) scores for the page.',
     annotations: {
-        category: ToolCategories.PERFORMANCE,
+        category: ToolCategory.PERFORMANCE,
         readOnlyHint: true,
     },
     schema: {
-        reload: z
+        reload: zod
             .boolean()
             .describe('Determines if, once tracing has started, the page should be automatically reloaded.'),
-        autoStop: z
+        autoStop: zod
             .boolean()
             .describe('Determines if the trace recording should be automatically stopped.'),
     },
@@ -79,7 +79,7 @@ export const stopTrace = defineTool({
     name: 'performance_stop_trace',
     description: 'Stops the active performance trace recording on the selected page.',
     annotations: {
-        category: ToolCategories.PERFORMANCE,
+        category: ToolCategory.PERFORMANCE,
         readOnlyHint: true,
     },
     schema: {},
@@ -95,11 +95,11 @@ export const analyzeInsight = defineTool({
     name: 'performance_analyze_insight',
     description: 'Provides more detailed information on a specific Performance Insight that was highlighted in the results of a trace recording.',
     annotations: {
-        category: ToolCategories.PERFORMANCE,
+        category: ToolCategory.PERFORMANCE,
         readOnlyHint: true,
     },
     schema: {
-        insightName: z
+        insightName: zod
             .string()
             .describe('The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"'),
     },

package/build/src/tools/screenshot.js

@@ -3,36 +3,36 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import z from 'zod';
-import { ToolCategories } from './categories.js';
+import { zod } from '../third_party/index.js';
+import { ToolCategory } from './categories.js';
 import { defineTool } from './ToolDefinition.js';
 export const screenshot = defineTool({
     name: 'take_screenshot',
     description: `Take a screenshot of the page or element.`,
     annotations: {
-        category: ToolCategories.DEBUGGING,
+        category: ToolCategory.DEBUGGING,
         readOnlyHint: true,
     },
     schema: {
-        format: z
+        format: zod
             .enum(['png', 'jpeg', 'webp'])
             .default('png')
             .describe('Type of format to save the screenshot as. Default is "png"'),
-        quality: z
+        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: z
+        uid: zod
             .string()
             .optional()
             .describe('The uid of an element on the page from the page content snapshot. If omitted takes a pages screenshot.'),
-        fullPage: z
+        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: z
+        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.'),

package/build/src/tools/script.js

@@ -1,16 +1,21 @@
-import z from 'zod';
-import { ToolCategories } from './categories.js';
+/**
+ * @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 } from './ToolDefinition.js';
 export const evaluateScript = defineTool({
     name: 'evaluate_script',
     description: `Evaluate a JavaScript function inside the currently selected page. Returns the response as JSON
 so returned values have to JSON-serializable.`,
     annotations: {
-        category: ToolCategories.DEBUGGING,
+        category: ToolCategory.DEBUGGING,
         readOnlyHint: false,
     },
     schema: {
-        function: z.string().describe(`A JavaScript function to run in the currently selected page.
+        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 () => {
@@ -20,9 +25,9 @@ Example with arguments: \`(el) => {
   return el.innerText;
 }\`
 `),
-        args: z
-            .array(z.object({
-            uid: z
+        args: zod
+            .array(zod.object({
+            uid: zod
                 .string()
                 .describe('The uid of an element on the page from the page content snapshot'),
         }))
@@ -30,15 +35,26 @@ Example with arguments: \`(el) => {
             .describe(`An optional list of arguments to pass to the function.`),
     },
     handler: async (request, response, context) => {
-        const page = context.getSelectedPage();
-        const fn = await page.evaluateHandle(`(${request.params.function})`);
-        const args = [fn];
+        const args = [];
         try {
+            const frames = new Set();
             for (const el of request.params.args ?? []) {
-                args.push(await context.getElementByUid(el.uid));
+                const handle = await context.getElementByUid(el.uid);
+                frames.add(handle.frame);
+                args.push(handle);
             }
+            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] ?? context.getSelectedPage();
+            }
+            const fn = await pageOrFrame.evaluateHandle(`(${request.params.function})`);
+            args.unshift(fn);
             await context.waitForEventsAfterAction(async () => {
-                const result = await page.evaluate(async (fn, ...args) => {
+                const result = await pageOrFrame.evaluate(async (fn, ...args) => {
                     // @ts-expect-error no types.
                     return JSON.stringify(await fn(...args));
                 }, ...args);
@@ -49,9 +65,7 @@ Example with arguments: \`(el) => {
             });
         }
         finally {
-            Promise.allSettled(args.map(arg => arg.dispose())).catch(() => {
-                // Ignore errors
-            });
+            void Promise.allSettled(args.map(arg => arg.dispose()));
         }
     },
 });