chrome-devtools-mcp 0.20.3 → 0.22.0

package/build/src/bin/chrome-devtools.js

@@ -4,14 +4,17 @@
  * Copyright 2026 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+process.title = 'chrome-devtools';
 import process from 'node:process';
 import { startDaemon, stopDaemon, sendCommand, handleResponse, } from '../daemon/client.js';
 import { isDaemonRunning, serializeArgs } from '../daemon/utils.js';
 import { logDisclaimers } from '../index.js';
 import { hideBin, yargs } from '../third_party/index.js';
+import { checkForUpdates } from '../utils/check-for-updates.js';
 import { VERSION } from '../version.js';
 import { commands } from './chrome-devtools-cli-options.js';
 import { cliOptions, parseArguments } from './chrome-devtools-mcp-cli-options.js';
+await checkForUpdates('Run `npm install -g chrome-devtools-mcp@latest` and `chrome-devtools start` to update and restart the daemon.');
 async function start(args) {
     const combinedArgs = [...args, ...defaultArgs];
     await startDaemon(combinedArgs);
@@ -26,9 +29,10 @@ delete startCliOptions.autoConnect;
 // Missing CLI serialization.
 delete startCliOptions.viewport;
 // CLI is generated based on the default tool definitions. To enable conditional
-// tools, they needs to be enabled during CLI generation.
+// tools, they need to be enabled during CLI generation.
 delete startCliOptions.experimentalPageIdRouting;
 delete startCliOptions.experimentalVision;
+delete startCliOptions.experimentalWebmcp;
 delete startCliOptions.experimentalInteropTools;
 delete startCliOptions.experimentalScreencast;
 delete startCliOptions.categoryEmulation;
@@ -42,9 +46,11 @@ if (!('default' in cliOptions.headless)) {
     throw new Error('headless cli option unexpectedly does not have a default');
 }
 if ('default' in cliOptions.isolated) {
-    throw new Error('headless cli option unexpectedly does not have a default');
+    throw new Error('isolated cli option unexpectedly has a default');
 }
 startCliOptions.headless.default = true;
+startCliOptions.isolated.description =
+    'If specified, creates a temporary user-data-dir that is automatically cleaned up after the browser is closed. Defaults to true unless userDataDir is provided.';
 const y = yargs(hideBin(process.argv))
     .scriptName('chrome-devtools')
     .showHelpOnFail(true)
@@ -63,7 +69,7 @@ y.command('start', 'Start or restart chrome-devtools-mcp', y => y
         await stopDaemon();
     }
     // Defaults but we do not want to affect the yargs conflict resolution.
-    if (argv.isolated === undefined) {
+    if (argv.isolated === undefined && argv.userDataDir === undefined) {
         argv.isolated = true;
     }
     if (argv.headless === undefined) {

package/build/src/bin/cliDefinitions.js

@@ -84,7 +84,7 @@ export const commands = {
             geolocation: {
                 name: 'geolocation',
                 type: 'string',
-                description: 'Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit clear the geolocation override.',
+                description: 'Geolocation (`<latitude>x<longitude>`) to emulate. Latitude between -90 and 90. Longitude between -180 and 180. Omit to clear the geolocation override.',
                 required: false,
             },
             userAgent: {
@@ -124,10 +124,16 @@ export const commands = {
                 description: 'An optional list of arguments to pass to the function.',
                 required: false,
             },
+            dialogAction: {
+                name: 'dialogAction',
+                type: 'string',
+                description: 'Handle dialogs while execution. "accept", "dismiss", or string for response of window.prompt. Defaults to accept.',
+                required: false,
+            },
         },
     },
     fill: {
-        description: 'Type text into a input, text area or select an option from a <select> element.',
+        description: 'Type text into an input, text area or select an option from a <select> element.',
         category: 'Input automation',
         args: {
             uid: {
@@ -175,13 +181,13 @@ export const commands = {
             requestFilePath: {
                 name: 'requestFilePath',
                 type: 'string',
-                description: 'The absolute or relative path to save the request body to. If omitted, the body is returned inline.',
+                description: 'The absolute or relative path to a .network-request file to save the request body to. If omitted, the body is returned inline.',
                 required: false,
             },
             responseFilePath: {
                 name: 'responseFilePath',
                 type: 'string',
-                description: 'The absolute or relative path to save the response body to. If omitted, the body is returned inline.',
+                description: 'The absolute or relative path to a .network-response file to save the response body to. If omitted, the body is returned inline.',
                 required: false,
             },
         },
@@ -258,7 +264,7 @@ export const commands = {
             pageSize: {
                 name: 'pageSize',
                 type: 'integer',
-                description: 'Maximum number of messages to return. When omitted, returns all requests.',
+                description: 'Maximum number of messages to return. When omitted, returns all messages.',
                 required: false,
             },
             pageIdx: {
@@ -314,7 +320,7 @@ export const commands = {
         },
     },
     list_pages: {
-        description: 'Get a list of pages  open in the browser.',
+        description: 'Get a list of pages open in the browser.',
         category: 'Navigation automation',
         args: {},
     },
@@ -503,8 +509,8 @@ export const commands = {
         },
     },
     take_memory_snapshot: {
-        description: 'Capture a memory heapsnapshot of the currently selected page to memory leak debugging',
-        category: 'Performance',
+        description: 'Capture a heap snapshot of the currently selected page. Use to analyze the memory distribution of JavaScript objects and debug memory leaks.',
+        category: 'Memory',
         args: {
             filePath: {
                 name: 'filePath',
@@ -535,7 +541,7 @@ export const commands = {
             uid: {
                 name: 'uid',
                 type: 'string',
-                description: 'The uid of an element on the page from the page content snapshot. If omitted takes a pages screenshot.',
+                description: 'The uid of an element on the page from the page content snapshot. If omitted, takes a page screenshot.',
                 required: false,
             },
             fullPage: {

package/build/src/daemon/client.js

@@ -135,7 +135,7 @@ export async function handleResponse(response, format) {
                 case 'image/jpeg':
                     extension = '.jpeg';
                     break;
-                case 'webp':
+                case 'image/webp':
                     extension = '.webp';
                     break;
             }

package/build/src/daemon/daemon.js

@@ -11,7 +11,7 @@ import process from 'node:process';
 import { logger } from '../logger.js';
 import { Client, PipeTransport, StdioClientTransport, } from '../third_party/index.js';
 import { VERSION } from '../version.js';
-import { getDaemonPid, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
+import { DAEMON_CLIENT_NAME, getDaemonPid, getPidFilePath, getSocketPath, INDEX_SCRIPT_PATH, IS_WINDOWS, isDaemonRunning, } from './utils.js';
 const pid = getDaemonPid();
 if (isDaemonRunning(pid)) {
     logger('Another daemon process is running.');
@@ -32,17 +32,13 @@ let server = null;
 async function setupMCPClient() {
     console.log('Setting up MCP client connection...');
     // Create stdio transport for chrome-devtools-mcp
-    // Workaround for https://github.com/modelcontextprotocol/typescript-sdk/blob/v1.x/src/client/stdio.ts#L128
-    // which causes the console window to show on Windows.
-    // @ts-expect-error no types for type.
-    process.type = 'mcp-client';
     mcpTransport = new StdioClientTransport({
         command: process.execPath,
         args: [INDEX_SCRIPT_PATH, ...mcpServerArgs],
         env: process.env,
     });
     mcpClient = new Client({
-        name: 'chrome-devtools-cli-daemon',
+        name: DAEMON_CLIENT_NAME,
         version: VERSION,
     }, {
         capabilities: {},

package/build/src/daemon/utils.js

@@ -11,6 +11,7 @@ import { logger } from '../logger.js';
 export const DAEMON_SCRIPT_PATH = path.join(import.meta.dirname, 'daemon.js');
 export const INDEX_SCRIPT_PATH = path.join(import.meta.dirname, '..', 'bin', 'chrome-devtools-mcp.js');
 const APP_NAME = 'chrome-devtools-mcp';
+export const DAEMON_CLIENT_NAME = 'chrome-devtools-cli-daemon';
 // Using these paths due to strict limits on the POSIX socket path length.
 export function getSocketPath() {
     const uid = os.userInfo().uid;

package/build/src/formatters/HeapSnapshotFormatter.js

@@ -0,0 +1,38 @@
+/**
+ * @license
+ * Copyright 2026 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+import { stableIdSymbol } from '../utils/id.js';
+export class HeapSnapshotFormatter {
+    #aggregates;
+    constructor(aggregates) {
+        this.#aggregates = aggregates;
+    }
+    #getSortedAggregates() {
+        return Object.values(this.#aggregates).sort((a, b) => b.self - a.self);
+    }
+    toString() {
+        const sorted = this.#getSortedAggregates();
+        const lines = [];
+        lines.push('uid,className,count,selfSize,maxRetainedSize');
+        for (const info of sorted) {
+            const uid = info[stableIdSymbol] ?? '';
+            lines.push(`${uid},"${info.name}",${info.count},${info.self},${info.maxRet}`);
+        }
+        return lines.join('\n');
+    }
+    toJSON() {
+        const sorted = this.#getSortedAggregates();
+        return sorted.map(info => ({
+            uid: info[stableIdSymbol],
+            className: info.name,
+            count: info.count,
+            selfSize: info.self,
+            retainedSize: info.maxRet,
+        }));
+    }
+    static sort(aggregates) {
+        return Object.entries(aggregates).sort((a, b) => b[1].self - a[1].self);
+    }
+}

package/build/src/formatters/NetworkFormatter.js

@@ -4,6 +4,7 @@
  * SPDX-License-Identifier: Apache-2.0
  * */
 import { isUtf8 } from 'node:buffer';
+import { DevTools, } from '../third_party/index.js';
 const BODY_CONTEXT_SIZE_LIMIT = 10000;
 export class NetworkFormatter {
     #request;
@@ -40,8 +41,8 @@ export class NetworkFormatter {
                     throw new Error('saveFile is not provided');
                 }
                 if (data) {
-                    await this.#options.saveFile(Buffer.from(data), this.#options.requestFilePath);
-                    this.#requestBodyFilePath = this.#options.requestFilePath;
+                    const result = await this.#options.saveFile(Buffer.from(data), this.#options.requestFilePath, '.network-request');
+                    this.#requestBodyFilePath = result.filename;
                 }
                 else {
                     this.#requestBody = requestBodyNotAvailableMessage;
@@ -66,8 +67,8 @@ export class NetworkFormatter {
                     if (!this.#options.saveFile) {
                         throw new Error('saveFile is not provided');
                     }
-                    await this.#options.saveFile(buffer, this.#options.responseFilePath);
-                    this.#responseBodyFilePath = this.#options.responseFilePath;
+                    const result = await this.#options.saveFile(buffer, this.#options.responseFilePath, '.network-response');
+                    this.#responseBodyFilePath = result.filename;
                 }
                 catch {
                     // Flatten error handling for buffer() failure and save failure
@@ -96,6 +97,16 @@ export class NetworkFormatter {
             selectedInDevToolsUI: this.#options.selectedInDevToolsUI,
         };
     }
+    #redactNetworkHeaders(headers) {
+        const headersList = Object.entries(headers).map(item => {
+            return { name: item[0], value: item[1] };
+        });
+        const redacted = DevTools.NetworkRequestFormatter.sanitizeHeaders(headersList);
+        return redacted.reduce((acc, item) => {
+            acc[item.name] = item.value;
+            return acc;
+        }, {});
+    }
     toJSONDetailed() {
         const redirectChain = this.#request.redirectChain();
         const formattedRedirectChain = redirectChain.reverse().map(request => {
@@ -105,15 +116,21 @@ export class NetworkFormatter {
             const formatter = new NetworkFormatter(request, {
                 requestId: id,
                 saveFile: this.#options.saveFile,
+                redactNetworkHeaders: this.#options.redactNetworkHeaders,
             });
             return formatter.toJSON();
         });
+        const responseHeaders = this.#request.response()?.headers();
         return {
             ...this.toJSON(),
-            requestHeaders: this.#request.headers(),
+            requestHeaders: this.#options.redactNetworkHeaders
+                ? this.#redactNetworkHeaders(this.#request.headers())
+                : this.#request.headers(),
             requestBody: this.#requestBody,
             requestBodyFilePath: this.#requestBodyFilePath,
-            responseHeaders: this.#request.response()?.headers(),
+            responseHeaders: this.#options.redactNetworkHeaders && responseHeaders
+                ? this.#redactNetworkHeaders(responseHeaders)
+                : this.#request.response()?.headers(),
             responseBody: this.#responseBody,
             responseBodyFilePath: this.#responseBodyFilePath,
             failure: this.#request.failure()?.errorText,
@@ -210,7 +227,7 @@ function converNetworkRequestDetailedToStringDetailed(data) {
         response.push(`### Redirect chain`);
         let indent = 0;
         for (const request of redirectChain.reverse()) {
-            response.push(`${'  '.repeat(indent)}${convertNetworkRequestConciseToString(request)})}`);
+            response.push(`${'  '.repeat(indent)}${convertNetworkRequestConciseToString(request)}`);
             indent++;
         }
     }

package/build/src/index.js

@@ -36,6 +36,12 @@ export async function createMcpServer(serverArgs, options) {
     server.server.setRequestHandler(SetLevelRequestSchema, () => {
         return {};
     });
+    server.server.oninitialized = () => {
+        const clientName = server.server.getClientVersion()?.name;
+        if (clientName) {
+            clearcutLogger?.setClientName(clientName);
+        }
+    };
     let context;
     async function getContext() {
         const chromeArgs = (serverArgs.chromeArg ?? []).map(String);
@@ -95,13 +101,21 @@ export async function createMcpServer(serverArgs, options) {
             return;
         }
         if (tool.annotations.category === ToolCategory.EXTENSIONS &&
-            !serverArgs.categoryExtensions) {
+            serverArgs.categoryExtensions === false) {
+            return;
+        }
+        if (tool.annotations.category === ToolCategory.IN_PAGE &&
+            !serverArgs.categoryInPageTools) {
             return;
         }
         if (tool.annotations.conditions?.includes('computerVision') &&
             !serverArgs.experimentalVision) {
             return;
         }
+        if (tool.annotations.conditions?.includes('experimentalMemory') &&
+            !serverArgs.experimentalMemory) {
+            return;
+        }
         if (tool.annotations.conditions?.includes('experimentalInteropTools') &&
             !serverArgs.experimentalInteropTools) {
             return;
@@ -110,6 +124,10 @@ export async function createMcpServer(serverArgs, options) {
             !serverArgs.experimentalScreencast) {
             return;
         }
+        if (tool.annotations.conditions?.includes('experimentalWebmcp') &&
+            !serverArgs.experimentalWebmcp) {
+            return;
+        }
         const schema = 'pageScoped' in tool &&
             tool.pageScoped &&
             serverArgs.experimentalPageIdRouting &&
@@ -132,6 +150,7 @@ export async function createMcpServer(serverArgs, options) {
                 const response = serverArgs.slim
                     ? new SlimMcpResponse(serverArgs)
                     : new McpResponse(serverArgs);
+                response.setRedactNetworkHeaders(serverArgs.redactNetworkHeaders);
                 if ('pageScoped' in tool && tool.pageScoped) {
                     const page = serverArgs.experimentalPageIdRouting &&
                         params.pageId &&
@@ -180,6 +199,8 @@ export async function createMcpServer(serverArgs, options) {
             finally {
                 void clearcutLogger?.logToolInvocation({
                     toolName: tool.name,
+                    params,
+                    schema,
                     success,
                     latencyMs: bucketizeLatency(Date.now() - startTime),
                 });

package/build/src/telemetry/ClearcutLogger.js

@@ -4,11 +4,115 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import process from 'node:process';
+import { DAEMON_CLIENT_NAME } from '../daemon/utils.js';
 import { logger } from '../logger.js';
 import { FilePersistence } from './persistence.js';
-import { WatchdogMessageType, OsType } from './types.js';
+import { McpClient, WatchdogMessageType, OsType, } from './types.js';
 import { WatchdogClient } from './WatchdogClient.js';
 const MS_PER_DAY = 24 * 60 * 60 * 1000;
+export const PARAM_BLOCKLIST = new Set(['uid', 'reqid', 'msgid']);
+const SUPPORTED_ZOD_TYPES = [
+    'ZodString',
+    'ZodNumber',
+    'ZodBoolean',
+    'ZodArray',
+    'ZodEnum',
+];
+function isZodType(type) {
+    return SUPPORTED_ZOD_TYPES.includes(type);
+}
+export function getZodType(zodType) {
+    const def = zodType._def;
+    const typeName = def.typeName;
+    if (typeName === 'ZodOptional' ||
+        typeName === 'ZodDefault' ||
+        typeName === 'ZodNullable') {
+        return getZodType(def.innerType);
+    }
+    if (typeName === 'ZodEffects') {
+        return getZodType(def.schema);
+    }
+    if (isZodType(typeName)) {
+        return typeName;
+    }
+    throw new Error(`Unsupported zod type for tool parameter: ${typeName}`);
+}
+export function transformArgName(zodType, name) {
+    const snakeCaseName = name.replace(/[A-Z]/g, letter => `_${letter.toLowerCase()}`);
+    if (zodType === 'ZodString') {
+        return `${snakeCaseName}_length`;
+    }
+    else if (zodType === 'ZodArray') {
+        return `${snakeCaseName}_count`;
+    }
+    else {
+        return snakeCaseName;
+    }
+}
+export function transformArgType(zodType) {
+    if (zodType === 'ZodString' || zodType === 'ZodArray') {
+        return 'number';
+    }
+    switch (zodType) {
+        case 'ZodNumber':
+            return 'number';
+        case 'ZodBoolean':
+            return 'boolean';
+        case 'ZodEnum':
+            return 'enum';
+        default:
+            throw new Error(`Unsupported zod type for tool parameter: ${zodType}`);
+    }
+}
+function transformValue(zodType, value) {
+    if (zodType === 'ZodString') {
+        return value.length;
+    }
+    else if (zodType === 'ZodArray') {
+        return value.length;
+    }
+    else {
+        return value;
+    }
+}
+function hasEquivalentType(zodType, value) {
+    if (zodType === 'ZodString') {
+        return typeof value === 'string';
+    }
+    else if (zodType === 'ZodArray') {
+        return Array.isArray(value);
+    }
+    else if (zodType === 'ZodNumber') {
+        return typeof value === 'number';
+    }
+    else if (zodType === 'ZodBoolean') {
+        return typeof value === 'boolean';
+    }
+    else if (zodType === 'ZodEnum') {
+        return (typeof value === 'string' ||
+            typeof value === 'number' ||
+            typeof value === 'boolean');
+    }
+    else {
+        return false;
+    }
+}
+export function sanitizeParams(params, schema) {
+    const transformed = {};
+    for (const [name, value] of Object.entries(params)) {
+        if (PARAM_BLOCKLIST.has(name)) {
+            continue;
+        }
+        const zodType = getZodType(schema[name]);
+        if (!hasEquivalentType(zodType, value)) {
+            throw new Error(`parameter ${name} has type ${zodType} but value ${value} is not of equivalent type`);
+        }
+        const transformedName = transformArgName(zodType, name);
+        const transformedValue = transformValue(zodType, value);
+        transformed[transformedName] = transformedValue;
+    }
+    return transformed;
+}
 function detectOsType() {
     switch (process.platform) {
         case 'win32':
@@ -24,6 +128,7 @@ function detectOsType() {
 export class ClearcutLogger {
     #persistence;
     #watchdog;
+    #mcpClient;
     constructor(options) {
         this.#persistence = options.persistence ?? new FilePersistence();
         this.#watchdog =
@@ -37,16 +142,48 @@ export class ClearcutLogger {
                     clearcutForceFlushIntervalMs: options.clearcutForceFlushIntervalMs,
                     clearcutIncludePidHeader: options.clearcutIncludePidHeader,
                 });
+        this.#mcpClient = McpClient.MCP_CLIENT_UNSPECIFIED;
+    }
+    setClientName(clientName) {
+        const lowerName = clientName.toLowerCase();
+        if (lowerName.includes('claude')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_CLAUDE_CODE;
+        }
+        else if (lowerName.includes('gemini')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_GEMINI_CLI;
+        }
+        else if (clientName === DAEMON_CLIENT_NAME) {
+            this.#mcpClient = McpClient.MCP_CLIENT_DT_MCP_CLI;
+        }
+        else if (lowerName.includes('openclaw')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_OPENCLAW;
+        }
+        else if (lowerName.includes('codex')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_CODEX;
+        }
+        else if (lowerName.includes('antigravity')) {
+            this.#mcpClient = McpClient.MCP_CLIENT_ANTIGRAVITY;
+        }
+        else {
+            this.#mcpClient = McpClient.MCP_CLIENT_OTHER;
+        }
     }
     async logToolInvocation(args) {
+        const tool_invocation = {
+            tool_name: args.toolName,
+            success: args.success,
+            latency_ms: args.latencyMs,
+        };
+        if (Object.keys(args.params).length > 0) {
+            tool_invocation.tool_params = {
+                [`${args.toolName}_params`]: sanitizeParams(args.params, args.schema),
+            };
+        }
         this.#watchdog.send({
             type: WatchdogMessageType.LOG_EVENT,
             payload: {
-                tool_invocation: {
-                    tool_name: args.toolName,
-                    success: args.success,
-                    latency_ms: args.latencyMs,
-                },
+                mcp_client: this.#mcpClient,
+                tool_invocation: tool_invocation,
             },
         });
     }
@@ -54,6 +191,7 @@ export class ClearcutLogger {
         this.#watchdog.send({
             type: WatchdogMessageType.LOG_EVENT,
             payload: {
+                mcp_client: this.#mcpClient,
                 server_start: {
                     flag_usage: flagUsage,
                 },
@@ -74,6 +212,7 @@ export class ClearcutLogger {
                 this.#watchdog.send({
                     type: WatchdogMessageType.LOG_EVENT,
                     payload: {
+                        mcp_client: this.#mcpClient,
                         daily_active: {
                             days_since_last_active: daysSince,
                         },

package/build/src/telemetry/flagUtils.js

@@ -4,6 +4,14 @@
  * SPDX-License-Identifier: Apache-2.0
  */
 import { toSnakeCase } from '../utils/string.js';
+/**
+ * For enums, log the value as uppercase.
+ * We're going to have an enum for such flags with choices represented
+ * as an `enum` where the keys of the enum will map to the uppercase `choice`.
+ */
+function formatEnumChoice(snakeCaseName, choice) {
+    return `${snakeCaseName}_${choice}`.toUpperCase();
+}
 /**
  * Computes telemetry flag usage from parsed arguments and CLI options.
  *
@@ -14,6 +22,8 @@ import { toSnakeCase } from '../utils/string.js';
  *    - The provided value differs from the default value.
  * - Boolean flags are logged with their literal value.
  * - String flags with defined `choices` (Enums) are logged as their uppercase value.
+ *
+ * IMPORTANT: keep getPossibleFlagMetrics() in sync with this function.
  */
 export function computeFlagUsage(args, options) {
     const usage = {};
@@ -35,11 +45,43 @@ export function computeFlagUsage(args, options) {
             typeof value === 'string' &&
             'choices' in config &&
             config.choices) {
-            // For enums, log the value as uppercase
-            // We're going to have an enum for such flags with choices represented
-            // as an `enum` where the keys of the enum will map to the uppercase `choice`.
-            usage[snakeCaseName] = `${snakeCaseName}_${value}`.toUpperCase();
+            usage[snakeCaseName] = formatEnumChoice(snakeCaseName, value);
         }
     }
     return usage;
 }
+/**
+ * Computes the list of possible flag metrics based on the CLI options.
+ *
+ * IMPORTANT: keep this function in sync with computeFlagUsage().
+ */
+export function getPossibleFlagMetrics(options) {
+    const metrics = [];
+    for (const [flagName, config] of Object.entries(options)) {
+        const snakeCaseName = toSnakeCase(flagName);
+        // _present is always a possible metric
+        metrics.push({
+            name: `${snakeCaseName}_present`,
+            flagType: 'boolean',
+        });
+        if (config.type === 'boolean') {
+            metrics.push({
+                name: snakeCaseName,
+                flagType: 'boolean',
+            });
+        }
+        else if (config.type === 'string' &&
+            'choices' in config &&
+            config.choices) {
+            metrics.push({
+                name: snakeCaseName,
+                flagType: 'enum',
+                choices: [
+                    `${snakeCaseName.toUpperCase()}_UNSPECIFIED`,
+                    ...config.choices.map(choice => formatEnumChoice(snakeCaseName, choice)),
+                ],
+            });
+        }
+    }
+    return metrics;
+}