@mcp-b/chrome-devtools-mcp 2.0.13 → 2.2.0

package/build/src/McpResponse.js

@@ -3,35 +3,64 @@
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
-import { AggregatedIssue } from '../vendor/chrome-devtools-frontend/mcp/mcp.js';
-import { mapIssueToMessageObject } from './DevtoolsUtils.js';
-import { formatConsoleEventShort, formatConsoleEventVerbose, } from './formatters/consoleFormatter.js';
-import { getFormattedHeaderValue, getFormattedResponseBody, getFormattedRequestBody, getShortDescriptionForRequest, getStatusFromRequest, } from './formatters/networkFormatter.js';
-import { formatSnapshotNode } from './formatters/snapshotFormatter.js';
+import { ConsoleFormatter } from './formatters/consoleFormatter.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 { DevTools } 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';
 export class McpResponse {
     #includePages = false;
+    #includeExtensionServiceWorkers = false;
+    #includeExtensionPages = false;
     #snapshotParams;
     #attachedNetworkRequestId;
+    #attachedNetworkRequestOptions;
     #attachedConsoleMessageId;
+    #attachedTraceSummary;
+    #attachedTraceInsight;
+    #attachedLighthouseResult;
     #textResponseLines = [];
+    #mcpContent = [];
     #images = [];
     #isError = false;
     #networkRequestsOptions;
     #consoleDataOptions;
+    #listExtensions;
     #devToolsData;
+    #tabId;
+    #args;
+    #page;
+    constructor(args) {
+        this.#args = args;
+    }
+    setPage(page) {
+        this.#page = page;
+    }
     attachDevToolsData(data) {
         this.#devToolsData = data;
     }
+    setTabId(tabId) {
+        this.#tabId = tabId;
+    }
     setIncludePages(value) {
         this.#includePages = value;
+        if (this.#args.categoryExtensions) {
+            this.#includeExtensionServiceWorkers = value;
+            this.#includeExtensionPages = value;
+        }
     }
     includeSnapshot(params) {
         this.#snapshotParams = params ?? {
             verbose: false,
         };
     }
