chrome-devtools-mcp 1.1.1 → 1.3.0

package/build/src/tools/pages.js

@@ -22,7 +22,7 @@ async function navigateWithInterception(page, action, allowListString, timeout)
             void interceptedRequest.continue();
         }
         else {
-            logger(`Blocking request to: ${requestUrl}`);
+            logger?.(`Blocking request to: ${requestUrl}`);
             void interceptedRequest.abort('blockedbyclient');
         }
     };
@@ -30,7 +30,7 @@ async function navigateWithInterception(page, action, allowListString, timeout)
         if (allowList) {
             page.pptrPage.off('request', requestHandler);
             await page.pptrPage.setRequestInterception(false).catch(error => {
-                logger(`Failed to disable request interception`, error);
+                logger?.(`Failed to disable request interception`, error);
             });
         }
     };
@@ -62,6 +62,7 @@ export const listPages = defineTool(args => {
         },
         schema: {},
         blockedByDialog: false,
+        verifyFilesSchema: [],
         handler: async (_request, response) => {
             response.setIncludePages(true);
             response.setListThirdPartyDeveloperTools();
@@ -86,6 +87,7 @@ export const selectPage = defineTool({
             .describe('Whether to focus the page and bring it to the top.'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response, context) => {
         const page = context.getPageById(request.params.pageId);
         context.selectPage(page);
@@ -110,6 +112,7 @@ export const closePage = defineTool({
             .describe('The ID of the page to close. Call list_pages to list pages.'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response, context) => {
         try {
             await context.closePage(request.params.pageId);
@@ -157,6 +160,7 @@ export const newPage = defineTool(args => {
             ...timeoutSchema,
         },
         blockedByDialog: false,
+        verifyFilesSchema: [],
         handler: async (request, response, context) => {
             const page = await context.newPage(request.params.background, request.params.isolatedContext);
             await navigateWithInterception(page, () => page.pptrPage.goto(request.params.url, {
@@ -204,6 +208,7 @@ export const navigatePage = definePageTool(args => {
             ...timeoutSchema,
         },
         blockedByDialog: false,
+        verifyFilesSchema: [],
         handler: async (request, response) => {
             const page = request.page;
             const options = {
@@ -290,7 +295,7 @@ export const navigatePage = definePageTool(args => {
                     await page.pptrPage
                         .removeScriptToEvaluateOnNewDocument(initScriptId)
                         .catch(error => {
-                        logger(`Failed to remove init script`, error);
+                        logger?.(`Failed to remove init script`, error);
                     });
                 }
             }
@@ -312,6 +317,7 @@ export const resizePage = definePageTool({
         height: zod.number().describe('Page height'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response, _context) => {
         const page = request.page;
         try {
@@ -354,6 +360,7 @@ export const handleDialog = definePageTool({
             .describe('Optional prompt text to enter into the dialog.'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response, _context) => {
         const page = request.page;
         const dialog = page.getDialog();
@@ -367,7 +374,7 @@ export const handleDialog = definePageTool({
                 }
                 catch (err) {
                     // Likely already handled by the user outside of MCP.
-                    logger(err);
+                    logger?.(err);
                 }
                 response.appendResponseLine('Successfully accepted the dialog');
                 break;
@@ -378,7 +385,7 @@ export const handleDialog = definePageTool({
                 }
                 catch (err) {
                     // Likely already handled.
-                    logger(err);
+                    logger?.(err);
                 }
                 response.appendResponseLine('Successfully dismissed the dialog');
                 break;
@@ -402,6 +409,7 @@ export const getTabId = definePageTool({
             .describe(`The ID of the page to get the tab ID for. Call ${listPages().name} to get available pages.`),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response, context) => {
         const page = context.getPageById(request.params.pageId);
         const tabId = page.pptrPage._tabId;

package/build/src/tools/performance.js

@@ -32,8 +32,8 @@ export const startTrace = definePageTool({
         filePath: filePathSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: ['filePath'],
     handler: async (request, response, context) => {
-        await context.validatePath(request.params.filePath);
         if (context.isRunningPerformanceTrace()) {
             response.appendResponseLine('Error: a performance trace is already running. Use performance_stop_trace to stop it. Only one trace can be running at any given time.');
             return;
@@ -96,8 +96,8 @@ export const stopTrace = definePageTool({
         filePath: filePathSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: ['filePath'],
     handler: async (request, response, context) => {
-        await context.validatePath(request.params.filePath);
         if (!context.isRunningPerformanceTrace()) {
             return;
         }
@@ -121,6 +121,7 @@ export const analyzeInsight = definePageTool({
             .describe('The name of the Insight you want more information on. For example: "DocumentLatency" or "LCPBreakdown"'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response, context) => {
         const lastRecording = context.recordedTraces().at(-1);
         if (!lastRecording) {
@@ -172,8 +173,8 @@ async function stopTracingAndAppendOutput(page, response, context, filePath) {
 }
 /** We tell CrUXManager to fetch data so it's available when DevTools.PerformanceTraceFormatter is invoked */
 async function populateCruxData(result) {
-    logger('populateCruxData called');
-    const cruxManager = DevTools.CrUXManager.instance();
+    logger?.('populateCruxData called');
+    const cruxManager = DevTools.CrUXManager.CrUXManager.instance();
     // go/jtfbx. Yes, we're aware this API key is public. ;)
     cruxManager.setEndpointForTesting('https://chromeuxreport.googleapis.com/v1/records:queryRecord?key=AIzaSyBn5gimNjhiEyA_euicSKko6IlD3HdgUfk');
     const cruxSetting = DevTools.Common.Settings.Settings.instance().createSetting('field-data', {
@@ -185,13 +186,13 @@ async function populateCruxData(result) {
     urls.push(result.parsedTrace.data.Meta.mainFrameURL);
     const urlSet = new Set(urls);
     if (urlSet.size === 0) {
-        logger('No URLs found for CrUX data');
+        logger?.('No URLs found for CrUX data');
         return;
     }
-    logger(`Fetching CrUX data for ${urlSet.size} URLs: ${Array.from(urlSet).join(', ')}`);
+    logger?.(`Fetching CrUX data for ${urlSet.size} URLs: ${Array.from(urlSet).join(', ')}`);
     const cruxData = await Promise.all(Array.from(urlSet).map(async (url) => {
         const data = await cruxManager.getFieldDataForPage(url);
-        logger(`CrUX data for ${url}: ${data ? 'found' : 'not found'}`);
+        logger?.(`CrUX data for ${url}: ${data ? 'found' : 'not found'}`);
         return data;
     }));
     result.parsedTrace.metadata.cruxFieldData = cruxData;

package/build/src/tools/screencast.js

@@ -30,22 +30,29 @@ export const startScreencast = definePageTool(args => ({
             .describe(`Output file path (${supportedExtensions.join(',')} are supported). Uses mkdtemp to generate a unique path if not provided.`),
     },
     blockedByDialog: false,
+    verifyFilesSchema: ['filePath'],
     handler: async (request, response, context) => {
-        await context.validatePath(request.params.filePath);
         if (context.getScreenRecorder() !== null) {
             response.appendResponseLine('Error: a screencast recording is already in progress. Use screencast_stop to stop it before starting a new one.');
             return;
         }
-        const filePath = request.params.filePath ?? (await generateTempFilePath());
-        let enforcedExtension = '.mp4';
-        let format = 'mp4';
-        for (const supportedExtension of supportedExtensions) {
-            if (filePath.endsWith(supportedExtension)) {
-                enforcedExtension = supportedExtension;
-                format = supportedExtension.substring(1);
-                break;
-            }
+        const requestedFilePath = request.params.filePath;
+        const filePath = requestedFilePath ?? (await generateTempFilePath());
+        // Match the extension case-insensitively so e.g. `.WEBM` is recognized as
+        // WebM. An explicitly requested but unsupported extension is rejected
+        // rather than being silently rewritten to `.mp4` (which would change both
+        // the format and the output path from what was requested). A missing
+        // extension falls back to `.mp4`. The matched extension is normalized to
+        // lower case.
+        const requestedExtension = path.extname(filePath);
+        const matchedExtension = supportedExtensions.find(supportedExtension => supportedExtension === requestedExtension.toLowerCase());
+        if (!matchedExtension && requestedExtension !== '') {
+            throw new Error(`Unsupported screencast file extension "${requestedExtension}". ` +
+                `Supported formats: ${supportedExtensions.join(', ')} (case-insensitive).`);
         }
+        const enforcedExtension = matchedExtension ?? '.mp4';
+        const format = (matchedExtension?.substring(1) ??
+            'mp4');
         const resolvedPath = ensureExtension(path.resolve(filePath), enforcedExtension);
         const page = request.page;
         let recorder;
@@ -57,6 +64,19 @@ export const startScreencast = definePageTool(args => ({
             });
         }
         catch (err) {
+            // If we generated a temporary directory for this recording, remove it so
+            // a failed start (e.g. ffmpeg missing) does not leak an empty directory.
+            if (requestedFilePath === undefined) {
+                try {
+                    await fs.rm(path.dirname(resolvedPath), {
+                        recursive: true,
+                        force: true,
+                    });
+                }
+                catch {
+                    // no-op
+                }
+            }
             const message = err instanceof Error ? err.message : String(err);
             if (message.includes('ENOENT') && message.includes('ffmpeg')) {
                 throw new Error('ffmpeg is required for screencast recording but was not found. ' +
@@ -78,9 +98,11 @@ export const stopScreencast = definePageTool({
     },
     schema: {},
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (_request, response, context) => {
         const data = context.getScreenRecorder();
         if (!data) {
+            response.appendResponseLine('Error: no active screencast recording to stop.');
             return;
         }
         try {

package/build/src/tools/screenshot.js

@@ -6,82 +6,164 @@
 import { zod } from '../third_party/index.js';
 import { ToolCategory } from './categories.js';
 import { definePageTool } from './ToolDefinition.js';
-export const screenshot = definePageTool({
-    name: 'take_screenshot',
-    description: `Take a screenshot of the page or element.`,
-    annotations: {
-        category: ToolCategory.DEBUGGING,
-        // Not read-only due to filePath param.
-        readOnlyHint: false,
-    },
-    schema: {
-        format: zod
-            .enum(['png', 'jpeg', 'webp'])
-            .default('png')
-            .describe('Type of format to save the screenshot as. Default is "png"'),
-        quality: zod
-            .number()
-            .min(0)
-            .max(100)
-            .optional()
-            .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
-        uid: zod
-            .string()
-            .optional()
-            .describe('The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.'),
-        fullPage: zod
-            .boolean()
-            .optional()
-            .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
-        filePath: zod
-            .string()
-            .optional()
-            .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
-    },
-    blockedByDialog: true,
-    handler: async (request, response, context) => {
-        await context.validatePath(request.params.filePath);
-        if (request.params.uid && request.params.fullPage) {
-            throw new Error('Providing both "uid" and "fullPage" is not allowed.');
+async function getSourceBox(page, element, fullPage) {
+    if (element) {
+        const box = await element.boundingBox();
+        return box ?? undefined;
+    }
+    if (fullPage) {
+        const dims = await page.evaluate(() => ({
+            width: Math.max(document.documentElement.scrollWidth, document.body?.scrollWidth ?? 0),
+            height: Math.max(document.documentElement.scrollHeight, document.body?.scrollHeight ?? 0),
+        }));
+        if (dims.width <= 0 || dims.height <= 0) {
+            return undefined;
         }
-        let pageOrHandle;
-        if (request.params.uid) {
-            pageOrHandle = await request.page.getElementByUid(request.params.uid);
-        }
-        else {
-            pageOrHandle = request.page.pptrPage;
-        }
-        const format = request.params.format;
-        const quality = format === 'png' ? undefined : request.params.quality;
-        const screenshot = await pageOrHandle.screenshot({
-            type: format,
-            fullPage: request.params.fullPage,
-            quality,
-            optimizeForSpeed: true, // Bonus: optimize encoding for speed
-        });
-        if (request.params.uid) {
-            response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
-        }
-        else if (request.params.fullPage) {
-            response.appendResponseLine('Took a screenshot of the full current page.');
-        }
-        else {
-            response.appendResponseLine("Took a screenshot of the current page's viewport.");
-        }
-        if (request.params.filePath) {
-            const result = await context.saveFile(screenshot, request.params.filePath, `.${format}`);
-            response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
-        }
-        else if (screenshot.length >= 2_000_000) {
-            const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot.${request.params.format}`);
-            response.appendResponseLine(`Saved screenshot to ${filepath}.`);
-        }
-        else {
-            response.attachImage({
-                mimeType: `image/${request.params.format}`,
-                data: Buffer.from(screenshot).toString('base64'),
-            });
-        }
-    },
+        return { x: 0, y: 0, width: dims.width, height: dims.height };
+    }
+    const viewport = page.viewport();
+    if (!viewport) {
+        return undefined;
+    }
+    return { x: 0, y: 0, width: viewport.width, height: viewport.height };
+}
+function computeDownscaleClip(box, maxWidth, maxHeight) {
+    const widthScale = maxWidth !== undefined ? Math.min(1, maxWidth / box.width) : 1;
+    const heightScale = maxHeight !== undefined ? Math.min(1, maxHeight / box.height) : 1;
+    const scale = Math.min(widthScale, heightScale);
+    if (scale >= 1) {
+        return undefined;
+    }
+    // Skip degenerate sub-pixel results.
+    if (Math.round(box.width * scale) < 1 || Math.round(box.height * scale) < 1) {
+        return undefined;
+    }
+    return {
+        x: box.x,
+        y: box.y,
+        width: box.width,
+        height: box.height,
+        scale,
+    };
+}
+export const screenshot = definePageTool(args => {
+    const { screenshotFormat, screenshotQuality, screenshotMaxWidth, screenshotMaxHeight, } = args ?? {};
+    const defaultFormat = screenshotFormat ?? 'png';
+    return {
+        name: 'take_screenshot',
+        description: `Take a screenshot of the page or element.`,
+        annotations: {
+            category: ToolCategory.DEBUGGING,
+            // Not read-only due to filePath param.
+            readOnlyHint: false,
+        },
+        schema: {
+            format: zod
+                .enum(['png', 'jpeg', 'webp'])
+                .default(defaultFormat)
+                .describe(`Type of format to save the screenshot as. Default is "${defaultFormat}"`),
+            quality: zod
+                .number()
+                .min(0)
+                .max(100)
+                .optional()
+                .describe('Compression quality for JPEG and WebP formats (0-100). Higher values mean better quality but larger file sizes. Ignored for PNG format.'),
+            uid: zod
+                .string()
+                .optional()
+                .describe('The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.'),
+            fullPage: zod
+                .boolean()
+                .optional()
+                .describe('If set to true takes a screenshot of the full page instead of the currently visible viewport. Incompatible with uid.'),
+            filePath: zod
+                .string()
+                .optional()
+                .describe('The absolute path, or a path relative to the current working directory, to save the screenshot to instead of attaching it to the response.'),
+        },
+        blockedByDialog: true,
+        verifyFilesSchema: ['filePath'],
+        handler: async (request, response, context) => {
+            if (request.params.uid && request.params.fullPage) {
+                throw new Error('Providing both "uid" and "fullPage" is not allowed.');
+            }
+            const page = request.page.pptrPage;
+            const element = request.params.uid
+                ? await request.page.getElementByUid(request.params.uid)
+                : undefined;
+            const format = request.params.format;
+            const quality = format === 'png'
+                ? undefined
+                : (request.params.quality ?? screenshotQuality);
+            const fullPage = request.params.fullPage ?? false;
+            // Compute a downscale clip when --screenshot-max-width or
+            // --screenshot-max-height is set and the source exceeds either bound.
+            // The smaller scale factor wins so both bounds are respected while
+            // preserving aspect ratio.
+            let clip;
+            if (screenshotMaxWidth !== undefined ||
+                screenshotMaxHeight !== undefined) {
+                const box = await getSourceBox(page, element, fullPage);
+                if (box) {
+                    clip = computeDownscaleClip(box, screenshotMaxWidth, screenshotMaxHeight);
+                }
+            }
+            let screenshot;
+            if (clip) {
+                // page.screenshot with clip lets the CDP scale param downscale the
+                // capture for viewport, full-page and element shots alike. We rely on
+                // Puppeteer's default of captureBeyondViewport=true when a clip is
+                // present so element/full-page captures below the fold still work.
+                screenshot = await page.screenshot({
+                    type: format,
+                    quality,
+                    optimizeForSpeed: true,
+                    clip,
+                });
+            }
+            else if (element) {
+                screenshot = await element.screenshot({
+                    type: format,
+                    quality,
+                    optimizeForSpeed: true,
+                });
+            }
+            else {
+                screenshot = await page.screenshot({
+                    type: format,
+                    fullPage,
+                    quality,
+                    optimizeForSpeed: true,
+                });
+            }
+            if (request.params.uid) {
+                response.appendResponseLine(`Took a screenshot of node with uid "${request.params.uid}".`);
+            }
+            else if (fullPage) {
+                response.appendResponseLine('Took a screenshot of the full current page.');
+            }
+            else {
+                response.appendResponseLine("Took a screenshot of the current page's viewport.");
+            }
+            // Narrow `format` at the point of use: in the factory form of
+            // definePageTool TS widens the Schema generic, which loses the literal
+            // union from zod.enum on request.params.format.
+            const extension = format === 'jpeg' ? '.jpeg' : format === 'webp' ? '.webp' : '.png';
+            if (request.params.filePath) {
+                const result = await context.saveFile(screenshot, request.params.filePath, extension);
+                response.appendResponseLine(`Saved screenshot to ${result.filename}.`);
+            }
+            else if (screenshot.length >= 2_000_000) {
+                const { filepath } = await context.saveTemporaryFile(screenshot, `screenshot${extension}`);
+                response.appendResponseLine(`Saved screenshot to ${filepath}.`);
+            }
+            else {
+                response.attachImage({
+                    mimeType: `image/${format}`,
+                    data: Buffer.from(screenshot).toString('base64'),
+                });
+            }
+        },
+    };
 });
 //# sourceMappingURL=screenshot.js.map

package/build/src/tools/script.js

@@ -51,9 +51,9 @@ Example with arguments: \`(el) => {
                 : {}),
         },
         blockedByDialog: true,
+        verifyFilesSchema: ['filePath'],
         handler: async (request, response, context) => {
             const { serviceWorkerId, args: uidArgs, function: fnString, pageId, dialogAction, filePath, } = request.params;
-            await context.validatePath(filePath);
             if (cliArgs?.categoryExtensions && serviceWorkerId) {
                 if (uidArgs && uidArgs.length > 0) {
                     throw new Error('args (element uids) cannot be used when evaluating in a service worker.');

package/build/src/tools/slim/tools.js

@@ -16,6 +16,7 @@ export const screenshot = definePageTool({
     },
     schema: {},
     blockedByDialog: true,
+    verifyFilesSchema: [],
     handler: async (request, response, context) => {
         const page = request.page;
         const screenshot = await page.pptrPage.screenshot({
@@ -37,6 +38,7 @@ export const navigate = definePageTool({
         url: zod.string().describe('URL to navigate to'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response) => {
         const page = request.page;
         const options = {
@@ -71,6 +73,7 @@ export const evaluate = definePageTool({
         script: zod.string().describe(`JS script to run on the page`),
     },
     blockedByDialog: true,
+    verifyFilesSchema: [],
     handler: async (request, response) => {
         const page = request.page;
         try {

package/build/src/tools/snapshot.js

@@ -27,8 +27,8 @@ in the DevTools Elements panel (if any).`,
             .describe('The absolute path, or a path relative to the current working directory, to save the snapshot to instead of attaching it to the response.'),
     },
     blockedByDialog: true,
-    handler: async (request, response, context) => {
-        await context.validatePath(request.params.filePath);
+    verifyFilesSchema: ['filePath'],
+    handler: async (request, response) => {
         response.includeSnapshot({
             verbose: request.params.verbose ?? false,
             filePath: request.params.filePath,
@@ -50,6 +50,7 @@ export const waitFor = definePageTool({
         ...timeoutSchema,
     },
     blockedByDialog: true,
+    verifyFilesSchema: [],
     handler: async (request, response, context) => {
         const page = request.page;
         await context.waitForTextOnPage(request.params.text, request.params.timeout, page.pptrPage);

package/build/src/tools/thirdPartyDeveloper.js

@@ -21,6 +21,7 @@ export const listThirdPartyDeveloperTools = definePageTool({
     },
     schema: {},
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (_request, response, _context) => {
         response.setListThirdPartyDeveloperTools();
     },
@@ -40,6 +41,7 @@ export const executeThirdPartyDeveloperTool = definePageTool({
             .describe('The JSON-stringified parameters to pass to the tool'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response) => {
         const toolName = request.params.toolName;
         let params = {};
@@ -58,8 +60,16 @@ export const executeThirdPartyDeveloperTool = definePageTool({
                 throw new Error(`Failed to parse params as JSON: ${errorMessage}`);
             }
         }
-        const toolGroup = request.page.getThirdPartyDeveloperTools();
-        const tool = toolGroup?.tools.find(t => t.name === toolName);
+        const toolGroups = request.page.getThirdPartyDeveloperTools();
+        let tool;
+        if (toolGroups) {
+            for (const group of toolGroups) {
+                tool = group.tools?.find(t => t.name === toolName);
+                if (tool) {
+                    break;
+                }
+            }
+        }
         if (!tool) {
             throw new Error(`Tool ${toolName} not found`);
         }

package/build/src/tools/webmcp.js

@@ -15,6 +15,7 @@ export const listWebMcpTools = definePageTool({
     },
     schema: {},
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (_request, response, _context) => {
         response.setListWebMcpTools();
     },
@@ -34,6 +35,7 @@ export const executeWebMcpTool = definePageTool({
             .describe('The JSON-stringified parameters to pass to the WebMCP tool'),
     },
     blockedByDialog: false,
+    verifyFilesSchema: [],
     handler: async (request, response) => {
         const toolName = request.params.toolName;
         let input = {};

package/build/src/trace-processing/parse.js

@@ -40,7 +40,7 @@ export async function parseRawTraceBuffer(buffer, metadata) {
     }
     catch (e) {
         const errorText = e instanceof Error ? e.message : JSON.stringify(e);
-        logger(`Unexpected error parsing trace: ${errorText}`);
+        logger?.(`Unexpected error parsing trace: ${errorText}`);
         return {
             error: errorText,
         };
@@ -51,9 +51,9 @@ const extraFormatDescriptions = `Information on performance traces may contain m
 ${DevTools.PerformanceTraceFormatter.callFrameDataFormatDescription}
 
 ${DevTools.PerformanceTraceFormatter.networkDataFormatDescription}`;
-export function getTraceSummary(result) {
+export function getTraceSummary(result, deviceScope) {
     const focus = DevTools.AgentFocus.fromParsedTrace(result.parsedTrace);
-    const formatter = new DevTools.PerformanceTraceFormatter(focus);
+    const formatter = new DevTools.PerformanceTraceFormatter(focus, deviceScope);
     const summaryText = formatter.formatTraceSummary();
     return `## Summary of Performance trace findings:
 ${summaryText}
@@ -61,7 +61,7 @@ ${summaryText}
 ## Details on call tree & network request formats:
 ${extraFormatDescriptions}`;
 }
-export function getInsightOutput(result, insightSetId, insightName) {
+export function getInsightOutput(result, insightSetId, insightName, deviceScope) {
     if (!result.insights) {
         return {
             error: 'No Performance insights are available for this trace.',
@@ -79,7 +79,7 @@ export function getInsightOutput(result, insightSetId, insightName) {
             error: `No Insight with the name ${insightName} found. Double check the name you provided is accurate and try again.`,
         };
     }
-    const formatter = new DevTools.PerformanceInsightFormatter(DevTools.AgentFocus.fromParsedTrace(result.parsedTrace), matchingInsight);
+    const formatter = new DevTools.PerformanceInsightFormatter(DevTools.AgentFocus.fromParsedTrace(result.parsedTrace), matchingInsight, deviceScope);
     return { output: formatter.formatInsight() };
 }
 //# sourceMappingURL=parse.js.map

package/build/src/version.js

@@ -5,6 +5,6 @@
  */
 // If moved update release-please config
 // x-release-please-start-version
-export const VERSION = '1.1.1';
+export const VERSION = '1.3.0';
 // x-release-please-end
 //# sourceMappingURL=version.js.map