chrome-devtools-frontend 1.0.1683520 → 1.0.1689415

package/front_end/models/ai_assistance/tools/GetStorageValues.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../../core/common/common.js';
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
+import * as Platform from '../../../core/platform/platform.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import type {FunctionHandlerOptions} from '../agents/AiAgent.js';
 import {areOriginsEquivalent, extractContextOrigin, isOpaqueOrigin} from '../AiOrigins.js';
@@ -45,10 +46,11 @@ export interface GetStorageValuesResult {
 
 export class GetStorageValuesTool implements DataTool<GetStorageValuesArgs, GetStorageValuesResult,
                                                       BaseToolCapability&OriginLockCapability&ServerLoggingCapability> {
-  readonly name = ToolName.GET_STORAGE_VALUES;
-  readonly description = 'Retrieve specific string values from storage partitions for requested keys across origins.';
+  readonly name: ToolName = ToolName.GET_STORAGE_VALUES;
+  readonly description: string =
+      'Retrieve specific string values from storage partitions for requested keys across origins.';
 
-  readonly annotations = [ToolAnnotation.REDACT_FROM_HISTORY];
+  readonly annotations: ToolAnnotation[] = [ToolAnnotation.REDACT_FROM_HISTORY];
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetStorageValuesArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -86,8 +88,19 @@ export class GetStorageValuesTool implements DataTool<GetStorageValuesArgs, GetS
     title: string,
     action: string,
   } {
+    let title: string;
+    switch (args.type) {
+      case 'localStorage':
+        title = lockedString('Reading local storage values');
+        break;
+      case 'sessionStorage':
+        title = lockedString('Reading session storage values');
+        break;
+      default:
+        Platform.TypeScriptUtilities.assertNever(args.type, `Unknown storage type: ${args.type}`);
+    }
     return {
-      title: lockedString('Reading storage values'),
+      title,
       action: `getStorageValues('${args.type}', ${JSON.stringify(args.keys)}, ${JSON.stringify(args.origins)})`,
     };
   }
@@ -97,7 +110,7 @@ export class GetStorageValuesTool implements DataTool<GetStorageValuesArgs, GetS
       context: BaseToolCapability&OriginLockCapability&ServerLoggingCapability,
       options?: FunctionHandlerOptions,
       ): Promise<DataHandlerResult<GetStorageValuesResult>> {
-    context.setLoggingEnabled(false);
+    context.disableLogging();
 
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     const targetManager = SDK.TargetManager.TargetManager.instance();

package/front_end/models/ai_assistance/tools/GetStyles.ts

@@ -26,9 +26,9 @@ export interface GetStylesArgs extends ToolArgs {
 
 export class GetStylesTool implements
     DataTool<GetStylesArgs, unknown, BaseToolCapability&TargetCapability&OriginLockCapability> {
-  readonly name = ToolName.GET_STYLES;
-  readonly description =
-      `Get computed and source styles for one or multiple elements on the inspected page for multiple elements at once by uid.
+  readonly name: ToolName = ToolName.GET_STYLES;
+  readonly description: string =
+      `Retrieves computed and authored CSS styles for one or more elements by their backend node IDs (uids).
 
 **CRITICAL** An element uid is a number, not a selector.
 **CRITICAL** Use selectors to refer to elements in the text output. Do not use uids.

package/front_end/models/ai_assistance/tools/GetTraceEventByKey.ts

@@ -4,13 +4,13 @@
 
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 import {formatEventForAI} from '../data_formatters/PerformanceTraceFormatter.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  type PerformanceTraceCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -25,9 +25,10 @@ export interface GetTraceEventByKeyArgs extends ToolArgs {
   eventKey: string;
 }
 
-export class GetTraceEventByKeyTool implements DataTool<GetTraceEventByKeyArgs, string, BaseToolCapability> {
-  readonly name = ToolName.GET_TRACE_EVENT_BY_KEY;
-  readonly description = 'Get details for a specific trace event by its event key.';
+export class GetTraceEventByKeyTool implements
+    DataTool<GetTraceEventByKeyArgs, string, BaseToolCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_TRACE_EVENT_BY_KEY;
+  readonly description: string = 'Retrieves details for a specific trace event by its event key.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetTraceEventByKeyArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -55,14 +56,14 @@ export class GetTraceEventByKeyTool implements DataTool<GetTraceEventByKeyArgs,
 
   async handler(
       params: GetTraceEventByKeyArgs,
-      capabilities: BaseToolCapability,
+      capabilities: BaseToolCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
-    const focus = conversationContext.getItem();
+    const focus = performanceTraceContext.getItem();
     const event = focus.lookupEvent(params.eventKey);
     if (!event) {
       return {error: `Could not find event with key "${params.eventKey}".`};

package/front_end/models/ai_assistance/tools/GetTraceMainThreadSummary.ts

@@ -4,16 +4,14 @@
 
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import {
-  type MainThreadSectionLabel,
-  PerformanceTraceContext,
-} from '../contexts/PerformanceTraceContext.js';
+import type {MainThreadSectionLabel} from '../contexts/PerformanceTraceContext.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
   MAX_FUNCTION_RESULT_BYTE_LENGTH,
+  type PerformanceTraceCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -29,9 +27,10 @@ export interface GetTraceMainThreadSummaryArgs extends ToolArgs {
 }
 
 export class GetTraceMainThreadSummaryTool implements
-    DataTool<GetTraceMainThreadSummaryArgs, string, BaseToolCapability> {
-  readonly name = ToolName.GET_TRACE_MAIN_THREAD_SUMMARY;
-  readonly description = 'Returns a focused, detailed summary of the main thread for a predefined labeled period.';
+    DataTool<GetTraceMainThreadSummaryArgs, string, BaseToolCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_TRACE_MAIN_THREAD_SUMMARY;
+  readonly description: string =
+      'Retrieves a focused, bottom-up summary of main thread activity for a predefined labeled period (e.g. \'nav-to-lcp\', \'lcp-ttfb\', \'lcp-render-delay\', \'trace-bounds\', or insight names).';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetTraceMainThreadSummaryArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -41,7 +40,7 @@ export class GetTraceMainThreadSummaryTool implements
       label: {
         type: Host.AidaClient.ParametersTypes.STRING,
         description:
-            'The label of the period to investigate (e.g., \'LCPBreakdown\', \'CLSCulprits\', \'nav-to-lcp\').',
+            'The label of the period to investigate (e.g., \'LCPBreakdown\', \'CLSCulprits\', \'nav-to-lcp\', \'lcp-render-delay\', \'trace-bounds\').',
         nullable: false,
       },
     },
@@ -60,20 +59,20 @@ export class GetTraceMainThreadSummaryTool implements
 
   async handler(
       params: GetTraceMainThreadSummaryArgs,
-      capabilities: BaseToolCapability,
+      capabilities: BaseToolCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
-    const focus = conversationContext.getItem();
-    const bounds = conversationContext.getBoundsForLabel(params.label);
+    const focus = performanceTraceContext.getItem();
+    const bounds = performanceTraceContext.getBoundsForLabel(params.label);
     if (!bounds) {
       return {error: `Invalid label: ${params.label}`};
     }
 
-    const formatter = conversationContext.createFormatter();
+    const formatter = performanceTraceContext.createFormatter();
     const summary = await formatter.formatMainThreadTrackSummary(bounds);
     if (summary.length > MAX_FUNCTION_RESULT_BYTE_LENGTH) {
       return {

package/front_end/models/ai_assistance/tools/GetTraceNetworkSummary.ts

@@ -4,13 +4,13 @@
 
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
   MAX_FUNCTION_RESULT_BYTE_LENGTH,
+  type PerformanceTraceCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -26,9 +26,11 @@ export interface GetTraceNetworkSummaryArgs extends ToolArgs {
   max?: number;
 }
 
-export class GetTraceNetworkSummaryTool implements DataTool<GetTraceNetworkSummaryArgs, string, BaseToolCapability> {
-  readonly name = ToolName.GET_TRACE_NETWORK_SUMMARY;
-  readonly description = 'Returns a summary of the network requests for the given bounds.';
+export class GetTraceNetworkSummaryTool implements
+    DataTool<GetTraceNetworkSummaryArgs, string, BaseToolCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.GET_TRACE_NETWORK_SUMMARY;
+  readonly description: string =
+      'Retrieves a summary of network requests recorded in the trace within the given time bounds.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetTraceNetworkSummaryArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -68,20 +70,20 @@ export class GetTraceNetworkSummaryTool implements DataTool<GetTraceNetworkSumma
 
   async handler(
       params: GetTraceNetworkSummaryArgs,
-      capabilities: BaseToolCapability,
+      capabilities: BaseToolCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
-    const focus = conversationContext.getItem();
-    const bounds = conversationContext.createBounds(params.min, params.max);
+    const focus = performanceTraceContext.getItem();
+    const bounds = performanceTraceContext.createBounds(params.min, params.max);
     if (!bounds) {
       return {error: 'Invalid bounds.'};
     }
 
-    const formatter = conversationContext.createFormatter();
+    const formatter = performanceTraceContext.createFormatter();
     const summary = formatter.formatNetworkTrackSummary(bounds);
     if (summary.length > MAX_FUNCTION_RESULT_BYTE_LENGTH) {
       return {

package/front_end/models/ai_assistance/tools/ListCookies.ts

@@ -0,0 +1,93 @@
+// Copyright 2026 The Chromium Authors
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import * as Host from '../../../core/host/host.js';
+import * as i18n from '../../../core/i18n/i18n.js';
+import * as SDK from '../../../core/sdk/sdk.js';
+
+import {getCookiesForOrigin, resolveAllowedTargetOrigins} from './CookieUtils.js';
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type OriginLockCapability,
+  type ServerLoggingCapability,
+  ToolAnnotation,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+const lockedString = i18n.i18n.lockedString;
+
+export interface ListCookiesArgs extends ToolArgs {
+  origins?: string[];
+}
+
+export interface ListCookiesResult {
+  cookieNamesByOrigin: Record<string, {cookies: string[]}|{error: string}>;
+}
+
+export class ListCookiesTool implements
+    DataTool<ListCookiesArgs, ListCookiesResult, BaseToolCapability&OriginLockCapability&ServerLoggingCapability> {
+  readonly name: ToolName = ToolName.LIST_COOKIES;
+  readonly description: string =
+      'Lists all cookie names for requested origins (or the current page origin if omitted), strictly excluding their values.';
+
+  readonly annotations: ToolAnnotation[] = [ToolAnnotation.REDACT_FROM_HISTORY];
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof ListCookiesArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: '',
+    nullable: false,
+    properties: {
+      origins: {
+        type: Host.AidaClient.ParametersTypes.ARRAY,
+        description: 'Optional list of origins to list cookies for. Defaults to the current page origin if omitted.',
+        items: {type: Host.AidaClient.ParametersTypes.STRING, description: 'An origin URL.'},
+        nullable: true,
+      },
+    },
+    required: [],
+  };
+
+  displayInfoFromArgs(args: ListCookiesArgs): {
+    title: string,
+    action: string,
+  } {
+    return {
+      title: lockedString('Reading cookies'),
+      action: `listCookies(${JSON.stringify(args?.origins ?? [])})`,
+    };
+  }
+
+  async handler(
+      args: ListCookiesArgs,
+      context: BaseToolCapability&OriginLockCapability&ServerLoggingCapability,
+      ): Promise<DataHandlerResult<ListCookiesResult>> {
+    context.disableLogging();
+
+    // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
+    const targetManager = SDK.TargetManager.TargetManager.instance();
+    const targetOriginsResult = resolveAllowedTargetOrigins(args?.origins, context, targetManager);
+    if ('error' in targetOriginsResult) {
+      return {error: targetOriginsResult.error};
+    }
+    const {targetOrigins, primaryPageTarget} = targetOriginsResult;
+
+    const cookieNamesByOrigin: ListCookiesResult['cookieNamesByOrigin'] = {};
+
+    await Promise.all(targetOrigins.map(async origin => {
+      const result = await getCookiesForOrigin(origin, targetManager, primaryPageTarget);
+      if ('error' in result) {
+        cookieNamesByOrigin[origin] = {error: result.error};
+        return;
+      }
+
+      const uniqueNames = Array.from(new Set(result.cookies.map(c => c.name())));
+      cookieNamesByOrigin[origin] = {cookies: uniqueNames};
+    }));
+
+    return {result: {cookieNamesByOrigin}};
+  }
+}

package/front_end/models/ai_assistance/tools/ListNetworkRequests.ts

@@ -38,8 +38,9 @@ interface NetworkRequestSummary {
  */
 export class ListNetworkRequestsTool implements
     DataTool<Record<string, never>, unknown, BaseToolCapability&OriginLockCapability> {
-  readonly name = ToolName.LIST_NETWORK_REQUESTS;
-  readonly description = 'Gives a list of network requests including URL, status code, and duration.';
+  readonly name: ToolName = ToolName.LIST_NETWORK_REQUESTS;
+  readonly description: string =
+      'Lists recorded network requests for the active origin, including request ID, URL, HTTP status code, duration, and transfer size.';
 
   readonly #networkLog?: Logs.NetworkLog.NetworkLog;
 
@@ -112,11 +113,19 @@ export class ListNetworkRequestsTool implements
     }
 
     if (requests.length === 0) {
+      if (hasCrossOriginRequest) {
+        return {
+          error: `No requests showing with origin ${origin}. Tell the user to start a new chat`,
+        };
+      }
       return {
-        // If there were requests but they were filtered out due to the origin lock,
-        // we ask the user to start a new chat so they can select a request from the other origin.
-        error: hasCrossOriginRequest ? `No requests showing with origin ${origin}. Tell the user to start a new chat` :
-                                       'No requests recorded by DevTools',
+        result: JSON.stringify([]),
+        widgets: [{
+          name: 'NETWORK_REQUESTS_LIST',
+          data: {
+            requests: [],
+          },
+        }],
       };
     }
 

package/front_end/models/ai_assistance/tools/ListPageOrigins.ts

@@ -20,9 +20,9 @@ const lockedString = i18n.i18n.lockedString;
 
 export class ListPageOriginsTool implements
     DataTool<Record<string, never>, {origins: string[]}, BaseToolCapability&OriginLockCapability> {
-  readonly name = ToolName.LIST_PAGE_ORIGINS;
-  readonly description =
-      'Lists all active, non-empty frame origins loaded by the page. Use this first when generic category context is active to discover all page origins, then pass them to listCookies or listStorageKeys, unless the user\'s explicit request hints at focusing only on the primary page.';
+  readonly name: ToolName = ToolName.LIST_PAGE_ORIGINS;
+  readonly description: string =
+      'Lists all active, non-empty frame origins loaded by the page. Call this first to discover all page origins before calling listCookies or listStorageKeys, unless the user\'s explicit request focuses only on the primary page.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<never> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,

package/front_end/models/ai_assistance/tools/ListSources.ts

@@ -33,11 +33,13 @@ interface SourceSummary {
  */
 export class ListSourcesTool implements
     DataTool<Record<string, never>, {files: SourceSummary[]}, BaseToolCapability&OriginLockCapability> {
-  readonly name = ToolName.LIST_SOURCES;
-  readonly description = 'Lists all source files in the workspace with their name and a unique ID.';
+  readonly name: ToolName = ToolName.LIST_SOURCES;
+  readonly description: string =
+      'Lists deployed and authored source files in the workspace (including source-mapped files) with their display name and unique numeric ID.';
 
   static lastSourceId = 0;
-  static uiSourceCodeId = new WeakMap<Workspace.UISourceCode.UISourceCode, number>();
+  static uiSourceCodeId: WeakMap<Workspace.UISourceCode.UISourceCode, number> =
+      new WeakMap<Workspace.UISourceCode.UISourceCode, number>();
 
   static reset(): void {
     ListSourcesTool.lastSourceId = 0;

package/front_end/models/ai_assistance/tools/ListStorageKeys.ts

@@ -5,6 +5,7 @@
 import * as Common from '../../../core/common/common.js';
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
+import * as Platform from '../../../core/platform/platform.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import {areOriginsEquivalent, extractContextOrigin, isOpaqueOrigin} from '../AiOrigins.js';
 
@@ -39,11 +40,11 @@ export interface ListStorageKeysResult {
 
 export class ListStorageKeysTool implements DataTool<ListStorageKeysArgs, ListStorageKeysResult,
                                                      BaseToolCapability&OriginLockCapability&ServerLoggingCapability> {
-  readonly name = ToolName.LIST_STORAGE_KEYS;
-  readonly description =
+  readonly name: ToolName = ToolName.LIST_STORAGE_KEYS;
+  readonly description: string =
       'Lists all keys for a given storage type for requested origins. Returns keys grouped by storage partition under their origin.';
 
-  readonly annotations = [ToolAnnotation.REDACT_FROM_HISTORY];
+  readonly annotations: ToolAnnotation[] = [ToolAnnotation.REDACT_FROM_HISTORY];
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof ListStorageKeysArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -74,8 +75,19 @@ export class ListStorageKeysTool implements DataTool<ListStorageKeysArgs, ListSt
     title: string,
     action: string,
   } {
+    let title: string;
+    switch (args.type) {
+      case 'localStorage':
+        title = lockedString('Reading local storage keys');
+        break;
+      case 'sessionStorage':
+        title = lockedString('Reading session storage keys');
+        break;
+      default:
+        Platform.TypeScriptUtilities.assertNever(args.type, `Unknown storage type: ${args.type}`);
+    }
     return {
-      title: lockedString('Reading storage keys'),
+      title,
       action: `listStorageKeys('${args.type}', ${JSON.stringify(args.origins)})`,
     };
   }
@@ -84,7 +96,7 @@ export class ListStorageKeysTool implements DataTool<ListStorageKeysArgs, ListSt
       args: ListStorageKeysArgs,
       context: BaseToolCapability&OriginLockCapability&ServerLoggingCapability,
       ): Promise<DataHandlerResult<ListStorageKeysResult>> {
-    context.setLoggingEnabled(false);
+    context.disableLogging();
 
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     const targetManager = SDK.TargetManager.TargetManager.instance();

package/front_end/models/ai_assistance/tools/RecordPerformanceTrace.ts

@@ -23,8 +23,9 @@ const lockedString = i18n.i18n.lockedString;
 
 export class RecordPerformanceTraceTool implements
     ContextTool<Record<string, never>, AgentFocus, BaseToolCapability&PerformanceRecordingCapability> {
-  readonly name = ToolName.RECORD_PERFORMANCE_TRACE;
-  readonly description = 'Records a new performance trace to measure, analyze, and debug page performance.';
+  readonly name: ToolName = ToolName.RECORD_PERFORMANCE_TRACE;
+  readonly description: string =
+      'Reloads the page and records a new performance trace to measure, analyze, and debug page performance.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<never> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,

package/front_end/models/ai_assistance/tools/ResolveDevtoolsNodePath.ts

@@ -38,8 +38,9 @@ export interface ResolveDevtoolsNodePathArgs extends ToolArgs {
  */
 export class ResolveDevtoolsNodePathTool implements DataTool<ResolveDevtoolsNodePathArgs, {backendNodeId: number},
                                                              BaseToolCapability&TargetCapability&OriginLockCapability> {
-  readonly name = ToolName.RESOLVE_DEVTOOLS_NODE_PATH;
-  readonly description = 'Resolves a DevTools node path to a backend node ID.';
+  readonly name: ToolName = ToolName.RESOLVE_DEVTOOLS_NODE_PATH;
+  readonly description: string =
+      'Resolves a DevTools node path (e.g. from a Lighthouse audit snippet) to an element backend node ID for further DOM, style, or accessibility inspection.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof ResolveDevtoolsNodePathArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -53,7 +54,7 @@ export class ResolveDevtoolsNodePathTool implements DataTool<ResolveDevtoolsNode
       },
       path: {
         type: Host.AidaClient.ParametersTypes.STRING,
-        description: 'DevTools node path string.',
+        description: 'DevTools node path string (e.g. "1,HTML,1,BODY,2,DIV").',
         nullable: false,
       },
     },

package/front_end/models/ai_assistance/tools/RunLighthouse.ts

@@ -10,21 +10,21 @@ import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
-  type LighthouseCapability,
+  type LighthouseRecordingCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
 
 export interface RunLighthouseArgs extends ToolArgs {
   explanation: string;
-  category: LHModel.RunTypes.CategoryId;
+  categoryId: LHModel.RunTypes.CategoryId;
   mode?: LHModel.RunTypes.RunMode;
 }
 
 export class RunLighthouseTool implements
-    DataTool<RunLighthouseArgs, {audits: string}, BaseToolCapability&LighthouseCapability> {
-  readonly name = ToolName.RUN_LIGHTHOUSE;
-  readonly description =
+    DataTool<RunLighthouseArgs, {audits: string}, BaseToolCapability&LighthouseRecordingCapability> {
+  readonly name: ToolName = ToolName.RUN_LIGHTHOUSE;
+  readonly description: string =
       'Runs Lighthouse audits on the active page. Supports "navigation" (for full initial page load audits), "snapshot" (for inspecting live in-page modifications without reload), and "timespan" (for interactions).';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof RunLighthouseArgs> = {
@@ -37,7 +37,7 @@ export class RunLighthouseTool implements
         description: 'Reason for running new audits.',
         nullable: false,
       },
-      category: {
+      categoryId: {
         type: Host.AidaClient.ParametersTypes.STRING,
         description: 'Lighthouse category. E.g. "accessibility", "performance".',
         nullable: false,
@@ -49,34 +49,31 @@ export class RunLighthouseTool implements
         nullable: true,
       },
     },
-    required: ['explanation', 'category'],
+    required: ['explanation', 'categoryId'],
   };
 
   displayInfoFromArgs(params: RunLighthouseArgs): {title: string, thought: string, action: string} {
     return {
-      title: `Running Lighthouse audits: ${params.category} (${params.mode ?? 'snapshot'})`,
+      title: `Running Lighthouse audits: ${params.categoryId} (${params.mode ?? 'snapshot'})`,
       thought: params.explanation,
-      action: `runLighthouse('${params.category}', '${params.mode ?? 'snapshot'}')`,
+      action: `runLighthouse('${params.categoryId}', '${params.mode ?? 'snapshot'}')`,
     };
   }
 
-  async handler(params: RunLighthouseArgs,
-                context: BaseToolCapability&LighthouseCapability): Promise<DataHandlerResult<{audits: string}>> {
-    if (!context.lighthouseRecording) {
-      return {error: 'Error: Lighthouse recording capability is not available.'};
-    }
+  async handler(params: RunLighthouseArgs, context: BaseToolCapability&LighthouseRecordingCapability):
+      Promise<DataHandlerResult<{audits: string}>> {
     const mode = params.mode ?? 'snapshot';
     try {
-      const report = await context.lighthouseRecording({
+      const report = await context.runLighthouse({
         mode,
-        categoryIds: [params.category],
+        categoryIds: [params.categoryId],
         isAIControlled: true,
       });
       if (!report) {
         return {error: 'Error: Failed to record new audits.'};
       }
 
-      const audits = new LighthouseFormatter().audits(report, params.category);
+      const audits = new LighthouseFormatter().audits(report, params.categoryId);
       const isSnapshot = mode === 'snapshot';
       return {
         result: {audits},

package/front_end/models/ai_assistance/tools/SelectTraceEventByKey.ts

@@ -6,12 +6,12 @@ import * as Common from '../../../core/common/common.js';
 import * as Host from '../../../core/host/host.js';
 import * as i18n from '../../../core/i18n/i18n.js';
 import * as SDK from '../../../core/sdk/sdk.js';
-import {PerformanceTraceContext} from '../contexts/PerformanceTraceContext.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
+  type PerformanceTraceCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -26,9 +26,10 @@ export interface SelectTraceEventByKeyArgs extends ToolArgs {
   eventKey: string;
 }
 
-export class SelectTraceEventByKeyTool implements DataTool<SelectTraceEventByKeyArgs, string, BaseToolCapability> {
-  readonly name = ToolName.SELECT_TRACE_EVENT_BY_KEY;
-  readonly description = 'Selects and reveals a specific event by its key in the Performance panel Flamechart.';
+export class SelectTraceEventByKeyTool implements
+    DataTool<SelectTraceEventByKeyArgs, string, BaseToolCapability&PerformanceTraceCapability> {
+  readonly name: ToolName = ToolName.SELECT_TRACE_EVENT_BY_KEY;
+  readonly description: string = 'Selects and reveals a specific event by its key in the Performance panel Flamechart.';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof SelectTraceEventByKeyArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -56,14 +57,14 @@ export class SelectTraceEventByKeyTool implements DataTool<SelectTraceEventByKey
 
   async handler(
       params: SelectTraceEventByKeyArgs,
-      capabilities: BaseToolCapability,
+      capabilities: BaseToolCapability&PerformanceTraceCapability,
       ): Promise<DataHandlerResult<string>> {
-    const conversationContext = capabilities.conversationContext;
-    if (!conversationContext || !(conversationContext instanceof PerformanceTraceContext)) {
+    const performanceTraceContext = capabilities.getPerformanceTraceContext();
+    if (!performanceTraceContext) {
       return {error: 'Performance trace context is not available.'};
     }
 
-    const focus = conversationContext.getItem();
+    const focus = performanceTraceContext.getItem();
     const event = focus.lookupEvent(params.eventKey);
     if (!event) {
       return {error: `Could not find event with key "${params.eventKey}".`};