+    setListExtensions() {
+        this.#listExtensions = true;
+    }
     setIncludeNetworkRequests(value, options) {
         if (!value) {
             this.#networkRequestsOptions = undefined;
@@ -67,15 +96,44 @@ export class McpResponse {
             includePreservedMessages: options?.includePreservedMessages,
         };
     }
-    attachNetworkRequest(reqid) {
+    attachNetworkRequest(reqid, options) {
         this.#attachedNetworkRequestId = reqid;
+        this.#attachedNetworkRequestOptions = options;
     }
     attachConsoleMessage(msgid) {
         this.#attachedConsoleMessageId = msgid;
     }
+    attachTraceSummary(result) {
+        this.#attachedTraceSummary = result;
+    }
+    attachTraceInsight(trace, insightSetId, insightName) {
+        this.#attachedTraceInsight = {
+            trace,
+            insightSetId,
+            insightName,
+        };
+    }
+    attachLighthouseResult(result) {
+        this.#attachedLighthouseResult = result;
+    }
+    appendMcpContent(value) {
+        this.#mcpContent.push(value);
+    }
+    setToolResultError(value) {
+        this.#isError = value;
+    }
     get includePages() {
         return this.#includePages;
     }
+    get attachedTraceSummary() {
+        return this.#attachedTraceSummary;
+    }
+    get attachedTracedInsight() {
+        return this.#attachedTraceInsight;
+    }
+    get attachedLighthouseResult() {
+        return this.#attachedLighthouseResult;
+    }
     get includeNetworkRequests() {
         return this.#networkRequestsOptions?.include ?? false;
     }
@@ -97,12 +155,6 @@ export class McpResponse {
     appendResponseLine(value) {
         this.#textResponseLines.push(value);
     }
-    setIsError(value) {
-        this.#isError = value;
-    }
-    get isError() {
-        return this.#isError;
-    }
     attachImage(value) {
         this.#images.push(value);
     }
@@ -112,6 +164,9 @@ export class McpResponse {
     get images() {
         return this.#images;
     }
+    get isError() {
+        return this.#isError;
+    }
     get snapshotParams() {
         return this.#snapshotParams;
     }
@@ -119,141 +174,189 @@ export class McpResponse {
         if (this.#includePages) {
             await context.createPagesSnapshot();
         }
-        let formattedSnapshot;
+        if (this.#includeExtensionServiceWorkers) {
+            await context.createExtensionServiceWorkersSnapshot();
+        }
+        let snapshot;
         if (this.#snapshotParams) {
-            await context.createTextSnapshot(this.#snapshotParams.verbose, this.#devToolsData);
-            const snapshot = context.getTextSnapshot();
-            if (snapshot) {
+            if (!this.#page) {
+                throw new Error('Response must have a page');
+            }
+            await context.createTextSnapshot(this.#page, this.#snapshotParams.verbose, this.#devToolsData);
+            const textSnapshot = this.#page.textSnapshot;
+            if (textSnapshot) {
+                const formatter = new SnapshotFormatter(textSnapshot);
                 if (this.#snapshotParams.filePath) {
-                    await context.saveFile(new TextEncoder().encode(formatSnapshotNode(snapshot.root, snapshot)), this.#snapshotParams.filePath);
-                    formattedSnapshot = `Saved snapshot to ${this.#snapshotParams.filePath}.`;
+                    await context.saveFile(new TextEncoder().encode(formatter.toString()), this.#snapshotParams.filePath);
+                    snapshot = this.#snapshotParams.filePath;
                 }
                 else {
-                    formattedSnapshot = formatSnapshotNode(snapshot.root, snapshot);
+                    snapshot = formatter;
                 }
             }
         }
-        const bodies = {};
+        let detailedNetworkRequest;
         if (this.#attachedNetworkRequestId) {
-            const request = context.getNetworkRequestById(this.#attachedNetworkRequestId);
-            bodies.requestBody = await getFormattedRequestBody(request);
-            const response = request.response();
-            if (response) {
-                bodies.responseBody = await getFormattedResponseBody(response);
+            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) => context.saveFile(data, filename),
+            });
+            detailedNetworkRequest = formatter;
         }
-        let consoleData;
+        let detailedConsoleMessage;
         if (this.#attachedConsoleMessageId) {
-            const message = context.getConsoleMessageById(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) {
+            if ('args' in message || message instanceof UncaughtError) {
                 const consoleMessage = message;
-                consoleData = {
-                    consoleMessageStableId,
-                    type: consoleMessage.type(),
-                    message: consoleMessage.text(),
-                    args: await Promise.all(consoleMessage.args().map(async (arg) => {
-                        const stringArg = await arg.jsonValue().catch(() => {
-                            // Ignore errors.
-                        });
-                        return typeof stringArg === 'object'
-                            ? JSON.stringify(stringArg)
-                            : String(stringArg);
-                    })),
-                };
+                const devTools = context.getDevToolsUniverse(this.#page);
+                detailedConsoleMessage = await ConsoleFormatter.from(consoleMessage, {
+                    id: consoleMessageStableId,
+                    fetchDetailedData: true,
+                    devTools: devTools ?? undefined,
+                });
             }
-            else if (message instanceof AggregatedIssue) {
-                const mappedIssueMessage = mapIssueToMessageObject(message);
-                if (!mappedIssueMessage)
+            else if (message instanceof DevTools.AggregatedIssue) {
+                const formatter = new IssueFormatter(message, {
+                    id: consoleMessageStableId,
+                    requestIdResolver: context.resolveCdpRequestId.bind(context, this.#page),
+                    elementIdResolver: context.resolveCdpElementId.bind(context, this.#page),
+                });
+                if (!formatter.isValid()) {
                     throw new Error("Can't provide detals for the msgid " + consoleMessageStableId);
-                consoleData = {
-                    consoleMessageStableId,
-                    ...mappedIssueMessage,
-                };
-            }
-            else {
-                consoleData = {
-                    consoleMessageStableId,
-                    type: 'error',
-                    message: message.message,
-                    args: [],
-                };
+                }
+                detailedConsoleMessage = formatter;
             }
         }
-        let consoleListData;
+        let extensions;
+        if (this.#listExtensions) {
+            extensions = context.listExtensions();
+        }
+        let consoleMessages;
         if (this.#consoleDataOptions?.include) {
-            let messages = context.getConsoleData(this.#consoleDataOptions.includePreservedMessages);
+            if (!this.#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 AggregatedIssue) {
+                    if (message instanceof DevTools.AggregatedIssue) {
                         return normalizedTypes.has('issue');
                     }
                     return normalizedTypes.has('error');
                 });
             }
-            consoleListData = (await Promise.all(messages.map(async (item) => {
+            consoleMessages = (await Promise.all(messages.map(async (item) => {
                 const consoleMessageStableId = context.getConsoleMessageStableId(item);
-                if ('args' in item) {
+                if ('args' in item || item instanceof UncaughtError) {
                     const consoleMessage = item;
-                    return {
-                        consoleMessageStableId,
-                        type: consoleMessage.type(),
-                        message: consoleMessage.text(),
-                        args: await Promise.all(consoleMessage.args().map(async (arg) => {
-                            const stringArg = await arg.jsonValue().catch(() => {
-                                // Ignore errors.
-                            });
-                            return typeof stringArg === 'object'
-                                ? JSON.stringify(stringArg)
-                                : String(stringArg);
-                        })),
-                    };
+                    const devTools = context.getDevToolsUniverse(page);
+                    return await ConsoleFormatter.from(consoleMessage, {
+                        id: consoleMessageStableId,
+                        fetchDetailedData: false,
+                        devTools: devTools ?? undefined,
+                    });
                 }
-                if (item instanceof AggregatedIssue) {
-                    const mappedIssueMessage = mapIssueToMessageObject(item);
-                    if (!mappedIssueMessage)
+                if (item instanceof DevTools.AggregatedIssue) {
+                    const formatter = new IssueFormatter(item, {
+                        id: consoleMessageStableId,
+                    });
+                    if (!formatter.isValid()) {
                         return null;
-                    return {
-                        consoleMessageStableId,
-                        ...mappedIssueMessage,
-                    };
+                    }
+                    return formatter;
                 }
-                return {
-                    consoleMessageStableId,
-                    type: 'error',
-                    message: item.message,
-                    args: [],
-                };
+                return null;
             }))).filter(item => item !== null);
         }
+        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);
+                });
+            }
+            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) => context.saveFile(data, filename),
+                })));
+            }
+        }
         return this.format(toolName, context, {
-            bodies,
-            consoleData,
-            consoleListData,
-            formattedSnapshot,
+            detailedConsoleMessage,
+            consoleMessages,
+            snapshot,
+            detailedNetworkRequest,
+            networkRequests,
+            traceInsight: this.#attachedTraceInsight,
+            traceSummary: this.#attachedTraceSummary,
+            extensions,
+            lighthouseResult: this.#attachedLighthouseResult,
         });
     }
     format(toolName, context, data) {
-        const response = [`# ${toolName} response`];
-        for (const line of this.#textResponseLines) {
-            response.push(line);
+        const structuredContent = {};
+        const response = [];
+        if (this.#textResponseLines.length) {
+            structuredContent.message = this.#textResponseLines.join('\n');
+            response.push(...this.#textResponseLines);
         }
-        const networkConditions = context.getNetworkConditions();
+        const networkConditions = this.#page?.networkConditions;
         if (networkConditions) {
-            response.push(`## Network emulation`);
-            response.push(`Emulating: ${networkConditions}`);
-            response.push(`Default navigation timeout set to ${context.getNavigationTimeout()} ms`);
+            const timeout = this.#page.pptrPage.getDefaultNavigationTimeout();
+            response.push(`Emulating network conditions: ${networkConditions}`);
+            response.push(`Default navigation timeout set to ${timeout} ms`);
+            structuredContent.networkConditions = networkConditions;
+            structuredContent.navigationTimeout = timeout;
+        }
+        const viewport = this.#page?.viewport;
+        if (viewport) {
+            response.push(`Emulating viewport: ${JSON.stringify(viewport)}`);
+            structuredContent.viewport = viewport;
         }
-        const cpuThrottlingRate = context.getCpuThrottlingRate();
+        const userAgent = this.#page?.userAgent;
+        if (userAgent) {
+            response.push(`Emulating user agent: ${userAgent}`);
+            structuredContent.userAgent = userAgent;
+        }
+        const cpuThrottlingRate = this.#page?.cpuThrottlingRate ?? 1;
         if (cpuThrottlingRate > 1) {
-            response.push(`## CPU emulation`);
-            response.push(`Emulating: ${cpuThrottlingRate}x slowdown`);
+            response.push(`Emulating CPU throttling: ${cpuThrottlingRate}x slowdown`);
+            structuredContent.cpuThrottlingRate = cpuThrottlingRate;
+        }
+        const colorScheme = this.#page?.colorScheme;
+        if (colorScheme) {
+            response.push(`Emulating color scheme: ${colorScheme}`);
+            structuredContent.colorScheme = colorScheme;
         }
-        const dialog = context.getDialog();
+        const dialog = this.#page?.getDialog();
         if (dialog) {
             const defaultValueIfNeeded = dialog.type() === 'prompt'
                 ? ` (default value: "${dialog.defaultValue()}")`
@@ -261,39 +364,164 @@ export class McpResponse {
             response.push(`# Open dialog
 ${dialog.type()}: ${dialog.message()}${defaultValueIfNeeded}.
 Call ${handleDialog.name} to handle it before continuing.`);
+            structuredContent.dialog = {
+                type: dialog.type(),
+                message: dialog.message(),
+                defaultValue: dialog.defaultValue(),
+            };
         }
         if (this.#includePages) {
-            const parts = [`## Pages`];
-            let idx = 0;
-            for (const page of context.getPages()) {
-                parts.push(`${idx}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}`);
-                idx++;
+            const allPages = context.getPages();
+            const { regularPages, extensionPages } = allPages.reduce((acc, page) => {
+                if (page.url().startsWith('chrome-extension://')) {
+                    acc.extensionPages.push(page);
+                }
+                else {
+                    acc.regularPages.push(page);
+                }
+                return acc;
+            }, { regularPages: [], extensionPages: [] });
+            if (regularPages.length) {
+                const parts = [`## Pages`];
+                const structuredPages = [];
+                for (const page of regularPages) {
+                    const isolatedContextName = context.getIsolatedContextName(page);
+                    const contextLabel = isolatedContextName
+                        ? ` isolatedContext=${isolatedContextName}`
+                        : '';
+                    parts.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
+                    structuredPages.push(createStructuredPage(page, context));
+                }
+                response.push(...parts);
+                structuredContent.pages = structuredPages;
+            }
+            if (this.#includeExtensionPages) {
+                if (extensionPages.length) {
+                    response.push(`## Extension Pages`);
+                    const structuredExtensionPages = [];
+                    for (const page of extensionPages) {
+                        const isolatedContextName = context.getIsolatedContextName(page);
+                        const contextLabel = isolatedContextName
+                            ? ` isolatedContext=${isolatedContextName}`
+                            : '';
+                        response.push(`${context.getPageId(page)}: ${page.url()}${context.isPageSelected(page) ? ' [selected]' : ''}${contextLabel}`);
+                        structuredExtensionPages.push(createStructuredPage(page, context));
+                    }
+                    structuredContent.extensionPages = structuredExtensionPages;
+                }
             }
-            response.push(...parts);
         }
-        if (data.formattedSnapshot) {
-            response.push('## Latest page snapshot');
-            response.push(data.formattedSnapshot);
+        if (this.#includeExtensionServiceWorkers) {
+            if (context.getExtensionServiceWorkers().length) {
+                response.push(`## Extension Service Workers`);
+            }
+            for (const extensionServiceWorker of context.getExtensionServiceWorkers()) {
+                response.push(`${extensionServiceWorker.id}: ${extensionServiceWorker.url}`);
+            }
+            structuredContent.extensionServiceWorkers = context
+                .getExtensionServiceWorkers()
+                .map(extensionServiceWorker => {
+                return {
+                    id: extensionServiceWorker.id,
+                    url: extensionServiceWorker.url,
+                };
+            });
         }
-        response.push(...this.#formatNetworkRequestData(context, data.bodies));
-        response.push(...this.#formatConsoleData(context, data.consoleData));
-        if (this.#networkRequestsOptions?.include) {
-            let requests = context.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);
-                });
+        if (this.#tabId) {
+            structuredContent.tabId = this.#tabId;
+        }
+        if (data.traceSummary) {
+            const summary = getTraceSummary(data.traceSummary);
+            response.push(summary);
+            structuredContent.traceSummary = summary;
+            structuredContent.traceInsights = [];
+            for (const insightSet of data.traceSummary.insights?.values() ?? []) {
+                for (const [insightName, model] of Object.entries(insightSet.model)) {
+                    structuredContent.traceInsights.push({
+                        insightName,
+                        insightKey: model.insightKey,
+                    });
+                }
+            }
+        }
+        if (data.traceInsight) {
+            const insightOutput = getInsightOutput(data.traceInsight.trace, data.traceInsight.insightSetId, data.traceInsight.insightName);
+            if ('error' in insightOutput) {
+                response.push(insightOutput.error);
+            }
+            else {
+                response.push(insightOutput.output);
+            }
+        }
+        if (data.lighthouseResult) {
+            structuredContent.lighthouseResult = data.lighthouseResult;
+            const { summary, reports } = data.lighthouseResult;
+            response.push('## Lighthouse Audit Results');
+            response.push(`Mode: ${summary.mode}`);
+            response.push(`Device: ${summary.device}`);
+            response.push(`URL: ${summary.url}`);
+            response.push('### Category Scores');
+            for (const score of summary.scores) {
+                response.push(`- ${score.title}: ${(score.score ?? 0) * 100} (${score.id})`);
+            }
+            response.push('### Audit Summary');
+            response.push(`Passed: ${summary.audits.passed}`);
+            response.push(`Failed: ${summary.audits.failed}`);
+            response.push(`Total Timing: ${summary.timing.total}ms`);
+            response.push('### Reports');
+            for (const report of reports) {
+                response.push(`- ${report}`);
             }
+        }
+        if (data.snapshot) {
+            if (typeof data.snapshot === 'string') {
+                response.push(`Saved snapshot to ${data.snapshot}.`);
+                structuredContent.snapshotFilePath = data.snapshot;
+            }
+            else {
+                response.push('## Latest page snapshot');
+                response.push(data.snapshot.toString());
+                structuredContent.snapshot = data.snapshot.toJSON();
+            }
+        }
+        if (data.detailedNetworkRequest) {
+            response.push(data.detailedNetworkRequest.toStringDetailed());
+            structuredContent.networkRequest =
+                data.detailedNetworkRequest.toJSONDetailed();
+        }
+        if (data.detailedConsoleMessage) {
+            response.push(data.detailedConsoleMessage.toStringDetailed());
+            structuredContent.consoleMessage =
+                data.detailedConsoleMessage.toJSONDetailed();
+        }
+        if (data.extensions) {
+            structuredContent.extensions = data.extensions;
+            response.push('## Extensions');
+            if (data.extensions.length === 0) {
+                response.push('No extensions installed.');
+            }
+            else {
+                const extensionsMessage = data.extensions
+                    .map(extension => {
+                    return `id=${extension.id} "${extension.name}" v${extension.version} ${extension.isEnabled ? 'Enabled' : 'Disabled'}`;
+                })
+                    .join('\n');
+                response.push(extensionsMessage);
+            }
+        }
+        if (this.#networkRequestsOptions?.include && data.networkRequests) {
+            const requests = data.networkRequests;
             response.push('## Network requests');
             if (requests.length) {
-                const data = this.#dataWithPagination(requests, this.#networkRequestsOptions.pagination);
-                response.push(...data.info);
-                for (const request of data.items) {
-                    response.push(getShortDescriptionForRequest(request, context.getNetworkRequestStableId(request), context.getNetworkRequestStableId(request) ===
-                        this.#networkRequestsOptions?.networkRequestIdInDevToolsUI));
+                const paginationData = this.#dataWithPagination(requests, this.#networkRequestsOptions.pagination);
+                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());
+                    }
                 }
             }
             else {
@@ -301,37 +529,42 @@ Call ${handleDialog.name} to handle it before continuing.`);
             }
         }
         if (this.#consoleDataOptions?.include) {
-            const messages = data.consoleListData ?? [];
+            const messages = data.consoleMessages ?? [];
             response.push('## Console messages');
             if (messages.length) {
-                const data = this.#dataWithPagination(messages, this.#consoleDataOptions.pagination);
-                response.push(...data.info);
-                response.push(...data.items.map(message => formatConsoleEventShort(message)));
+                const paginationData = this.#dataWithPagination(messages, 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());
             }
             else {
                 response.push('<no console messages found>');
-                // Provide helpful hint about preserved messages if not already enabled
-                if (!this.#consoleDataOptions.includePreservedMessages) {
-                    response.push('');
-                    response.push('Tip: Use includePreservedMessages: true to see messages from previous navigations.');
-                }
-                // Provide hint about type filtering if specified
-                if (this.#consoleDataOptions.types?.length) {
-                    response.push(`(Filtering by types: ${this.#consoleDataOptions.types.join(', ')})`);
-                }
             }
         }
-        const text = {
-            type: 'text',
-            text: response.join('\n'),
-        };
+        const textBlocks = response.length || !this.#mcpContent.length
+            ? [
+                {
+                    type: 'text',
+                    text: response.join('\n'),
+                },
+            ]
+            : [];
         const images = this.#images.map(imageData => {
             return {
                 type: 'image',
                 ...imageData,
             };
         });
-        return [text, ...images];
+        const content = [
+            ...textBlocks,
+            ...this.#mcpContent,
+            ...images,
+        ];
+        return {
+            content,
+            structuredContent,
+        };
     }
     #dataWithPagination(data, pagination) {
         const response = [];
@@ -352,61 +585,30 @@ Call ${handleDialog.name} to handle it before continuing.`);
         return {
             info: response,
             items: paginationResult.items,
+            pagination: {
+                currentPage: paginationResult.currentPage,
+                totalPages: paginationResult.totalPages,
+                hasNextPage: paginationResult.hasNextPage,
+                hasPreviousPage: paginationResult.hasPreviousPage,
+                startIndex: paginationResult.startIndex,
+                endIndex: paginationResult.endIndex,
+                invalidPage: paginationResult.invalidPage,
+            },
         };
     }
-    #formatConsoleData(context, data) {
-        const response = [];
-        if (!data) {
-            return response;
-        }
-        response.push(formatConsoleEventVerbose(data, context));
-        return response;
-    }
-    #formatNetworkRequestData(context, data) {
-        const response = [];
-        const id = this.#attachedNetworkRequestId;
-        if (!id) {
-            return response;
-        }
-        const httpRequest = context.getNetworkRequestById(id);
-        response.push(`## Request ${httpRequest.url()}`);
-        response.push(`Status:  ${getStatusFromRequest(httpRequest)}`);
-        response.push(`### Request Headers`);
-        for (const line of getFormattedHeaderValue(httpRequest.headers())) {
-            response.push(line);
-        }
-        if (data.requestBody) {
-            response.push(`### Request Body`);
-            response.push(data.requestBody);
-        }
-        const httpResponse = httpRequest.response();
-        if (httpResponse) {
-            response.push(`### Response Headers`);
-            for (const line of getFormattedHeaderValue(httpResponse.headers())) {
-                response.push(line);
-            }
-        }
-        if (data.responseBody) {
-            response.push(`### Response Body`);
-            response.push(data.responseBody);
-        }
-        const httpFailure = httpRequest.failure();
-        if (httpFailure) {
-            response.push(`### Request failed with`);
-            response.push(httpFailure.errorText);
-        }
-        const redirectChain = httpRequest.redirectChain();
-        if (redirectChain.length) {
-            response.push(`### Redirect chain`);
-            let indent = 0;
-            for (const request of redirectChain.reverse()) {
-                response.push(`${'  '.repeat(indent)}${getShortDescriptionForRequest(request, context.getNetworkRequestStableId(request))}`);
-                indent++;
-            }
-        }
-        return response;
-    }
     resetResponseLineForTesting() {
         this.#textResponseLines = [];
     }
 }
+function createStructuredPage(page, context) {
+    const isolatedContextName = context.getIsolatedContextName(page);
+    const entry = {
+        id: context.getPageId(page),
+        url: page.url(),
+        selected: context.isPageSelected(page),
+    };
+    if (isolatedContextName) {
+        entry.isolatedContext = isolatedContextName;
+    }
+    return entry;
+}