opera-devtools-mcp 0.2.4 → 0.3.0

package/build/src/McpResponse.js

@@ -6,110 +6,18 @@
  * Modified by Opera Software AS.
  */
 import { ConsoleFormatter } from './formatters/ConsoleFormatter.js';
-import { HeapSnapshotFormatter } from './formatters/HeapSnapshotFormatter.js';
-import { isNodeLike } from './formatters/HeapSnapshotFormatter.js';
+import { HeapSnapshotFormatter, isEdgeLike, 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 { UncaughtError } from './collectors/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';
+import { DevTools, getToonEncode, getGcfEncode } from './third_party/index.js';
+import { handleDialog, listPages } from './tools/pages.js';
+import { getInsightOutput, getTraceSummary, } from './processors/PerformanceTrace.js';
+import { stableIdSymbol } from './utils/id.js';
 import { paginate } from './utils/pagination.js';
-export function replaceHtmlElementsWithUids(schema) {
-    if (typeof schema === 'boolean') {
-        return;
-    }
-    let isHtmlElement = false;
-    for (const [key, value] of Object.entries(schema)) {
-        if (key === 'x-mcp-type' && value === 'HTMLElement') {
-            isHtmlElement = true;
-            break;
-        }
-    }
-    if (isHtmlElement) {
-        schema.properties = { uid: { type: 'string' } };
-        schema.required = ['uid'];
-    }
-    if (schema.properties) {
-        for (const key of Object.keys(schema.properties)) {
-            replaceHtmlElementsWithUids(schema.properties[key]);
-        }
-    }
-    if (schema.items) {
-        if (Array.isArray(schema.items)) {
-            for (const item of schema.items) {
-                replaceHtmlElementsWithUids(item);
-            }
-        }
-        else {
-            replaceHtmlElementsWithUids(schema.items);
-        }
-    }
-    if (schema.anyOf) {
-        for (const s of schema.anyOf) {
-            replaceHtmlElementsWithUids(s);
-        }
-    }
-    if (schema.allOf) {
-        for (const s of schema.allOf) {
-            replaceHtmlElementsWithUids(s);
-        }
-    }
-    if (schema.oneOf) {
-        for (const s of schema.oneOf) {
-            replaceHtmlElementsWithUids(s);
-        }
-    }
-}
-async function getToolGroup(page) {
-    // Check if there is a `devtoolstooldiscovery` event listener
-    const windowHandle = await page.pptrPage.evaluateHandle(() => window);
-    // @ts-expect-error internal API
-    const client = page.pptrPage._client();
-    const { listeners } = await client.send('DOMDebugger.getEventListeners', {
-        objectId: windowHandle.remoteObject().objectId,
-    });
-    if (listeners.find(l => l.type === 'devtoolstooldiscovery') === undefined) {
-        return;
-    }
-    const toolGroup = await page.pptrPage.evaluate(() => {
-        return new Promise(resolve => {
-            const event = new CustomEvent('devtoolstooldiscovery');
-            // @ts-expect-error Adding custom property
-            event.respondWith = (toolGroup) => {
-                if (!window.__dtmcp) {
-                    window.__dtmcp = {};
-                }
-                window.__dtmcp.toolGroup = 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) {
-                            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`);
-                        }
-                        return await tool.execute(args);
-                    };
-                }
-                resolve(toolGroup);
-            };
-            window.dispatchEvent(event);
-            // If the page does not synchronously call `event.respondWith`, return instead of timing out
-            setTimeout(() => {
-                resolve(null);
-            }, 0);
-        });
-    });
-    for (const tool of toolGroup?.tools ?? []) {
-        replaceHtmlElementsWithUids(tool.inputSchema);
-    }
-    return toolGroup;
-}
+const { formatBytesToKb } = DevTools.I18n.ByteUtilities;
 export class McpResponse {
     #includePages = false;
     #includeExtensionServiceWorkers = false;
@@ -136,6 +44,11 @@ export class McpResponse {
     #redactNetworkHeaders = true;
     #error;
     #logCallback;
+    #attachedWaitForResult;
+    #reconnectNotice = false;
+    get #deviceScope() {
+        return this.#page?.viewport?.isMobile ? 'PHONE' : 'DESKTOP';
+    }
     constructor(args, logCallback) {
         this.#args = args;
         this.#logCallback = logCallback;
@@ -149,6 +62,13 @@ export class McpResponse {
     setRedactNetworkHeaders(value) {
         this.#redactNetworkHeaders = value;
     }
+    /**
+     * Surfaces a one-time note that the browser reconnected and page ids changed.
+     * Set by the tool handler when the context reports a pending reconnect notice.
+     */
+    setReconnectNotice() {
+        this.#reconnectNotice = true;
+    }
     attachDevToolsData(data) {
         this.#devToolsData = data;
     }
@@ -183,7 +103,7 @@ export class McpResponse {
         }
         this.#networkRequestsOptions = {
             include: value,
-            pagination: options?.pageSize || options?.pageIdx
+            pagination: options?.pageSize !== undefined || options?.pageIdx !== undefined
                 ? {
                     pageSize: options.pageSize,
                     pageIdx: options.pageIdx,
@@ -201,7 +121,7 @@ export class McpResponse {
         }
         this.#consoleDataOptions = {
             include: value,
-            pagination: options?.pageSize || options?.pageIdx
+            pagination: options?.pageSize !== undefined || options?.pageIdx !== undefined
                 ? {
                     pageSize: options.pageSize,
                     pageIdx: options.pageIdx,
@@ -209,6 +129,8 @@ export class McpResponse {
                 : undefined,
             types: options?.types,
             includePreservedMessages: options?.includePreservedMessages,
+            includeStackTraces: options?.includeStackTraces,
+            serviceWorkerId: options?.serviceWorkerId,
         };
     }
     setError(error) {
@@ -270,20 +192,25 @@ export class McpResponse {
     appendResponseLine(value) {
         this.#textResponseLines.push(value);
     }
-    setHeapSnapshotAggregates(aggregates, options) {
+    attachWaitForResult(result) {
+        this.#attachedWaitForResult = result;
+    }
+    setHeapSnapshotAggregates(aggregateData, options) {
         this.#heapSnapshotOptions = {
             ...this.#heapSnapshotOptions,
             include: true,
-            aggregates,
+            aggregateData,
             pagination: options,
         };
     }
-    setHeapSnapshotStats(stats, staticData) {
+    setHeapSnapshotStats(stats, staticData, nativeContextSizes, retainedByContextSummary) {
         this.#heapSnapshotOptions = {
             ...this.#heapSnapshotOptions,
             include: true,
             stats,
             staticData,
+            nativeContextSizes,
+            retainedByContextSummary,
         };
     }
     setHeapSnapshotNodes(nodes, options) {
@@ -294,6 +221,49 @@ export class McpResponse {
             pagination: options,
         };
     }
+    setHeapSnapshotDuplicateStrings(duplicateStrings, options) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            duplicateStrings,
+            pagination: options,
+        };
+    }
+    setHeapSnapshotRetainingPaths(retainingPaths) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            retainingPaths,
+        };
+    }
+    setHeapSnapshotDominators(dominators) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            dominators,
+        };
+    }
+    setHeapSnapshotClassDiffs(classDiffs) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            classDiffs,
+        };
+    }
+    setHeapSnapshotDetailedClassDiff(detailedClassDiff) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            detailedClassDiff,
+        };
+    }
+    setHeapSnapshotObjectDetails(objectInfo) {
+        this.#heapSnapshotOptions = {
+            ...this.#heapSnapshotOptions,
+            include: true,
+            objectInfo,
+        };
+    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -309,167 +279,189 @@ export class McpResponse {
     get listWebMcpTools() {
         return this.#listWebMcpTools;
     }
-    async handle(toolName, context) {
+    async #handleSnapshot(context) {
         if (this.#includePages) {
             await context.createPagesSnapshot();
         }
-        if (this.#includeExtensionServiceWorkers) {
-            await context.createExtensionServiceWorkersSnapshot();
+        if (!this.#snapshotParams) {
+            return undefined;
         }
-        let snapshot;
-        if (this.#snapshotParams) {
-            if (!this.#page) {
-                throw new Error('Response must have a page');
-            }
-            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);
-                if (this.#snapshotParams.filePath) {
-                    const result = await context.saveFile(new TextEncoder().encode(formatter.toString()), this.#snapshotParams.filePath, '.txt');
-                    snapshot = result.filename;
-                }
-                else {
-                    snapshot = formatter;
-                }
-            }
+        if (!this.#page) {
+            throw new Error('Response must have a page');
         }
-        let detailedNetworkRequest;
-        if (this.#attachedNetworkRequestId) {
-            if (!this.#page) {
-                throw new Error(`Response must have an McpPage`);
-            }
-            const request = context.getNetworkRequestById(this.#page, this.#attachedNetworkRequestId);
-            const formatter = await NetworkFormatter.from(request, {
-                requestId: this.#attachedNetworkRequestId,
-                requestIdResolver: req => context.getNetworkRequestStableId(req),
-                fetchData: true,
-                requestFilePath: this.#attachedNetworkRequestOptions?.requestFilePath,
-                responseFilePath: this.#attachedNetworkRequestOptions?.responseFilePath,
-                saveFile: (data, filename, extension) => context.saveFile(data, filename, extension),
-                redactNetworkHeaders: this.#redactNetworkHeaders,
+        this.#page.textSnapshot = await TextSnapshot.create(this.#page, {
+            verbose: this.#snapshotParams.verbose,
+            devtoolsData: this.#devToolsData,
+        });
+        const formatter = new SnapshotFormatter(this.#page.textSnapshot);
+        if (this.#snapshotParams.filePath) {
+            const result = await context.saveFile(new TextEncoder().encode(formatter.toString()), this.#snapshotParams.filePath, '.txt');
+            return result.filename;
+        }
+        else {
+            return formatter;
+        }
+    }
+    async #handleAttachedNetworkRequest(context) {
+        if (!this.#attachedNetworkRequestId) {
+            return undefined;
+        }
+        if (!this.#page) {
+            throw new Error(`Response must have an McpPage`);
+        }
+        const request = this.#page.getNetworkRequestById(this.#attachedNetworkRequestId);
+        return await NetworkFormatter.from(request, {
+            requestId: this.#attachedNetworkRequestId,
+            requestIdResolver: req => this.getNetworkRequestStableId(req),
+            fetchData: true,
+            requestFilePath: this.#attachedNetworkRequestOptions?.requestFilePath,
+            responseFilePath: this.#attachedNetworkRequestOptions?.responseFilePath,
+            saveFile: (data, filename, extension) => context.saveFile(data, filename, extension),
+            redactNetworkHeaders: this.#redactNetworkHeaders,
+        });
+    }
+    async #handleAttachedConsoleMessage() {
+        if (!this.#attachedConsoleMessageId) {
+            return undefined;
+        }
+        if (!this.#page) {
+            throw new Error(`Response must have an McpPage`);
+        }
+        const message = this.#page.getConsoleMessageById(this.#attachedConsoleMessageId);
+        const consoleMessageStableId = this.#attachedConsoleMessageId;
+        if ('args' in message || message instanceof UncaughtError) {
+            const consoleMessage = message;
+            return await ConsoleFormatter.from(consoleMessage, {
+                id: consoleMessageStableId,
+                fetchDetailedData: true,
+                devTools: this.#page.devtoolsUniverse,
             });
-            detailedNetworkRequest = formatter;
         }
-        let detailedConsoleMessage;
-        if (this.#attachedConsoleMessageId) {
-            if (!this.#page) {
-                throw new Error(`Response must have an McpPage`);
-            }
-            const message = context.getConsoleMessageById(this.#page, this.#attachedConsoleMessageId);
-            const consoleMessageStableId = this.#attachedConsoleMessageId;
-            if ('args' in message || message instanceof UncaughtError) {
-                const consoleMessage = message;
-                const devTools = context.getDevToolsUniverse(this.#page);
-                detailedConsoleMessage = await ConsoleFormatter.from(consoleMessage, {
-                    id: consoleMessageStableId,
-                    fetchDetailedData: true,
-                    devTools: devTools ?? undefined,
-                });
-            }
-            else if (message instanceof DevTools.AggregatedIssue) {
-                const formatter = new IssueFormatter(message, {
-                    id: consoleMessageStableId,
-                    requestIdResolver: context.resolveCdpRequestId.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);
-                }
-                detailedConsoleMessage = formatter;
+        else if (message instanceof DevTools.AggregatedIssue) {
+            const formatter = new IssueFormatter(message, {
+                id: consoleMessageStableId,
+                requestIdResolver: this.#page.resolveCdpRequestId.bind(this.#page),
+                elementIdResolver: this.#page.textSnapshot?.resolveCdpElementId.bind(this.#page.textSnapshot),
+            });
+            if (!formatter.isValid()) {
+                throw new Error("Can't provide details for the msgid " + consoleMessageStableId);
             }
+            return formatter;
         }
-        let extensions;
-        if (this.#listExtensions) {
-            extensions = await context.listExtensions();
+        else {
+            return undefined;
         }
-        // Null indicates no tools.
-        let thirdPartyDeveloperTools;
+    }
+    async #handleThirdPartyDevelopeTools() {
         if (this.#args.categoryExperimentalThirdParty &&
             this.#listThirdPartyDeveloperTools &&
             this.#page) {
-            thirdPartyDeveloperTools = await getToolGroup(this.#page);
-            if (thirdPartyDeveloperTools) {
-                this.#page.thirdPartyDeveloperTools = thirdPartyDeveloperTools;
-            }
+            return await this.#page.getToolGroups();
         }
-        let webmcpTools;
+        return undefined;
+    }
+    async #handleWebMCP() {
         if (this.#args.categoryExperimentalWebmcp &&
             this.#listWebMcpTools &&
             this.#page) {
-            webmcpTools = this.#page.getWebMcpTools();
+            return this.#page.getWebMcpTools();
         }
-        let consoleMessages;
-        if (this.#consoleDataOptions?.include) {
-            if (!this.#page) {
+        return undefined;
+    }
+    async #handleConsoleList(context) {
+        if (!this.#consoleDataOptions?.include) {
+            return undefined;
+        }
+        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`);
             }
-            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 => {
-                    if ('type' in message) {
-                        return normalizedTypes.has(message.type());
-                    }
-                    if (message instanceof DevTools.AggregatedIssue) {
-                        return normalizedTypes.has('issue');
-                    }
-                    return normalizedTypes.has('error');
-                });
-            }
-            consoleMessages = (await Promise.all(messages.map(async (item) => {
-                const consoleMessageStableId = context.getConsoleMessageStableId(item);
-                if ('args' in item || item instanceof UncaughtError) {
-                    const consoleMessage = item;
-                    const devTools = context.getDevToolsUniverse(page);
-                    return await ConsoleFormatter.from(consoleMessage, {
-                        id: consoleMessageStableId,
-                        fetchDetailedData: false,
-                        devTools: devTools ?? undefined,
-                    });
+            messages = page.getConsoleData(this.#consoleDataOptions.includePreservedMessages);
+        }
+        if (this.#consoleDataOptions.types?.length) {
+            const normalizedTypes = new Set(this.#consoleDataOptions.types);
+            messages = messages.filter(message => {
+                if ('type' in message) {
+                    return normalizedTypes.has(message.type());
                 }
-                if (item instanceof DevTools.AggregatedIssue) {
-                    const formatter = new IssueFormatter(item, {
-                        id: consoleMessageStableId,
-                    });
-                    if (!formatter.isValid()) {
-                        return null;
-                    }
-                    return formatter;
+                if (message instanceof DevTools.AggregatedIssue) {
+                    return normalizedTypes.has('issue');
                 }
-                return null;
-            }))).filter(item => item !== null);
+                return normalizedTypes.has('error');
+            });
         }
-        let networkRequests;
-        if (this.#networkRequestsOptions?.include) {
-            if (!this.#page) {
-                throw new Error(`Response must have an McpPage`);
-            }
-            let requests = context.getNetworkRequests(this.#page, this.#networkRequestsOptions?.includePreservedRequests);
-            // Apply resource type filtering if specified
-            if (this.#networkRequestsOptions.resourceTypes?.length) {
-                const normalizedTypes = new Set(this.#networkRequestsOptions.resourceTypes);
-                requests = requests.filter(request => {
-                    const type = request.resourceType();
-                    return normalizedTypes.has(type);
+        return (await Promise.all(messages.map(async (item) => {
+            const consoleMessageStableId = this.getConsoleMessageStableId(item);
+            if ('args' in item || item instanceof UncaughtError) {
+                const consoleMessage = item;
+                return await ConsoleFormatter.from(consoleMessage, {
+                    id: consoleMessageStableId,
+                    fetchDetailedData: false,
+                    fetchStackTrace: this.#consoleDataOptions?.includeStackTraces,
+                    devTools: page ? page.devtoolsUniverse : undefined,
                 });
             }
-            if (requests.length) {
-                networkRequests = await Promise.all(requests.map(request => NetworkFormatter.from(request, {
-                    requestId: context.getNetworkRequestStableId(request),
-                    selectedInDevToolsUI: context.getNetworkRequestStableId(request) ===
-                        this.#networkRequestsOptions?.networkRequestIdInDevToolsUI,
-                    fetchData: false,
-                    saveFile: (data, filename, extension) => context.saveFile(data, filename, extension),
-                    redactNetworkHeaders: this.#redactNetworkHeaders,
-                })));
+            if (item instanceof DevTools.AggregatedIssue) {
+                const formatter = new IssueFormatter(item, {
+                    id: consoleMessageStableId,
+                });
+                if (!formatter.isValid()) {
+                    return null;
+                }
+                return formatter;
             }
+            return null;
+        }))).filter(item => item !== null);
+    }
+    async #handleNetworkRequestList(context) {
+        if (!this.#networkRequestsOptions?.include) {
+            return undefined;
+        }
+        if (!this.#page) {
+            throw new Error(`Response must have an McpPage`);
+        }
+        let requests = this.#page.getNetworkRequests(this.#networkRequestsOptions?.includePreservedRequests);
+        // Apply resource type filtering if specified
+        if (this.#networkRequestsOptions.resourceTypes?.length) {
+            const normalizedTypes = new Set(this.#networkRequestsOptions.resourceTypes);
+            requests = requests.filter(request => {
+                const type = request.resourceType();
+                return normalizedTypes.has(type);
+            });
         }
-        return this.format(toolName, context, {
+        return await Promise.all(requests.map(request => NetworkFormatter.from(request, {
+            requestId: this.getNetworkRequestStableId(request),
+            selectedInDevToolsUI: this.getNetworkRequestStableId(request) ===
+                this.#networkRequestsOptions?.networkRequestIdInDevToolsUI,
+            fetchData: false,
+            saveFile: (data, filename, extension) => context.saveFile(data, filename, extension),
+            redactNetworkHeaders: this.#redactNetworkHeaders,
+        })));
+    }
+    async handle(context, dataFormat = 'default') {
+        const [snapshot, detailedNetworkRequest, detailedConsoleMessage, thirdPartyDeveloperTools, webmcpTools, consoleMessages, networkRequests,] = await Promise.all([
+            this.#handleSnapshot(context),
+            this.#handleAttachedNetworkRequest(context),
+            this.#handleAttachedConsoleMessage(),
+            this.#handleThirdPartyDevelopeTools(),
+            this.#handleWebMCP(),
+            this.#handleConsoleList(context),
+            this.#handleNetworkRequestList(context),
+        ]);
+        if (this.#includeExtensionServiceWorkers) {
+            await context.createExtensionServiceWorkersSnapshot();
+        }
+        let extensions;
+        if (this.#listExtensions) {
+            extensions = await context.listExtensions();
+        }
+        return this.format(context, {
             detailedConsoleMessage,
             consoleMessages,
             snapshot,
@@ -482,15 +474,56 @@ export class McpResponse {
             thirdPartyDeveloperTools,
             webmcpTools,
             errorMessage: this.#error?.message,
-        });
+        }, dataFormat);
     }
-    format(toolName, context, data) {
+    getConsoleMessageStableId(message) {
+        return message[stableIdSymbol] ?? -1;
+    }
+    getNetworkRequestStableId(request) {
+        return request[stableIdSymbol] ?? -1;
+    }
+    async format(context, data, dataFormat = 'default') {
         const structuredContent = {};
+        // Resolve the compact encoder based on the chosen format
+        let compactEncode;
+        if (dataFormat === 'toon') {
+            try {
+                compactEncode = await getToonEncode();
+            }
+            catch {
+                throw new Error('The `@toon-format/toon` package is required to use --experimentalDataFormat=toon. ' +
+                    'Make sure the peer dependency is installed:\n' +
+                    '- For npx: npx --package chrome-devtools-mcp@latest --package @toon-format/toon@latest chrome-devtools-mcp --experimentalDataFormat=toon\n' +
+                    '- For npm: npm install @toon-format/toon (add -g if installed globally)');
+            }
+        }
+        else if (dataFormat === 'gcf') {
+            try {
+                compactEncode = await getGcfEncode();
+            }
+            catch {
+                throw new Error('The `@blackwell-systems/gcf` package is required to use --experimentalDataFormat=gcf. ' +
+                    'Make sure the peer dependency is installed:\n' +
+                    '- For npx: npx --package chrome-devtools-mcp@latest --package @blackwell-systems/gcf@latest chrome-devtools-mcp --experimentalDataFormat=gcf\n' +
+                    '- For npm: npm install @blackwell-systems/gcf (add -g if installed globally)');
+            }
+        }
         const response = [];
+        if (this.#reconnectNotice) {
+            structuredContent.reconnected = true;
+            response.push(`Note: the browser was restarted or reconnected since the last call. Page ids have changed. Call ${listPages().name} to see open pages.`);
+        }
         if (this.#textResponseLines.length) {
             structuredContent.message = this.#textResponseLines.join('\n');
             response.push(...this.#textResponseLines);
         }
+        if (this.#attachedWaitForResult) {
+            if (this.#attachedWaitForResult.navigatedToUrl) {
+                response.push(`Page navigated to ${this.#attachedWaitForResult.navigatedToUrl}.`);
+                structuredContent.navigatedToUrl =
+                    this.#attachedWaitForResult.navigatedToUrl;
+            }
+        }
         const networkConditions = this.#page?.networkConditions;
         if (networkConditions) {
             const timeout = this.#page.pptrPage.getDefaultNavigationTimeout();
@@ -499,6 +532,11 @@ export class McpResponse {
             structuredContent.networkConditions = networkConditions;
             structuredContent.navigationTimeout = timeout;
         }
+        const geolocation = this.#page?.geolocation;
+        if (geolocation) {
+            response.push(`Emulating geolocation: latitude=${geolocation.latitude}, longitude=${geolocation.longitude}`);
+            structuredContent.geolocation = geolocation;
+        }
         const viewport = this.#page?.viewport;
         if (viewport) {
             response.push(`Emulating viewport: ${JSON.stringify(viewport)}`);
@@ -535,25 +573,40 @@ Call ${handleDialog.name} to handle it before continuing.`);
         }
         if (this.#includePages) {
             const allPages = context.getPages();
-            const { regularPages, extensionPages } = allPages.reduce((acc, page) => {
-                if (page.url().startsWith('chrome-extension://')) {
-                    acc.extensionPages.push(page);
+            const { regularPages, extensionPages } = allPages.reduce((acc, mcpPage) => {
+                if (mcpPage.pptrPage.url().startsWith('chrome-extension://')) {
+                    acc.extensionPages.push(mcpPage);
                 }
                 else {
-                    acc.regularPages.push(page);
+                    acc.regularPages.push(mcpPage);
                 }
                 return acc;
             }, { regularPages: [], extensionPages: [] });
+            const selectionFallback = context.getSelectedPageFallback();
+            if (selectionFallback) {
+                let selectedPageId;
+                try {
+                    selectedPageId = context.getSelectedMcpPage().id;
+                }
+                catch {
+                    selectedPageId = undefined;
+                }
+                response.push(`Note: the previously selected page ${selectionFallback.wasClosed ? 'was closed' : 'is no longer listed'}.${selectedPageId !== undefined ? ` Page ${selectedPageId} is now selected.` : ''}`);
+            }
             if (regularPages.length) {
                 const parts = [`## Pages`];
                 const structuredPages = [];
-                for (const page of regularPages) {
-                    const isolatedContextName = context.getIsolatedContextName(page);
+                for (const mcpPage of regularPages) {
+                    const isolatedContextName = mcpPage.isolatedContextName;
                     const contextLabel = isolatedContextName
                         ? ` isolatedContext=${isolatedContextName}`
                         : '';
-                    parts.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
-                    structuredPages.push(createStructuredPage(page, context));
+                    const title = await fetchPageTitle(mcpPage.pptrPage);
+                    const pageLabel = title
+                        ? `${truncateTitle(title)} (${mcpPage.pptrPage.url()})`
+                        : mcpPage.pptrPage.url();
+                    parts.push(`${mcpPage.id}: ${pageLabel}${context.isPageSelected(mcpPage) ? ' [selected]' : ''}${contextLabel}`);
+                    structuredPages.push(createStructuredPage(mcpPage, context, title));
                 }
                 response.push(...parts);
                 structuredContent.pages = structuredPages;
@@ -562,13 +615,17 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 if (extensionPages.length) {
                     response.push(`## Extension Pages`);
                     const structuredExtensionPages = [];
-                    for (const page of extensionPages) {
-                        const isolatedContextName = context.getIsolatedContextName(page);
+                    for (const mcpPage of extensionPages) {
+                        const isolatedContextName = mcpPage.isolatedContextName;
                         const contextLabel = isolatedContextName
                             ? ` isolatedContext=${isolatedContextName}`
                             : '';
-                        response.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
-                        structuredExtensionPages.push(createStructuredPage(page, context));
+                        const title = await fetchPageTitle(mcpPage.pptrPage);
+                        const pageLabel = title
+                            ? `${truncateTitle(title)} (${mcpPage.pptrPage.url()})`
+                            : mcpPage.pptrPage.url();
+                        response.push(`${mcpPage.id}: ${pageLabel}${context.isPageSelected(mcpPage) ? ' [selected]' : ''}${contextLabel}`);
+                        structuredExtensionPages.push(createStructuredPage(mcpPage, context, title));
                     }
                     structuredContent.extensionPages = structuredExtensionPages;
                 }
@@ -594,7 +651,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 = [];
@@ -602,13 +659,17 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 for (const [insightName, model] of Object.entries(insightSet.model)) {
                     structuredContent.traceInsights.push({
                         insightName,
-                        insightKey: model.insightKey,
+                        insightKey: typeof model === 'object' &&
+                            model !== null &&
+                            'insightKey' in model
+                            ? model.insightKey
+                            : undefined,
                     });
                 }
             }
         }
         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);
             }
@@ -642,9 +703,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(compactEncode
+                    ? compactEncode(structuredContent.snapshot)
+                    : data.snapshot.toString());
             }
         }
         if (this.#heapSnapshotOptions?.include) {
@@ -661,28 +724,125 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 structuredContent.heapSnapshot = structuredContent.heapSnapshot || {};
                 structuredContent.heapSnapshot.staticData = staticData;
             }
-            const aggregates = this.#heapSnapshotOptions.aggregates;
-            if (aggregates) {
-                const sortedEntries = HeapSnapshotFormatter.sort(aggregates);
+            const nativeContextSizes = this.#heapSnapshotOptions.nativeContextSizes;
+            if (nativeContextSizes) {
+                response.push('### Native Contexts');
+                response.push(HeapSnapshotFormatter.formatNativeContextSizes(nativeContextSizes));
+                structuredContent.heapSnapshot = structuredContent.heapSnapshot || {};
+                structuredContent.heapSnapshot.nativeContextSizes = nativeContextSizes;
+            }
+            const retainedByContextSummary = this.#heapSnapshotOptions.retainedByContextSummary;
+            if (retainedByContextSummary) {
+                response.push('### Retained by Context Summary');
+                response.push(HeapSnapshotFormatter.formatRetainedByContextSummary(retainedByContextSummary));
+                structuredContent.heapSnapshot = structuredContent.heapSnapshot || {};
+                structuredContent.heapSnapshot.retainedByContextSummary =
+                    retainedByContextSummary;
+            }
+            const aggregateData = this.#heapSnapshotOptions.aggregateData;
+            if (aggregateData) {
+                const sortedEntries = HeapSnapshotFormatter.sort(aggregateData.aggregates);
                 const paginationData = this.#dataWithPagination(sortedEntries, this.#heapSnapshotOptions.pagination);
+                response.push(`Objects: ${aggregateData.objectCount}`);
+                response.push(`Total shallow size: ${formatBytesToKb(aggregateData.totalSelfSize)}`);
+                structuredContent.heapSnapshot = structuredContent.heapSnapshot || {};
+                structuredContent.heapSnapshot.aggregateStats = {
+                    objectCount: aggregateData.objectCount,
+                    totalSelfSize: aggregateData.totalSelfSize,
+                };
                 structuredContent.pagination = paginationData.pagination;
                 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(compactEncode
+                    ? compactEncode(structuredContent.heapSnapshotData)
+                    : formatter.toString());
             }
             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);
+                let items = Array.from(nodes.items);
+                const firstItem = nodes.items[0];
+                if (firstItem) {
+                    if (isNodeLike(firstItem)) {
+                        items = items
+                            .filter(isNodeLike)
+                            .sort((a, b) => b.retainedSize - a.retainedSize);
+                    }
+                    else if (isEdgeLike(firstItem)) {
+                        items = items.filter(isEdgeLike);
+                    }
+                }
+                const paginationData = this.#dataWithPagination(items, this.#heapSnapshotOptions.pagination);
                 response.push(HeapSnapshotFormatter.formatNodes(paginationData.items));
                 structuredContent.pagination = paginationData.pagination;
                 response.push(...paginationData.info);
                 structuredContent.heapSnapshotNodes = paginationData.items;
             }
+            const retainingPaths = this.#heapSnapshotOptions.retainingPaths;
+            if (retainingPaths) {
+                response.push('### Retaining Paths');
+                const { paths, limitsReached } = retainingPaths;
+                if (paths.length === 0) {
+                    response.push('No retaining paths found.');
+                }
+                else {
+                    response.push(HeapSnapshotFormatter.formatRetainingPaths(paths));
+                }
+                const reached = Object.entries(limitsReached)
+                    .filter(([, hit]) => hit)
+                    .map(([limit]) => limit);
+                if (reached.length > 0) {
+                    response.push(`Note: results are truncated, the following limits were reached: ${reached.join(', ')}.`);
+                }
+                structuredContent.heapSnapshotRetainingPaths =
+                    retainingPaths;
+            }
+            const dominators = this.#heapSnapshotOptions.dominators;
+            if (dominators) {
+                response.push('### Dominator Chain');
+                if (dominators.length === 0) {
+                    response.push('No dominators found.');
+                }
+                else {
+                    response.push(HeapSnapshotFormatter.formatDominators(dominators));
+                }
+                structuredContent.heapSnapshotDominators = dominators;
+            }
+            const classDiffs = this.#heapSnapshotOptions.classDiffs;
+            if (classDiffs) {
+                response.push('### Heap Snapshot Diff');
+                response.push(compactEncode
+                    ? compactEncode(classDiffs)
+                    : HeapSnapshotFormatter.formatDiffSummary(classDiffs));
+                structuredContent.heapSnapshotClassDiffs = classDiffs;
+            }
+            const detailedClassDiff = this.#heapSnapshotOptions.detailedClassDiff;
+            if (detailedClassDiff) {
+                response.push('### Heap Snapshot Detailed Diff');
+                response.push(compactEncode
+                    ? compactEncode(detailedClassDiff)
+                    : HeapSnapshotFormatter.formatDiffDetails(detailedClassDiff));
+                structuredContent.heapSnapshotDetailedClassDiff = detailedClassDiff;
+            }
+            const duplicateStrings = this.#heapSnapshotOptions.duplicateStrings;
+            if (duplicateStrings) {
+                response.push('### Duplicate Strings');
+                const paginationData = this.#dataWithPagination(duplicateStrings, this.#heapSnapshotOptions.pagination);
+                structuredContent.pagination = paginationData.pagination;
+                response.push(...paginationData.info);
+                const formatted = HeapSnapshotFormatter.formatDuplicateStrings(paginationData.items);
+                response.push(formatted);
+                structuredContent.heapSnapshotDuplicateStrings = paginationData.items;
+            }
+            const objectInfo = this.#heapSnapshotOptions.objectInfo;
+            if (objectInfo) {
+                response.push('### Object Details');
+                response.push(compactEncode
+                    ? compactEncode(objectInfo)
+                    : HeapSnapshotFormatter.formatObjectInfo(objectInfo));
+                structuredContent.heapSnapshotObjectDetails = objectInfo;
+            }
         }
         if (data.detailedNetworkRequest) {
             response.push(data.detailedNetworkRequest.toStringDetailed());
@@ -710,18 +870,11 @@ Call ${handleDialog.name} to handle it before continuing.`);
                 response.push(extensionsMessage);
             }
         }
-        if (data.thirdPartyDeveloperTools !== undefined) {
-            if (data.thirdPartyDeveloperTools) {
-                structuredContent.thirdPartyDeveloperTools =
-                    data.thirdPartyDeveloperTools;
-            }
+        const thirdPartyDeveloperTools = data.thirdPartyDeveloperTools;
+        if (thirdPartyDeveloperTools?.length) {
+            structuredContent.thirdPartyDeveloperTools = 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 thirdPartyDeveloperTools) {
                 response.push(`${toolGroup.name}: ${toolGroup.description}`);
                 response.push('Available tools:');
                 const toolDefinitionsMessage = toolGroup.tools
@@ -760,11 +913,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(...(compactEncode
+                        ? [compactEncode(structuredContent.networkRequests)]
+                        : paginationData.items.map(i => i.toString())));
                 }
             }
             else {
@@ -778,9 +930,17 @@ 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 (compactEncode) {
+                    response.push(compactEncode(structuredContent.consoleMessages));
+                }
+                else {
+                    response.push(...paginationData.items.map(item => item.toString()));
+                }
+                if (structuredContent.consoleMessages.some(message => 'stackTrace' in message)) {
+                    response.push('Note: stack trace line and column numbers use 1-based indexing');
+                }
             }
             else {
                 response.push('<no console messages found>');
@@ -839,12 +999,26 @@ Call ${handleDialog.name} to handle it before continuing.`);
         this.#textResponseLines = [];
     }
 }
-function createStructuredPage(page, context) {
-    const isolatedContextName = context.getIsolatedContextName(page);
+function truncateTitle(title, maxLength = 50) {
+    if (title.length <= maxLength) {
+        return title;
+    }
+    return title.slice(0, maxLength - 3) + '...';
+}
+async function fetchPageTitle(page) {
+    return Promise.race([
+        page.title().catch(() => ''),
+        new Promise(resolve => setTimeout(() => resolve(''), 1000)),
+    ]);
+}
+function createStructuredPage(mcpPage, context, rawTitle) {
+    const isolatedContextName = mcpPage.isolatedContextName;
+    const title = truncateTitle(rawTitle);
     const entry = {
-        id: context.getPageId(page),
-        url: page.url(),
-        selected: context.isPageSelected(page),
+        id: mcpPage.id,
+        url: mcpPage.pptrPage.url(),
+        title,
+        selected: context.isPageSelected(mcpPage),
     };
     if (isolatedContextName) {
         entry.isolatedContext = isolatedContextName;