chrome-devtools-mcp 0.22.0 → 0.24.0

package/README.md

@@ -591,6 +591,10 @@ The Chrome DevTools MCP server supports the following configuration option:
   Exposes experimental screencast tools (requires ffmpeg). Install ffmpeg https://www.ffmpeg.org/download.html and ensure it is available in the MCP server PATH.
   - **Type:** boolean
 
+- **`--experimentalFfmpegPath`/ `--experimental-ffmpeg-path`**
+  Path to ffmpeg executable for screencast recording.
+  - **Type:** string
+
 - **`--experimentalWebmcp`/ `--experimental-webmcp`**
   Set to true to enable debugging WebMCP tools. Requires Chrome 149+ with the following flags: `--enable-features=WebMCPTesting,DevToolsWebMCPSupport`
   - **Type:** boolean

package/build/src/DevToolsConnectionAdapter.js

@@ -67,3 +67,4 @@ export class PuppeteerDevToolsConnection {
         }
     }
 }
+//# sourceMappingURL=DevToolsConnectionAdapter.js.map

package/build/src/DevtoolsUtils.js

@@ -292,3 +292,4 @@ async function waitForScript(model, scriptId, signal) {
         });
     }
 }
+//# sourceMappingURL=DevtoolsUtils.js.map

package/build/src/HeapSnapshotManager.js

@@ -56,6 +56,17 @@ export class HeapSnapshotManager {
         }
         return uid;
     }
+    async getNodesByUid(filePath, uid) {
+        const snapshot = await this.getSnapshot(filePath);
+        const filter = new DevTools.HeapSnapshotModel.HeapSnapshotModel.NodeFilter();
+        const className = await this.resolveClassKeyFromUid(filePath, uid);
+        if (!className) {
+            throw new Error(`Class with UID ${uid} not found in heap snapshot`);
+        }
+        const provider = snapshot.createNodesProviderForClass(className, filter);
+        const range = await provider.serializeItemsRange(0, 1);
+        return await provider.serializeItemsRange(0, range.totalLength);
+    }
     #getCachedSnapshot(filePath) {
         const absolutePath = path.resolve(filePath);
         const cached = this.#snapshots.get(absolutePath);
@@ -64,6 +75,10 @@ export class HeapSnapshotManager {
         }
         return cached;
     }
+    async resolveClassKeyFromUid(filePath, uid) {
+        const cached = this.#getCachedSnapshot(filePath);
+        return cached.uidToClassKey.get(uid);
+    }
     async #loadSnapshot(absolutePath) {
         const workerProxy = new DevTools.HeapSnapshotModel.HeapSnapshotProxy.HeapSnapshotWorkerProxy(() => {
             /* noop */
@@ -92,3 +107,4 @@ export class HeapSnapshotManager {
         }
     }
 }
+//# sourceMappingURL=HeapSnapshotManager.js.map

package/build/src/McpContext.js

@@ -4,16 +4,17 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import fs from 'node:fs/promises';
+import os from 'node:os';
 import path from 'node:path';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { UniverseManager } from './DevtoolsUtils.js';
 import { HeapSnapshotManager } from './HeapSnapshotManager.js';
 import { McpPage } from './McpPage.js';
 import { NetworkCollector, ConsoleCollector, } from './PageCollector.js';
-import { Locator } from './third_party/index.js';
-import { PredefinedNetworkConditions } from './third_party/index.js';
+import { Locator, PredefinedNetworkConditions, } from './third_party/index.js';
 import { listPages } from './tools/pages.js';
 import { CLOSE_PAGE_ERROR } from './tools/ToolDefinition.js';
-import { ensureExtension, saveTemporaryFile } from './utils/files.js';
+import { ensureExtension, getTempFilePath } from './utils/files.js';
 import { getNetworkMultiplierFromString } from './WaitForHelper.js';
 const DEFAULT_TIMEOUT = 5_000;
 const NAVIGATION_TIMEOUT = 10_000;
