chrome-devtools-mcp 1.1.1 → 1.2.0

package/README.md

@@ -514,8 +514,9 @@ If you run into any issues, checkout our [troubleshooting guide](./docs/troubles
   - [`take_snapshot`](docs/tool-reference.md#take_snapshot)
   - [`screencast_start`](docs/tool-reference.md#screencast_start)
   - [`screencast_stop`](docs/tool-reference.md#screencast_stop)
-- **Memory** (5 tools)
+- **Memory** (6 tools)
   - [`take_heapsnapshot`](docs/tool-reference.md#take_heapsnapshot)
+  - [`close_heapsnapshot`](docs/tool-reference.md#close_heapsnapshot)
   - [`get_heapsnapshot_class_nodes`](docs/tool-reference.md#get_heapsnapshot_class_nodes)
   - [`get_heapsnapshot_details`](docs/tool-reference.md#get_heapsnapshot_details)
   - [`get_heapsnapshot_retainers`](docs/tool-reference.md#get_heapsnapshot_retainers)
@@ -608,8 +609,8 @@ The Chrome DevTools MCP server supports the following configuration option:
   Whether to enable coordinate-based tools such as click_at(x,y). Usually requires a computer-use model able to produce accurate coordinates by looking at screenshots.
   - **Type:** boolean
 
-- **`--experimentalMemory`/ `--experimental-memory`**
-  Whether to enable experimental memory tools.
+- **`--memoryDebugging`/ `--memory-debugging`, `-experimentalMemory`**
+  Whether to enable memory debugging tools.
   - **Type:** boolean
 
 - **`--experimentalStructuredContent`/ `--experimental-structured-content`**
@@ -636,6 +637,14 @@ The Chrome DevTools MCP server supports the following configuration option:
   Additional arguments for Chrome. Only applies when Chrome is launched by chrome-devtools-mcp.
   - **Type:** array
 
+- **`--blockedUrlPattern`/ `--blocked-url-pattern`**
+  Restricts network access by blocking specified URL patterns (uses https://urlpattern.spec.whatwg.org/). Silently detaches from targets with blocked URLs upon connection, and blocks runtime requests (including navigations and subresources). Accepts an array of patterns.
+  - **Type:** array
+
+- **`--allowedUrlPattern`/ `--allowed-url-pattern`**
+  Restricts network access by allowing only specified URL patterns (uses https://urlpattern.spec.whatwg.org/). Requires Chrome 149+. Silently detaches from targets with unallowed URLs upon connection, and blocks runtime requests (including navigations and subresources). Accepts an array of patterns.
+  - **Type:** array
+
 - **`--ignoreDefaultChromeArg`/ `--ignore-default-chrome-arg`**
   Explicitly disable default arguments for Chrome. Only applies when Chrome is launched by chrome-devtools-mcp.
   - **Type:** array

package/build/src/DevtoolsUtils.js

@@ -18,6 +18,63 @@ export class FakeIssuesManager extends DevTools.Common.ObjectWrapper
 }
 // DevTools CDP errors can get noisy.
 DevTools.ProtocolClient.InspectorBackend.test.suppressRequestErrors = true;
+// Stub out Network emulation commands on the DevTools Agent prototype globally.
+// This prevents the DevTools Frontend from ever resetting/clearing Puppeteer's
+// active network blocking/throttling rules during target setup or session lifetime.
+const networkAgentPrototype = DevTools.ProtocolClient.InspectorBackend.inspectorBackend.agentPrototypes.get('Network');
+if (networkAgentPrototype) {
+    Object.defineProperty(networkAgentPrototype, 'invoke_emulateNetworkConditionsByRule', {
+        value: () => {
+            return Promise.resolve({
+                ruleIds: [],
+                getError: () => undefined,
+            });
+        },
+        writable: true,
+        configurable: true,
+        enumerable: true,
+    });
+    Object.defineProperty(networkAgentPrototype, 'invoke_overrideNetworkState', {
+        value: () => {
+            return Promise.resolve({
+                getError: () => undefined,
+            });
+        },
+        writable: true,
+        configurable: true,
+        enumerable: true,
+    });
+    Object.defineProperty(networkAgentPrototype, 'invoke_enable', {
+        value: () => {
+            return Promise.resolve({
+                getError: () => undefined,
+            });
+        },
+        writable: true,
+        configurable: true,
+        enumerable: true,
+    });
+    Object.defineProperty(networkAgentPrototype, 'invoke_disable', {
+        value: () => {
+            return Promise.resolve({
+                getError: () => undefined,
+            });
+        },
+        writable: true,
+        configurable: true,
+        enumerable: true,
+    });
+    Object.defineProperty(networkAgentPrototype, 'invoke_setBlockedURLs', {
+        value: () => {
+            return Promise.resolve({
+                getError: () => undefined,
+            });
+        },
+        writable: true,
+        configurable: true,
+        enumerable: true,
+    });
+}
 DevTools.I18n.DevToolsLocale.DevToolsLocale.instance({
     create: true,
     data: {

package/build/src/HeapSnapshotManager.js

@@ -122,13 +122,18 @@ export class HeapSnapshotManager {
         const snapshot = await snapshotPromise;
         return { snapshot, worker: workerProxy };
     }
+    hasSnapshots() {
+        return this.#snapshots.size > 0;
+    }
     dispose(filePath) {
         const absolutePath = path.resolve(filePath);
         const cached = this.#snapshots.get(absolutePath);
         if (cached) {
             cached.worker.dispose();
             this.#snapshots.delete(absolutePath);
+            return true;
         }
+        return false;
     }
 }
 //# sourceMappingURL=HeapSnapshotManager.js.map

package/build/src/McpContext.js

@@ -12,6 +12,7 @@ import { UniverseManager } from './DevtoolsUtils.js';
 import { HeapSnapshotManager } from './HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
+import { ServiceWorkerConsoleCollector } from './ServiceWorkerCollector.js';
 import { Locator, PredefinedNetworkConditions, } from './third_party/index.js';
 import { listPages } from './tools/pages.js';
 import { CLOSE_PAGE_ERROR } from './tools/ToolDefinition.js';
@@ -33,6 +34,7 @@ export class McpContext {
     #networkCollector;
     #consoleCollector;
     #devtoolsUniverseManager;
+    #serviceWorkerConsoleCollector;
     #isRunningTrace = false;
     #screenRecorderData = null;
     #nextPageId = 1;
@@ -63,19 +65,22 @@ export class McpContext {
                 },
             };
         });
+        this.#serviceWorkerConsoleCollector = new ServiceWorkerConsoleCollector(this.browser);
         this.#devtoolsUniverseManager = new UniverseManager(this.browser);
     }
     async #init() {
         const pages = await this.createPagesSnapshot();
-        await this.createExtensionServiceWorkersSnapshot();
+        const workers = await this.createExtensionServiceWorkersSnapshot();
         await this.#networkCollector.init(pages);
         await this.#consoleCollector.init(pages);
         await this.#devtoolsUniverseManager.init(pages);
+        await this.#serviceWorkerConsoleCollector.init(workers);
     }
     dispose() {
         this.#networkCollector.dispose();
         this.#consoleCollector.dispose();
         this.#devtoolsUniverseManager.dispose();
+        this.#serviceWorkerConsoleCollector.dispose();
         for (const mcpPage of this.#mcpPages.values()) {
             mcpPage.dispose();
         }
@@ -148,7 +153,7 @@ export class McpContext {
     }
     resolveCdpRequestId(page, cdpRequestId) {
         if (!cdpRequestId) {
-            this.logger('no network request');
+            this.logger?.('no network request');
             return;
         }
         const request = this.#networkCollector.find(page.pptrPage, request => {
@@ -156,7 +161,7 @@ export class McpContext {
             return request.id === cdpRequestId;
         });
         if (!request) {
-            this.logger('no network request for ' + cdpRequestId);
+            this.logger?.('no network request for ' + cdpRequestId);
             return;
         }
         return this.#networkCollector.getIdForResource(request);
@@ -217,7 +222,13 @@ export class McpContext {
         const page = targetPage ?? this.getSelectedPptrPage();
         const mcpPage = this.#getMcpPage(page);
         const newSettings = { ...mcpPage.emulationSettings };
-        if (!options.networkConditions) {
+        // Skip network emulation if blocklist/allowlist is configured, as it conflicts with blocking rules in Puppeteer.
+        if (this.#options.hasNetworkBlockOrAllowlist) {
+            if (options.networkConditions !== undefined) {
+                throw new Error('Network throttling is not supported when network blocking (allowlist/blocklist) is configured.');
+            }
+        }
+        else if (!options.networkConditions) {
             await page.emulateNetworkConditions(null);
             delete newSettings.networkConditions;
         }
@@ -412,6 +423,9 @@ export class McpContext {
         });
         return this.#extensionServiceWorkers;
     }
+    getServiceWorkerConsoleData(extensionId) {
+        return this.#serviceWorkerConsoleCollector.getData(extensionId);
+    }
     async createPagesSnapshot() {
         const { pages: allPages, isolatedContextNames } = await this.#getAllPages();
         for (const page of allPages) {
@@ -421,7 +435,7 @@ export class McpContext {
                 this.#mcpPages.set(page, mcpPage);
                 // We emulate a focused page for all pages to support multi-agent workflows.
                 void page.emulateFocusedPage(true).catch(error => {
-                    this.logger('Error turning on focused page emulation', error);
+                    this.logger?.('Error turning on focused page emulation', error);
                 });
             }
             mcpPage.isolatedContextName = isolatedContextNames.get(page);
@@ -467,7 +481,7 @@ export class McpContext {
                         this.#extensionPages.set(target, page);
                     }
                     catch (e) {
-                        this.logger('Failed to get page for extension target', e);
+                        this.logger?.('Failed to get page for extension target', e);
                     }
                 }
             }
@@ -502,7 +516,7 @@ export class McpContext {
         return { pages: allPages, isolatedContextNames };
     }
     async detectOpenDevToolsWindows() {
-        this.logger('Detecting open DevTools windows');
+        this.logger?.('Detecting open DevTools windows');
         const { pages } = await this.#getAllPages();
         await Promise.all(pages.map(async (page) => {
             const mcpPage = this.#mcpPages.get(page);
@@ -557,7 +571,7 @@ export class McpContext {
             return { filename: filePath };
         }
         catch (err) {
-            this.logger(err);
+            this.logger?.(err);
             throw new Error('Could not save a file', { cause: err });
         }
     }
@@ -639,5 +653,11 @@ export class McpContext {
     async getHeapSnapshotRetainers(filePath, nodeId) {
         return await this.#heapSnapshotManager.getRetainers(filePath, nodeId);
     }
+    async closeHeapSnapshot(filePath) {
+        return this.#heapSnapshotManager.dispose(filePath);
+    }
+    hasHeapSnapshots() {
+        return this.#heapSnapshotManager.hasSnapshots();
+    }
 }
 //# sourceMappingURL=McpContext.js.map

package/build/src/McpPage.js

@@ -30,7 +30,7 @@ export class McpPage {
     // Dialog
     #dialog;
     #dialogHandler;
-    thirdPartyDeveloperTools;
+    thirdPartyDeveloperTools = [];
     constructor(page, id) {
         this.pptrPage = page;
         this.id = id;
@@ -194,18 +194,18 @@ export class McpPage {
             for (const handle of oldHandles) {
                 await handle
                     .dispose()
-                    .catch(e => logger('Failed to dispose old handle', e));
+                    .catch(e => logger?.('Failed to dispose old handle', e));
             }
         }
         const cdpElementIds = await Promise.all(elementHandles.map(async (elementHandle, index) => {
             const backendNodeId = await elementHandle.backendNodeId();
             if (!backendNodeId) {
-                logger(`No backendNodeId for stashed DOM element with index ${index}`);
+                logger?.(`No backendNodeId for stashed DOM element with index ${index}`);
                 return `stashed-${index}`;
             }
             const cdpElementId = this.resolveCdpElementId(backendNodeId);
             if (!cdpElementId) {
-                logger(`Could not get cdpElementId for backend node ${backendNodeId}`);
+                logger?.(`Could not get cdpElementId for backend node ${backendNodeId}`);
                 return `stashed-${index}`;
             }
             return cdpElementId;
@@ -263,12 +263,12 @@ export class McpPage {
     }
     resolveCdpElementId(cdpBackendNodeId) {
         if (!cdpBackendNodeId) {
-            logger('no cdpBackendNodeId');
+            logger?.('no cdpBackendNodeId');
             return;
         }
         const snapshot = this.textSnapshot;
         if (!snapshot) {
-            logger('no text snapshot');
+            logger?.('no text snapshot');
             return;
         }
         // TODO: index by backendNodeId instead.
@@ -286,10 +286,10 @@ export class McpPage {
     }
     async getDevToolsData() {
         try {
-            logger('Getting DevTools UI data');
+            logger?.('Getting DevTools UI data');
             const devtoolsPage = this.devToolsPage;
             if (!devtoolsPage) {
-                logger('No DevTools page detected');
+                logger?.('No DevTools page detected');
                 return {};
             }
             const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
@@ -307,7 +307,7 @@ export class McpPage {
             return { cdpBackendNodeId, cdpRequestId };
         }
         catch (err) {
-            logger('error getting devtools data', err);
+            logger?.('error getting devtools data', err);
         }
         return {};
     }

package/build/src/McpResponse.js

@@ -11,7 +11,7 @@ import { NetworkFormatter } from './formatters/NetworkFormatter.js';
 import { SnapshotFormatter } from './formatters/SnapshotFormatter.js';
 import { UncaughtError } from './PageCollector.js';
 import { TextSnapshot } from './TextSnapshot.js';
-import { DevTools } from './third_party/index.js';
+import { DevTools, toonEncode } from './third_party/index.js';
 import { handleDialog } from './tools/pages.js';
 import { getInsightOutput, getTraceSummary } from './trace-processing/parse.js';
 import { paginate } from './utils/pagination.js';
@@ -61,7 +61,7 @@ export function replaceHtmlElementsWithUids(schema) {
         }
     }
 }
-async function getToolGroup(page) {
+async function getToolGroups(page) {
     // Check if there is a `devtoolstooldiscovery` event listener
     const windowHandle = await page.pptrPage.evaluateHandle(() => window);
     // @ts-expect-error internal API
@@ -70,43 +70,78 @@ async function getToolGroup(page) {
         objectId: windowHandle.remoteObject().objectId,
     });
     if (listeners.find(l => l.type === 'devtoolstooldiscovery') === undefined) {
-        return;
+        return [];
     }
-    const toolGroup = await page.pptrPage.evaluate(() => {
+    const toolGroups = await page.pptrPage.evaluate(() => {
         return new Promise(resolve => {
             const event = new CustomEvent('devtoolstooldiscovery');
+            const groups = [];
             // @ts-expect-error Adding custom property
-            event.respondWith = (toolGroup) => {
+            event.respondWith = toolGroup => {
                 if (!window.__dtmcp) {
                     window.__dtmcp = {};
                 }
-                window.__dtmcp.toolGroup = toolGroup;
+                if (!window.__dtmcp.toolGroups) {
+                    window.__dtmcp.toolGroups = [];
+                }
+                if (typeof toolGroup.name !== 'string' ||
+                    typeof toolGroup.description !== 'string' ||
+                    !Array.isArray(toolGroup.tools)) {
+                    console.error('Invalid toolGroup:', toolGroup);
+                    return;
+                }
+                for (const tool of toolGroup.tools) {
+                    if (typeof tool.name !== 'string' ||
+                        typeof tool.description !== 'string' ||
+                        typeof tool.inputSchema !== 'object' ||
+                        typeof tool.execute !== 'function') {
+                        console.error('Invalid tool:', tool);
+                        return;
+                    }
+                }
+                window.__dtmcp.toolGroups.push(toolGroup);
                 // When receiving a toolGroup for the first time, expose a simple execution helper
                 if (!window.__dtmcp.executeTool) {
                     window.__dtmcp.executeTool = async (toolName, args) => {
-                        if (!window.__dtmcp?.toolGroup) {
+                        if (!window.__dtmcp?.toolGroups ||
+                            window.__dtmcp.toolGroups.length === 0) {
                             throw new Error('No tools found on the page');
                         }
-                        const tool = window.__dtmcp.toolGroup.tools.find(t => t.name === toolName);
-                        if (!tool) {
-                            throw new Error(`Tool ${toolName} not found`);
+                        for (const group of window.__dtmcp.toolGroups) {
+                            const tool = group.tools?.find(t => t.name === toolName);
+                            if (tool) {
+                                return await tool.execute(args);
+                            }
                         }
-                        return await tool.execute(args);
+                        throw new Error(`Tool ${toolName} not found`);
                     };
                 }
-                resolve(toolGroup);
+                groups.push(toolGroup);
             };
             window.dispatchEvent(event);
-            // If the page does not synchronously call `event.respondWith`, return instead of timing out
-            setTimeout(() => {
-                resolve(null);
-            }, 0);
+            // If at least one toolGroup was added synchronously, resolve with the array.
+            // Otherwise, use setTimeout to allow for any microtask/asynchronous respondWith calls, or resolve with an empty array.
+            if (groups.length > 0) {
+                resolve(groups);
+            }
+            else {
+                setTimeout(() => {
+                    if (groups.length > 0) {
+                        resolve(groups);
+                    }
+                    else {
+                        resolve([]);
+                    }
+                }, 0);
+            }
         });
     });
-    for (const tool of toolGroup?.tools ?? []) {
-        replaceHtmlElementsWithUids(tool.inputSchema);
+    for (const group of toolGroups) {
+        for (const tool of group.tools ?? []) {
+            replaceHtmlElementsWithUids(tool.inputSchema);
+        }
     }
-    return toolGroup;
+    return toolGroups;
 }
 export class McpResponse {
     #includePages = false;
@@ -134,6 +169,9 @@ export class McpResponse {
     #redactNetworkHeaders = true;
     #error;
     #attachedWaitForResult;
+    get #deviceScope() {
+        return this.#page?.viewport?.isMobile ? 'PHONE' : 'DESKTOP';
+    }
     constructor(args) {
         this.#args = args;
     }
@@ -203,6 +241,7 @@ export class McpResponse {
                 : undefined,
             types: options?.types,
             includePreservedMessages: options?.includePreservedMessages,
+            serviceWorkerId: options?.serviceWorkerId,
         };
     }
     setError(error) {
@@ -306,7 +345,7 @@ export class McpResponse {
     get listWebMcpTools() {
         return this.#listWebMcpTools;
     }
-    async handle(toolName, context) {
+    async handle(toolName, context, useToon = false) {
         if (this.#includePages) {
             await context.createPagesSnapshot();
         }
@@ -383,12 +422,11 @@ export class McpResponse {
         if (this.#listExtensions) {
             extensions = await context.listExtensions();
         }
-        // Null indicates no tools.
-        let thirdPartyDeveloperTools;
+        let thirdPartyDeveloperTools = [];
         if (this.#args.categoryExperimentalThirdParty &&
             this.#listThirdPartyDeveloperTools &&
             this.#page) {
-            thirdPartyDeveloperTools = await getToolGroup(this.#page);
+            thirdPartyDeveloperTools = await getToolGroups(this.#page);
             if (thirdPartyDeveloperTools) {
                 this.#page.thirdPartyDeveloperTools = thirdPartyDeveloperTools;
             }
@@ -401,11 +439,18 @@ export class McpResponse {
         }
         let consoleMessages;
         if (this.#consoleDataOptions?.include) {
-            if (!this.#page) {
-                throw new Error(`Response must have an McpPage`);
+            let messages;
+            let page;
+            if (this.#consoleDataOptions.serviceWorkerId) {
+                messages = context.getServiceWorkerConsoleData(this.#consoleDataOptions.serviceWorkerId);
+            }
+            else {
+                page = this.#page;
+                if (!page) {
+                    throw new Error(`Response must have an McpPage`);
+                }
+                messages = context.getConsoleData(page, this.#consoleDataOptions.includePreservedMessages);
             }
-            const page = this.#page;
-            let messages = context.getConsoleData(this.#page, this.#consoleDataOptions.includePreservedMessages);
             if (this.#consoleDataOptions.types?.length) {
                 const normalizedTypes = new Set(this.#consoleDataOptions.types);
                 messages = messages.filter(message => {
@@ -422,7 +467,9 @@ export class McpResponse {
                 const consoleMessageStableId = context.getConsoleMessageStableId(item);
                 if ('args' in item || item instanceof UncaughtError) {
                     const consoleMessage = item;
-                    const devTools = context.getDevToolsUniverse(page);
+                    const devTools = page
+                        ? context.getDevToolsUniverse(page)
+                        : null;
                     return await ConsoleFormatter.from(consoleMessage, {
                         id: consoleMessageStableId,
                         fetchDetailedData: false,
@@ -479,9 +526,9 @@ export class McpResponse {
             thirdPartyDeveloperTools,
             webmcpTools,
             errorMessage: this.#error?.message,
-        });
+        }, useToon);
     }
-    format(toolName, context, data) {
+    format(toolName, context, data, useToon) {
         const structuredContent = {};
         const response = [];
         if (this.#textResponseLines.length) {
@@ -603,7 +650,7 @@ Call ${handleDialog.name} to handle it before continuing.`);
             structuredContent.tabId = this.#tabId;
         }
         if (data.traceSummary) {
-            const summary = getTraceSummary(data.traceSummary);
+            const summary = getTraceSummary(data.traceSummary, this.#deviceScope);
             response.push(summary);
             structuredContent.traceSummary = summary;
             structuredContent.traceInsights = [];
@@ -617,7 +664,7 @@ Call ${handleDialog.name} to handle it before continuing.`);
             }
         }
         if (data.traceInsight) {
-            const insightOutput = getInsightOutput(data.traceInsight.trace, data.traceInsight.insightSetId, data.traceInsight.insightName);
+            const insightOutput = getInsightOutput(data.traceInsight.trace, data.traceInsight.insightSetId, data.traceInsight.insightName, this.#deviceScope);
             if ('error' in insightOutput) {
                 response.push(insightOutput.error);
             }
@@ -651,9 +698,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 structuredContent.snapshotFilePath = data.snapshot;
             }
             else {
-                response.push('## Latest page snapshot');
-                response.push(data.snapshot.toString());
                 structuredContent.snapshot = data.snapshot.toJSON();
+                response.push('## Latest page snapshot');
+                response.push(useToon
+                    ? toonEncode(structuredContent.snapshot)
+                    : data.snapshot.toString());
             }
         }
         if (this.#heapSnapshotOptions?.include) {
@@ -678,8 +727,10 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(...paginationData.info);
                 const paginatedRecord = Object.fromEntries(paginationData.items);
                 const formatter = new HeapSnapshotFormatter(paginatedRecord);
-                response.push(formatter.toString());
                 structuredContent.heapSnapshotData = formatter.toJSON();
+                response.push(useToon
+                    ? toonEncode(structuredContent.heapSnapshotData)
+                    : formatter.toString());
             }
             const nodes = this.#heapSnapshotOptions.nodes;
             if (nodes) {
@@ -728,18 +779,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(extensionsMessage);
             }
         }
-        if (data.thirdPartyDeveloperTools !== undefined) {
-            if (data.thirdPartyDeveloperTools) {
-                structuredContent.thirdPartyDeveloperTools =
-                    data.thirdPartyDeveloperTools;
-            }
+        if (data.thirdPartyDeveloperTools.length) {
+            structuredContent.thirdPartyDeveloperTools =
+                data.thirdPartyDeveloperTools;
             response.push('## Third-party developer tools');
-            if (data.thirdPartyDeveloperTools === null ||
-                !data.thirdPartyDeveloperTools?.tools) {
-                response.push('No third-party developer tools available.');
-            }
-            else {
-                const toolGroup = data.thirdPartyDeveloperTools;
+            for (const toolGroup of data.thirdPartyDeveloperTools) {
                 response.push(`${toolGroup.name}: ${toolGroup.description}`);
                 response.push('Available tools:');
                 const toolDefinitionsMessage = toolGroup.tools
@@ -778,11 +822,10 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 structuredContent.pagination = paginationData.pagination;
                 response.push(...paginationData.info);
                 if (data.networkRequests) {
-                    structuredContent.networkRequests = [];
-                    for (const formatter of paginationData.items) {
-                        response.push(formatter.toString());
-                        structuredContent.networkRequests.push(formatter.toJSON());
-                    }
+                    structuredContent.networkRequests = paginationData.items.map(i => i.toJSON());
+                    response.push(...(useToon
+                        ? [toonEncode(structuredContent.networkRequests)]
+                        : paginationData.items.map(i => i.toString())));
                 }
             }
             else {
@@ -796,9 +839,14 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 const grouped = ConsoleFormatter.groupConsecutive(messages);
                 const paginationData = this.#dataWithPagination(grouped, this.#consoleDataOptions.pagination);
                 structuredContent.pagination = paginationData.pagination;
-                response.push(...paginationData.info);
-                response.push(...paginationData.items.map(item => item.toString()));
                 structuredContent.consoleMessages = paginationData.items.map(item => item.toJSON());
+                response.push(...paginationData.info);
+                if (useToon) {
+                    response.push(toonEncode(structuredContent.consoleMessages));
+                }
+                else {
+                    response.push(...paginationData.items.map(item => item.toString()));
+                }
             }
             else {
                 response.push('<no console messages found>');

package/build/src/PageCollector.js

@@ -50,7 +50,7 @@ export class PageCollector {
             this.addPage(page);
         }
         catch (err) {
-            logger('Error getting a page for a target onTargetCreated', err);
+            logger?.('Error getting a page for a target onTargetCreated', err);
         }
     };
     #onTargetDestroyed = async (target) => {
@@ -62,7 +62,7 @@ export class PageCollector {
             this.cleanupPageDestroyed(page);
         }
         catch (err) {
-            logger('Error getting a page for a target onTargetDestroyed', err);
+            logger?.('Error getting a page for a target onTargetDestroyed', err);
         }
     };
     addPage(page) {
@@ -136,10 +136,10 @@ export class PageCollector {
             throw new Error('No requests found for selected page');
         }
         const item = this.find(page, item => item[stableIdSymbol] === stableId);
-        if (item) {
-            return item;
+        if (!item) {
+            throw new Error('Request not found for selected page');
         }
-        throw new Error('Request not found for selected page');
+        return item;
     }
     find(page, filter) {
         const navigations = this.storage.get(page);
@@ -241,7 +241,7 @@ class PageEventSubscriber {
             // @ts-expect-error Protocol types diverge.
             inspectorIssue)[0];
             if (!issue) {
-                logger('No issue mapping for for the issue: ', inspectorIssue.code);
+                logger?.('No issue mapping for for the issue: ', inspectorIssue.code);
                 return;
             }
             const primaryKey = issue.primaryKey();
@@ -256,7 +256,7 @@ class PageEventSubscriber {
             });
         }
         catch (error) {
-            logger('Error creating a new issue', error);
+            logger?.('Error creating a new issue', error);
         }
     };
 }