@@ -37,11 +38,11 @@ export class McpContext {
     #extensionPages = new WeakMap();
     #extensionServiceWorkerMap = new WeakMap();
     #nextExtensionServiceWorkerId = 1;
-    #nextSnapshotId = 1;
     #traceResults = [];
     #locatorClass;
     #options;
     #heapSnapshotManager = new HeapSnapshotManager();
+    #roots = undefined;
     constructor(browser, logger, options, locatorClass) {
         this.browser = browser;
         this.logger = logger;
@@ -90,6 +91,39 @@ export class McpContext {
         await context.#init();
         return context;
     }
+    roots() {
+        if (this.#roots === undefined) {
+            return undefined;
+        }
+        return [
+            ...this.#roots,
+            {
+                uri: pathToFileURL(os.tmpdir()).href,
+                name: 'temp',
+            },
+        ];
+    }
+    setRoots(roots) {
+        this.#roots = roots;
+    }
+    validatePath(filePath) {
+        if (filePath === undefined) {
+            return;
+        }
+        const roots = this.roots();
+        if (roots === undefined) {
+            return;
+        }
+        const absolutePath = path.resolve(filePath);
+        for (const root of roots) {
+            const rootPath = path.resolve(fileURLToPath(root.uri));
+            if (absolutePath === rootPath ||
+                absolutePath.startsWith(rootPath + path.sep)) {
+                return;
+            }
+        }
+        throw new Error(`Access denied: path ${filePath} is not within any of the workspace roots ${JSON.stringify(roots)}.`);
+    }
     resolveCdpRequestId(page, cdpRequestId) {
         if (!cdpRequestId) {
             this.logger('no network request');
@@ -105,29 +139,6 @@ export class McpContext {
         }
         return this.#networkCollector.getIdForResource(request);
     }
-    resolveCdpElementId(page, cdpBackendNodeId) {
-        if (!cdpBackendNodeId) {
-            this.logger('no cdpBackendNodeId');
-            return;
-        }
-        const snapshot = page.textSnapshot;
-        if (!snapshot) {
-            this.logger('no text snapshot');
-            return;
-        }
-        // TODO: index by backendNodeId instead.
-        const queue = [snapshot.root];
-        while (queue.length) {
-            const current = queue.pop();
-            if (current.backendNodeId === cdpBackendNodeId) {
-                return current.id;
-            }
-            for (const child of current.children) {
-                queue.push(child);
-            }
-        }
-        return;
-    }
     getNetworkRequests(page, includePreservedRequests) {
         return this.#networkCollector.getData(page.pptrPage, includePreservedRequests);
     }
@@ -486,111 +497,19 @@ export class McpContext {
     getIsolatedContextName(page) {
         return this.#mcpPages.get(page)?.isolatedContextName;
     }
-    getDevToolsPage(page) {
-        return this.#mcpPages.get(page)?.devToolsPage;
-    }
-    async getDevToolsData(page) {
+    async saveTemporaryFile(data, filename) {
+        const filepath = await getTempFilePath(filename);
+        this.validatePath(filepath);
         try {
-            this.logger('Getting DevTools UI data');
-            const devtoolsPage = this.getDevToolsPage(page.pptrPage);
-            if (!devtoolsPage) {
-                this.logger('No DevTools page detected');
-                return {};
-            }
-            const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
-                // @ts-expect-error no types
-                const UI = await import('/bundled/ui/legacy/legacy.js');
-                // @ts-expect-error no types
-                const SDK = await import('/bundled/core/sdk/sdk.js');
-                const request = UI.Context.Context.instance().flavor(SDK.NetworkRequest.NetworkRequest);
-                const node = UI.Context.Context.instance().flavor(SDK.DOMModel.DOMNode);
-                return {
-                    cdpRequestId: request?.requestId(),
-                    cdpBackendNodeId: node?.backendNodeId(),
-                };
-            });
-            return { cdpBackendNodeId, cdpRequestId };
+            await fs.writeFile(filepath, data);
         }
         catch (err) {
-            this.logger('error getting devtools data', err);
-        }
-        return {};
-    }
-    /**
-     * Creates a text snapshot of a page.
-     */
-    async createTextSnapshot(page, verbose = false, devtoolsData = undefined) {
-        const rootNode = await page.pptrPage.accessibility.snapshot({
-            includeIframes: true,
-            interestingOnly: !verbose,
-        });
-        if (!rootNode) {
-            return;
-        }
-        const { uniqueBackendNodeIdToMcpId } = page;
-        const snapshotId = this.#nextSnapshotId++;
-        // Iterate through the whole accessibility node tree and assign node ids that
-        // will be used for the tree serialization and mapping ids back to nodes.
-        let idCounter = 0;
-        const idToNode = new Map();
-        const seenUniqueIds = new Set();
-        const assignIds = (node) => {
-            let id = '';
-            // @ts-expect-error untyped loaderId & backendNodeId.
-            const uniqueBackendId = `${node.loaderId}_${node.backendNodeId}`;
-            if (uniqueBackendNodeIdToMcpId.has(uniqueBackendId)) {
-                // Re-use MCP exposed ID if the uniqueId is the same.
-                id = uniqueBackendNodeIdToMcpId.get(uniqueBackendId);
-            }
-            else {
-                // Only generate a new ID if we have not seen the node before.
-                id = `${snapshotId}_${idCounter++}`;
-                uniqueBackendNodeIdToMcpId.set(uniqueBackendId, id);
-            }
-            seenUniqueIds.add(uniqueBackendId);
-            const nodeWithId = {
-                ...node,
-                id,
-                children: node.children
-                    ? node.children.map(child => assignIds(child))
-                    : [],
-            };
-            // The AXNode for an option doesn't contain its `value`.
-            // Therefore, set text content of the option as value.
-            if (node.role === 'option') {
-                const optionText = node.name;
-                if (optionText) {
-                    nodeWithId.value = optionText.toString();
-                }
-            }
-            idToNode.set(nodeWithId.id, nodeWithId);
-            return nodeWithId;
-        };
-        const rootNodeWithId = assignIds(rootNode);
-        const snapshot = {
-            root: rootNodeWithId,
-            snapshotId: String(snapshotId),
-            idToNode,
-            hasSelectedElement: false,
-            verbose,
-        };
-        page.textSnapshot = snapshot;
-        const data = devtoolsData ?? (await this.getDevToolsData(page));
-        if (data?.cdpBackendNodeId) {
-            snapshot.hasSelectedElement = true;
-            snapshot.selectedElementUid = this.resolveCdpElementId(page, data?.cdpBackendNodeId);
-        }
-        // Clean up unique IDs that we did not see anymore.
-        for (const key of uniqueBackendNodeIdToMcpId.keys()) {
-            if (!seenUniqueIds.has(key)) {
-                uniqueBackendNodeIdToMcpId.delete(key);
-            }
+            throw new Error('Could not save a file', { cause: err });
         }
-    }
-    async saveTemporaryFile(data, filename) {
-        return await saveTemporaryFile(data, filename);
+        return { filepath };
     }
     async saveFile(data, clientProvidedFilePath, extension) {
+        this.validatePath(clientProvidedFilePath);
         try {
             const filePath = ensureExtension(path.resolve(clientProvidedFilePath), extension);
             await fs.mkdir(path.dirname(filePath), { recursive: true });
@@ -643,6 +562,7 @@ export class McpContext {
         await this.#networkCollector.init(pages);
     }
     async installExtension(extensionPath) {
+        this.validatePath(extensionPath);
         const id = await this.browser.installExtension(extensionPath);
         return id;
     }
@@ -666,12 +586,20 @@ export class McpContext {
         return pptrExtensions.get(id);
     }
     async getHeapSnapshotAggregates(filePath) {
+        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getAggregates(filePath);
     }
     async getHeapSnapshotStats(filePath) {
+        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getStats(filePath);
     }
     async getHeapSnapshotStaticData(filePath) {
+        this.validatePath(filePath);
         return await this.#heapSnapshotManager.getStaticData(filePath);
     }
+    async getHeapSnapshotNodesByUid(filePath, uid) {
+        this.validatePath(filePath);
+        return await this.#heapSnapshotManager.getNodesByUid(filePath, uid);
+    }
 }
+//# sourceMappingURL=McpContext.js.map

package/build/src/McpPage.js

@@ -3,6 +3,8 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+import { logger } from './logger.js';
+import { TextSnapshot } from './TextSnapshot.js';
 import { takeSnapshot } from './tools/snapshot.js';
 import { getNetworkMultiplierFromString, WaitForHelper, } from './WaitForHelper.js';
 /**
@@ -19,6 +21,7 @@ export class McpPage {
     // Snapshot
     textSnapshot = null;
     uniqueBackendNodeIdToMcpId = new Map();
+    extraHandles = [];
     // Emulation
     emulationSettings = {};
     // Metadata
@@ -45,6 +48,11 @@ export class McpPage {
     clearDialog() {
         this.#dialog = undefined;
     }
+    throwIfDialogOpen() {
+        if (this.#dialog) {
+            throw new Error(`A dialog is open (${this.#dialog.type()}: ${this.#dialog.message()}).`);
+        }
+    }
     getInPageTools() {
         return this.inPageTools;
     }
@@ -80,6 +88,151 @@ export class McpPage {
     dispose() {
         this.pptrPage.off('dialog', this.#dialogHandler);
     }
+    async executeInPageTool(toolName, params, response) {
+        // Creates array of ElementHandles from the UIDs in the params.
+        // We do not replace the uids with the ElementsHandles yet, because
+        // the `evaluate` function only turns them into DOM elements if they
+        // are passed as non-nested arguments.
+        const handles = [];
+        for (const value of Object.values(params)) {
+            if (value instanceof Object &&
+                'uid' in value &&
+                typeof value.uid === 'string' &&
+                Object.keys(value).length === 1) {
+                handles.push(await this.getElementByUid(value.uid));
+            }
+        }
+        const result = await this.pptrPage.evaluate(async (name, args, ...elements) => {
+            // Replace the UIDs with DOM elements.
+            for (const [key, value] of Object.entries(args)) {
+                if (value instanceof Object &&
+                    'uid' in value &&
+                    typeof value.uid === 'string' &&
+                    Object.keys(value).length === 1) {
+                    args[key] = elements.shift();
+                }
+            }
+            if (!window.__dtmcp?.executeTool) {
+                throw new Error('No tools found on the page');
+            }
+            const toolResult = await window.__dtmcp.executeTool(name, args);
+            const stashDOMElement = (el) => {
+                if (!window.__dtmcp) {
+                    window.__dtmcp = {};
+                }
+                if (window.__dtmcp.stashedElements === undefined) {
+                    window.__dtmcp.stashedElements = [];
+                }
+                window.__dtmcp.stashedElements.push(el);
+                return {
+                    stashedId: `stashed-${window.__dtmcp.stashedElements.length - 1}`,
+                };
+            };
+            const ancestors = [];
+            // Recursively walks the tool result:
+            // - Replaces DOM elements with an ID and stashes the DOM element on the window object
+            // - Replaces non-plain objects with a string representation of the object
+            // - Replaces circular references with the string '<Circular reference>'
+            // - Replaces functions with the string '<Function object>'
+            const processToolResult = (data, parentEl) => {
+                // 1. Handle DOM Elements
+                if (data instanceof Element) {
+                    return stashDOMElement(data);
+                }
+                // 2. Handle Arrays
+                if (Array.isArray(data)) {
+                    return data.map((item) => processToolResult(item, parentEl));
+                }
+                // 3. Handle Objects
+                if (data !== null && typeof data === 'object') {
+                    while (ancestors.length > 0 && ancestors.at(-1) !== parentEl) {
+                        ancestors.pop();
+                    }
+                    if (ancestors.includes(data)) {
+                        return '<Circular reference>';
+                    }
+                    ancestors.push(data);
+                    // If not a plain object, return a string representation of the object
+                    if (Object.getPrototypeOf(data) !== Object.prototype) {
+                        return `<${data.constructor.name} instance>`;
+                    }
+                    const processedObj = {};
+                    for (const [key, value] of Object.entries(data)) {
+                        processedObj[key] = processToolResult(value, data);
+                    }
+                    return processedObj;
+                }
+                // 4. Handle Functions
+                if (typeof data === 'function') {
+                    return '<Function object>';
+                }
+                // 5. Return primitives (strings, numbers, booleans) as-is
+                return data;
+            };
+            return {
+                result: processToolResult(toolResult),
+                stashed: window.__dtmcp?.stashedElements?.length ?? 0,
+            };
+        }, toolName, params, ...handles);
+        const elementHandles = [];
+        for (let i = 0; i < (result.stashed ?? 0); i++) {
+            const elementHandle = await this.pptrPage.evaluateHandle(index => {
+                const el = window.__dtmcp?.stashedElements?.[index];
+                if (!el) {
+                    throw new Error(`Stashed element at index ${index} not found`);
+                }
+                return el;
+            }, i);
+            elementHandles.push(elementHandle);
+        }
+        if (elementHandles.length) {
+            const oldHandles = [...this.extraHandles];
+            this.textSnapshot = await TextSnapshot.create(this, {
+                extraHandles: elementHandles,
+            });
+            response.includeSnapshot();
+            for (const handle of oldHandles) {
+                await handle
+                    .dispose()
+                    .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}`);
+                return `stashed-${index}`;
+            }
+            const cdpElementId = this.resolveCdpElementId(backendNodeId);
+            if (!cdpElementId) {
+                logger(`Could not get cdpElementId for backend node ${backendNodeId}`);
+                return `stashed-${index}`;
+            }
+            return cdpElementId;
+        }));
+        const recursivelyReplaceStashedElements = (node) => {
+            if (Array.isArray(node)) {
+                return node.map(x => recursivelyReplaceStashedElements(x));
+            }
+            if (node !== null && typeof node === 'object') {
+                if ('stashedId' in node &&
+                    typeof node.stashedId === 'string' &&
+                    node.stashedId.startsWith('stashed-') &&
+                    Object.keys(node).length === 1) {
+                    const index = parseInt(node.stashedId.split('-')[1]);
+                    return { uid: cdpElementIds[index] };
+                }
+                const resultObj = {};
+                for (const [key, value] of Object.entries(node)) {
+                    resultObj[key] = recursivelyReplaceStashedElements(value);
+                }
+                return resultObj;
+            }
+            return node;
+        };
+        const resultWithUids = recursivelyReplaceStashedElements(result.result);
+        response.appendResponseLine(JSON.stringify(resultWithUids, null, 2));
+    }
     async getElementByUid(uid) {
         if (!this.textSnapshot) {
             throw new Error(`No snapshot found for page ${this.id ?? '?'}. Use ${takeSnapshot.name} to capture one.`);
@@ -108,4 +261,55 @@ export class McpPage {
     getAXNodeByUid(uid) {
         return this.textSnapshot?.idToNode.get(uid);
     }
+    resolveCdpElementId(cdpBackendNodeId) {
+        if (!cdpBackendNodeId) {
+            logger('no cdpBackendNodeId');
+            return;
+        }
+        const snapshot = this.textSnapshot;
+        if (!snapshot) {
+            logger('no text snapshot');
+            return;
+        }
+        // TODO: index by backendNodeId instead.
+        const queue = [snapshot.root];
+        while (queue.length) {
+            const current = queue.pop();
+            if (current.backendNodeId === cdpBackendNodeId) {
+                return current.id;
+            }
+            for (const child of current.children) {
+                queue.push(child);
+            }
+        }
+        return;
+    }
+    async getDevToolsData() {
+        try {
+            logger('Getting DevTools UI data');
+            const devtoolsPage = this.devToolsPage;
+            if (!devtoolsPage) {
+                logger('No DevTools page detected');
+                return {};
+            }
+            const { cdpRequestId, cdpBackendNodeId } = await devtoolsPage.evaluate(async () => {
+                // @ts-expect-error no types
+                const UI = await import('/bundled/ui/legacy/legacy.js');
+                // @ts-expect-error no types
+                const SDK = await import('/bundled/core/sdk/sdk.js');
+                const request = UI.Context.Context.instance().flavor(SDK.NetworkRequest.NetworkRequest);
+                const node = UI.Context.Context.instance().flavor(SDK.DOMModel.DOMNode);
+                return {
+                    cdpRequestId: request?.requestId(),
+                    cdpBackendNodeId: node?.backendNodeId(),
+                };
+            });
+            return { cdpBackendNodeId, cdpRequestId };
+        }
+        catch (err) {
+            logger('error getting devtools data', err);
+        }
+        return {};
+    }
 }
+//# sourceMappingURL=McpPage.js.map

package/build/src/McpResponse.js

@@ -5,10 +5,12 @@
  */
 import { ConsoleFormatter } from './formatters/ConsoleFormatter.js';
 import { HeapSnapshotFormatter } from './formatters/HeapSnapshotFormatter.js';
+import { isNodeLike } from './formatters/HeapSnapshotFormatter.js';
 import { IssueFormatter } from './formatters/IssueFormatter.js';
 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 { handleDialog } from './tools/pages.js';
 import { getInsightOutput, getTraceSummary } from './trace-processing/parse.js';
@@ -130,6 +132,7 @@ export class McpResponse {
     #args;
     #page;
     #redactNetworkHeaders = true;
+    #error;
     constructor(args) {
         this.#args = args;
     }
@@ -161,7 +164,7 @@ export class McpResponse {
         this.#listExtensions = true;
     }
     setListInPageTools() {
-        if (this.#args.categoryInPageTools) {
+        if (this.#args.categoryExperimentalInPage) {
             this.#listInPageTools = true;
         }
     }
@@ -203,6 +206,9 @@ export class McpResponse {
             includePreservedMessages: options?.includePreservedMessages,
         };
     }
+    setError(error) {
+        this.#error = error;
+    }
     attachNetworkRequest(reqId, options) {
         this.#attachedNetworkRequestId = reqId;
         this.#attachedNetworkRequestOptions = options;
@@ -253,6 +259,9 @@ export class McpResponse {
     get consoleMessagesTypes() {
         return this.#consoleDataOptions?.types;
     }
+    get error() {
+        return this.#error;
+    }
     appendResponseLine(value) {
         this.#textResponseLines.push(value);
     }
@@ -272,6 +281,14 @@ export class McpResponse {
             staticData,
         };
     }
+    setHeapSnapshotNodes(nodes, options) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            nodes,
+            pagination: options,
+        };
+    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -299,7 +316,10 @@ export class McpResponse {
             if (!this.#page) {
                 throw new Error('Response must have a page');
             }
-            await context.createTextSnapshot(this.#page, this.#snapshotParams.verbose, this.#devToolsData);
+            this.#page.textSnapshot = await TextSnapshot.create(this.#page, {
+                verbose: this.#snapshotParams.verbose,
+                devtoolsData: this.#devToolsData,
+            });
             const textSnapshot = this.#page.textSnapshot;
             if (textSnapshot) {
                 const formatter = new SnapshotFormatter(textSnapshot);
@@ -349,7 +369,7 @@ export class McpResponse {
                 const formatter = new IssueFormatter(message, {
                     id: consoleMessageStableId,
                     requestIdResolver: context.resolveCdpRequestId.bind(context, this.#page),
-                    elementIdResolver: context.resolveCdpElementId.bind(context, this.#page),
+                    elementIdResolver: this.#page.resolveCdpElementId.bind(this.#page),
                 });
                 if (!formatter.isValid()) {
                     throw new Error("Can't provide details for the msgid " + consoleMessageStableId);
@@ -451,6 +471,7 @@ export class McpResponse {
             lighthouseResult: this.#attachedLighthouseResult,
             inPageTools,
             webmcpTools,
+            errorMessage: this.#error?.message,
         });
     }
     format(toolName, context, data) {
@@ -641,6 +662,17 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(formatter.toString());
                 structuredContent.heapSnapshotData = formatter.toJSON();
             }
+            const nodes = this.#heapSnapshotOptions.nodes;
+            if (nodes) {
+                const sortedItems = nodes.items
+                    .filter(isNodeLike)
+                    .sort((a, b) => b.retainedSize - a.retainedSize);
+                const paginationData = this.#dataWithPagination(sortedItems, this.#heapSnapshotOptions.pagination);
+                response.push(HeapSnapshotFormatter.formatNodes(paginationData.items));
+                structuredContent.pagination = paginationData.pagination;
+                response.push(...paginationData.info);
+                structuredContent.heapSnapshotNodes = paginationData.items;
+            }
         }
         if (data.detailedNetworkRequest) {
             response.push(data.detailedNetworkRequest.toStringDetailed());
@@ -729,16 +761,21 @@ Call ${handleDialog.name} to handle it before continuing.`);
             const messages = data.consoleMessages ?? [];
             response.push('## Console messages');
             if (messages.length) {
-                const paginationData = this.#dataWithPagination(messages, this.#consoleDataOptions.pagination);
+                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(message => message.toString()));
-                structuredContent.consoleMessages = paginationData.items.map(message => message.toJSON());
+                response.push(...paginationData.items.map(item => item.toString()));
+                structuredContent.consoleMessages = paginationData.items.map(item => item.toJSON());
             }
             else {
                 response.push('<no console messages found>');
             }
         }
+        if (data.errorMessage) {
+            response.push(`Error: ${data.errorMessage}`);
+            structuredContent.errorMessage = data.errorMessage;
+        }
         const text = {
             type: 'text',
             text: response.join('\n'),
@@ -800,3 +837,4 @@ function createStructuredPage(page, context) {
     }
     return entry;
 }
+//# sourceMappingURL=McpResponse.js.map

package/build/src/Mutex.js

@@ -35,3 +35,4 @@ export class Mutex {
         resolve();
     }
 }
+//# sourceMappingURL=Mutex.js.map