chrome-devtools-frontend 1.0.1706026 → 1.0.1709383

package/front_end/models/ai_assistance/data_formatters/PerformanceTraceFormatter.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import type * as Platform from '../../../core/platform/platform.js';
+import * as SDK from '../../../core/sdk/sdk.js';
 import type * as Protocol from '../../../generated/protocol.js';
 import * as CrUXManager from '../../crux-manager/crux-manager.js';
 import type * as SourceMapScopes from '../../source_map_scopes/source_map_scopes.js';
@@ -15,6 +16,105 @@ import {NetworkRequestFormatter, sanitizeHeaders} from './NetworkRequestFormatte
 import {PerformanceInsightFormatter} from './PerformanceInsightFormatter.js';
 import {bytes, micros, millis} from './UnitFormatters.js';
 
+/**
+ * Filters response headers to the 7 standard CORS-safelisted headers for
+ * opaque cross-origin requests.
+ *
+ * Note: `NetworkRequestFormatter` (`allowHeader` / `sanitizeHeaders`) applies
+ * a second, broader allowlist to redact sensitive header values (like
+ * `set-cookie`) even on same-origin requests, but that list permits headers
+ * such as `location`, `link`, `content-security-policy`, and `x-forwarded-host`
+ * that must not be exposed for cross-origin requests.
+ */
+function filterToCorsSafelistedHeaders(headers: Array<{name: string, value: string}>):
+    Array<{name: string, value: string}> {
+  return headers.filter(
+      header => SDK.NetworkRequestAccess.CORS_SAFELISTED_RESPONSE_HEADERS.has(header.name.toLowerCase().trim()));
+}
+
+/**
+ * Evaluates whether a traced network request is same-origin with the trace's
+ * main frame origin across its entire redirect chain.
+ *
+ * Trace events record raw network activity from the renderer (including full
+ * redirect chains, final post-redirect URLs, and all response headers), even
+ * for cross-origin requests where the browser's Same-Origin Policy would hide
+ * those details from the page.
+ *
+ * Unlike live `SDK.NetworkRequest.NetworkRequest` objects evaluated via
+ * `SDK.NetworkRequestAccess.evaluateResponseAccessMode`, traced network
+ * requests do not record request headers/cookies (needed to determine if a
+ * request is credentialed when evaluating `Access-Control-Allow-Origin: *`),
+ * Fetch request mode (`cors` vs `no-cors`), `corsErrorStatus`, or intermediate
+ * redirect response headers. Consequently, all cross-origin traced requests
+ * are treated as opaque (restricting headers to the CORS safelist and omitting
+ * redirect chains).
+ */
+function isSameOriginTraceRequest(
+    request: Trace.Types.Events.SyntheticNetworkRequest,
+    parsedTrace: Trace.TraceModel.ParsedTrace,
+    ): boolean {
+  const traceUrl = parsedTrace.data?.Meta?.mainFrameURL;
+  const targetUrl = request.args.data.url;
+  if (!traceUrl || !targetUrl) {
+    return false;
+  }
+  const traceOrigin = SDK.SecurityOrigin.SecurityOrigin.create(traceUrl);
+  if (traceOrigin.isOpaque()) {
+    return false;
+  }
+  const redirects = request.args.data.redirects ?? [];
+  for (const redirect of redirects) {
+    if (!redirect.url || !traceOrigin.isSameOriginWith(SDK.SecurityOrigin.SecurityOrigin.create(redirect.url))) {
+      return false;
+    }
+  }
+  return traceOrigin.isSameOriginWith(SDK.SecurityOrigin.SecurityOrigin.create(targetUrl));
+}
+
+function filteredResponseHeaders(
+    request: Trace.Types.Events.SyntheticNetworkRequest,
+    parsedTrace: Trace.TraceModel.ParsedTrace,
+    ): Array<{name: string, value: string}>|null {
+  const headers = request.args.data.responseHeaders;
+  if (!headers) {
+    return headers;
+  }
+  if (isSameOriginTraceRequest(request, parsedTrace)) {
+    return headers;
+  }
+  return filterToCorsSafelistedHeaders(headers);
+}
+
+function filteredRedirects(
+    request: Trace.Types.Events.SyntheticNetworkRequest,
+    parsedTrace: Trace.TraceModel.ParsedTrace,
+    ): Trace.Types.Events.SyntheticNetworkRedirect[] {
+  if (isSameOriginTraceRequest(request, parsedTrace)) {
+    return request.args.data.redirects ?? [];
+  }
+  return [];
+}
+
+/**
+ * Returns the URL safe to expose for a traced network request.
+ *
+ * `request.args.data.url` is the final post-redirect URL. For cross-origin
+ * requests that redirected, the final URL (and any intermediate redirect hops)
+ * is hidden from the page by the Same-Origin Policy, whereas `redirects[0].url`
+ * is the initial pre-redirect URL that the page itself requested.
+ */
+function filteredUrl(
+    request: Trace.Types.Events.SyntheticNetworkRequest,
+    parsedTrace: Trace.TraceModel.ParsedTrace,
+    ): string {
+  const redirects = request.args.data.redirects ?? [];
+  if (redirects.length === 0 || isSameOriginTraceRequest(request, parsedTrace)) {
+    return request.args.data.url;
+  }
+  return redirects[0].url || '<redacted cross-origin redirect destination>';
+}
+
 export interface NetworkRequestFormatOptions {
   verbose?: boolean;
   customTitle?: string;
@@ -470,12 +570,36 @@ export class PerformanceTraceFormatter {
       // number of related events. Mostly, insights probably don't have more than
       // 5.
       const eventsString =
-          events.slice(0, 5).map(e => Trace.Name.forEntry(e) + ' ' + this.serializeEvent(e)).join(', ');
+          events.slice(0, 5).map(e => this.#safeNameForEntry(e) + ' ' + this.serializeEvent(e)).join(', ');
       results.push(`- ${insightKey}: ${eventsString}`);
     }
     return results.join('\n');
   }
 
+  /**
+   * Returns the display name for a trace event, replacing the final
+   * post-redirect URL on cross-origin network requests with the initial
+   * pre-redirect URL (`filteredUrl`) before delegating to `Trace.Name.forEntry`.
+   */
+  #safeNameForEntry(event: Trace.Types.Events.Event): string {
+    if (Trace.Types.Events.isSyntheticNetworkRequest(event)) {
+      const safeUrl = filteredUrl(event, this.#parsedTrace);
+      if (safeUrl !== event.args.data.url) {
+        return Trace.Name.forEntry({
+          ...event,
+          args: {
+            ...event.args,
+            data: {
+              ...event.args.data,
+              url: safeUrl,
+            },
+          },
+        });
+      }
+    }
+    return Trace.Name.forEntry(event);
+  }
+
   async formatMainThreadTrackSummary(bounds: Trace.Types.Timing.TraceWindowMicro): Promise<string> {
     if (!this.#parsedTrace.insights) {
       return 'No main thread activity found';
@@ -614,6 +738,10 @@ export class PerformanceTraceFormatter {
     return result;
   }
 
+  formatRequestUrl(request: Trace.Types.Events.SyntheticNetworkRequest): string {
+    return filteredUrl(request, this.#parsedTrace);
+  }
+
   formatNetworkRequests(
       requests: readonly Trace.Types.Events.SyntheticNetworkRequest[], options?: NetworkRequestFormatOptions): string {
     if (requests.length === 0) {
@@ -679,22 +807,20 @@ export class PerformanceTraceFormatter {
   #networkRequestVerbosely(request: Trace.Types.Events.SyntheticNetworkRequest, options?: NetworkRequestFormatOptions):
       string {
     const {
-      url,
       statusCode,
       initialPriority,
       priority,
       fromServiceWorker,
       mimeType,
-      responseHeaders,
       syntheticData,
       protocol,
     } = request.args.data;
     const parsedTrace = this.#parsedTrace;
+    const url = filteredUrl(request, parsedTrace);
+    const responseHeaders = filteredResponseHeaders(request, parsedTrace);
 
     const titlePrefix = `## ${options?.customTitle ?? 'Network request'}`;
 
-    // Note: unlike other agents, we do have the ability to include
-    // cross-origins, hence why we do not sanitize the URLs here.
     const navigationForEvent = Trace.Helpers.Trace.getNavigationForTraceEvent(
         request,
         request.args.data.frame,
@@ -727,7 +853,7 @@ export class PerformanceTraceFormatter {
       priorityLines.push(`Final priority: ${priority}`);
     }
 
-    const redirects = request.args.data.redirects.map((redirect, index) => {
+    const redirects = filteredRedirects(request, parsedTrace).map((redirect, index) => {
       const startTime = redirect.ts - baseTime;
       return `#### Redirect ${index + 1}: ${redirect.url}
 - Start time: ${micros(startTime)}
@@ -735,7 +861,7 @@ export class PerformanceTraceFormatter {
     });
 
     const initiators = this.#getInitiatorChain(parsedTrace, request);
-    const initiatorUrls = initiators.map(initiator => initiator.args.data.url);
+    const initiatorUrls = initiators.map(initiator => filteredUrl(initiator, parsedTrace));
 
     const eventKey = this.#eventsSerializer.keyForEvent(request);
     const eventKeyLine = eventKey ? `eventKey: ${eventKey}\n` : '';
@@ -749,7 +875,7 @@ ${eventKeyLine}Timings:
 Durations:
 - Download time: ${micros(downloadTime)}
 - Main thread processing time: ${micros(mainThreadProcessingDuration)}
-- Total duration: ${micros(request.dur)}${initiator ? `\nInitiator: ${initiator.args.data.url}` : ''}
+- Total duration: ${micros(request.dur)}${initiator ? `\nInitiator: ${filteredUrl(initiator, parsedTrace)}` : ''}
 Redirects:${redirects.length ? '\n' + redirects.join('\n') : ' no redirects'}
 Status code: ${statusCode}
 MIME Type: ${mimeType}
@@ -776,7 +902,8 @@ Network requests data:
     const urlIdToIndex = new Map<string, number>();
     const allRequestsText = requests
                                 .map(request => {
-                                  const urlIndex = this.#getOrAssignUrlIndex(urlIdToIndex, request.args.data.url);
+                                  const urlIndex =
+                                      this.#getOrAssignUrlIndex(urlIdToIndex, filteredUrl(request, this.#parsedTrace));
                                   return this.#networkRequestCompressedFormat(urlIndex, request, urlIdToIndex);
                                 })
                                 .join('\n');
@@ -867,11 +994,11 @@ The order of headers corresponds to an internal fixed list. If a header is not p
       priority,
       fromServiceWorker,
       mimeType,
-      responseHeaders,
       syntheticData,
       protocol,
     } = request.args.data;
     const parsedTrace = this.#parsedTrace;
+    const responseHeaders = filteredResponseHeaders(request, parsedTrace);
 
     const navigationForEvent = Trace.Helpers.Trace.getNavigationForTraceEvent(
         request,
@@ -895,7 +1022,7 @@ The order of headers corresponds to an internal fixed list. If a header is not p
                                return `${header.name}: ${value}`;
                              })
                              .join('|');
-    const redirects = request.args.data.redirects
+    const redirects = filteredRedirects(request, parsedTrace)
                           .map(redirect => {
                             const urlIndex = this.#getOrAssignUrlIndex(urlIdToIndex, redirect.url);
                             const redirectStartTime = micros(redirect.ts - baseTime);
@@ -906,7 +1033,7 @@ The order of headers corresponds to an internal fixed list. If a header is not p
 
     const initiators = this.#getInitiatorChain(parsedTrace, request);
     const initiatorUrlIndices =
-        initiators.map(initiator => this.#getOrAssignUrlIndex(urlIdToIndex, initiator.args.data.url));
+        initiators.map(initiator => this.#getOrAssignUrlIndex(urlIdToIndex, filteredUrl(initiator, parsedTrace)));
 
     const parts = [
       urlIndex,
@@ -1037,33 +1164,93 @@ The order of headers corresponds to an internal fixed list. If a header is not p
   }
 }
 
+function sanitizeSyntheticNetworkRequestEvent(
+    event: Trace.Types.Events.SyntheticNetworkRequest,
+    parsedTrace: Trace.TraceModel.ParsedTrace,
+    ): Trace.Types.Events.SyntheticNetworkRequest {
+  const safeUrl = filteredUrl(event, parsedTrace);
+  const headers = filteredResponseHeaders(event, parsedTrace);
+  const sanitizedEvent: Trace.Types.Events.SyntheticNetworkRequest = {
+    ...event,
+    args: {
+      ...event.args,
+      data: {
+        ...event.args.data,
+        url: safeUrl,
+        redirects: filteredRedirects(event, parsedTrace),
+        responseHeaders: headers ? sanitizeHeaders(headers) : null,
+      },
+    },
+  };
+  if (event.rawSourceEvent?.args?.data) {
+    sanitizedEvent.rawSourceEvent = {
+      ...event.rawSourceEvent,
+      args: {
+        ...event.rawSourceEvent.args,
+        data: {
+          ...event.rawSourceEvent.args.data,
+          url: safeUrl,
+        },
+      },
+    };
+  }
+  return sanitizedEvent;
+}
+
 /**
  * Serializes a trace event to a JSON string for AI consumption,
  * ensuring sensitive data (like headers and raw script source code)
  * is sanitized or redacted.
  */
-export function formatEventForAI(event: Trace.Types.Events.Event): string {
+export function formatEventForAI(
+    event: Trace.Types.Events.Event,
+    parsedTrace: Trace.TraceModel.ParsedTrace,
+    ): string {
   if (Trace.Types.Events.isSyntheticNetworkRequest(event)) {
+    return JSON.stringify(sanitizeSyntheticNetworkRequestEvent(event, parsedTrace));
+  }
+
+  if (Trace.Types.Events.isResourceSendRequest(event)) {
+    const syntheticRequest =
+        parsedTrace.data?.NetworkRequests?.byTime?.find(r => r.args.data.requestId === event.args.data.requestId);
+    let safeUrl = '<redacted cross-origin redirect destination>';
+    if (syntheticRequest) {
+      safeUrl = isSameOriginTraceRequest(syntheticRequest, parsedTrace) ? event.args.data.url :
+                                                                          filteredUrl(syntheticRequest, parsedTrace);
+    } else {
+      const traceUrl = parsedTrace.data?.Meta?.mainFrameURL;
+      const traceOrigin = traceUrl ? SDK.SecurityOrigin.SecurityOrigin.create(traceUrl) : null;
+      if (traceOrigin && !traceOrigin.isOpaque() &&
+          traceOrigin.isSameOriginWith(SDK.SecurityOrigin.SecurityOrigin.create(event.args.data.url))) {
+        safeUrl = event.args.data.url;
+      }
+    }
     return JSON.stringify({
       ...event,
       args: {
         ...event.args,
         data: {
           ...event.args.data,
-          responseHeaders: event.args.data.responseHeaders ? sanitizeHeaders(event.args.data.responseHeaders) : null,
+          url: safeUrl,
         },
       },
     });
   }
 
   if (Trace.Types.Events.isResourceReceiveResponse(event)) {
+    const syntheticRequest =
+        parsedTrace.data?.NetworkRequests?.byTime?.find(r => r.args.data.requestId === event.args.data.requestId);
+    const isSameOrigin = Boolean(syntheticRequest && isSameOriginTraceRequest(syntheticRequest, parsedTrace));
+    const filteredHeaders = event.args.data.headers ?
+        (isSameOrigin ? event.args.data.headers : filterToCorsSafelistedHeaders(event.args.data.headers)) :
+        undefined;
     return JSON.stringify({
       ...event,
       args: {
         ...event.args,
         data: {
           ...event.args.data,
-          headers: event.args.data.headers ? sanitizeHeaders(event.args.data.headers) : undefined,
+          headers: filteredHeaders ? sanitizeHeaders(filteredHeaders) : undefined,
         },
       },
     });

package/front_end/models/ai_assistance/skills/Skill.ts

@@ -2,8 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// This will become a union type as we add more skills (e.g. 'styling' | 'network').
-export type SkillName = 'styling'|'network'|'accessibility'|'performance'|'storage'|'sources';
+export type SkillName = 'styling'|'network'|'accessibility'|'performance'|'storage'|'sources'|'lighthouse';
 
 export interface Skill {
   name: SkillName;

package/front_end/models/ai_assistance/skills/SkillRegistry.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import {skill as accessibilitySkill} from './accessibility.skill.js';
+import {skill as lighthouseSkill} from './lighthouse.skill.js';
 import {skill as networkSkill} from './network.skill.js';
 import {skill as performanceSkill} from './performance.skill.js';
 import type {Skill, SkillName} from './Skill.js';
@@ -17,4 +18,5 @@ export const SKILLS: Record<SkillName, Skill> = {
   performance: performanceSkill,
   storage: storageSkill,
   sources: sourcesSkill,
+  lighthouse: lighthouseSkill,
 };

package/front_end/models/ai_assistance/skills/lighthouse.md

@@ -0,0 +1,33 @@
+---
+name: lighthouse
+description: Running Lighthouse reports and audits, full-page audits (performance, accessibility, best practices, Search Engine Optimization (SEO)), and inspecting Lighthouse scores.
+allowed-tools:
+  - runLighthouse
+  - getLighthouseAudits
+  - resolveDevtoolsNodePath
+---
+You are an expert web quality and audit assistant integrated into Chrome DevTools.
+Your role is to evaluate websites using Lighthouse audits across performance, accessibility, best practices, and SEO.
+
+# Tools & Workflow
+
+1. **Lighthouse Audits (`runLighthouse` & `getLighthouseAudits`)**:
+   - If an active Lighthouse report context already exists and no fresh audit is requested:
+     - To inspect the entire report or multiple categories, call `getLighthouseAudits` with `categoryId: 'all'`.
+     - For a specific category, call `getLighthouseAudits` with the corresponding category ID (e.g. `'performance'`, `'accessibility'`, `'best-practices'`, `'seo'`).
+   - If no active report exists or a fresh audit is requested, call `runLighthouse`:
+     - If the user asks for a general report or multiple categories, use `categoryId: 'all'`.
+     - For a single category, pass that category ID.
+     - Execution mode:
+       - Use `"navigation"` mode for full page-load audits (default for full site reviews).
+       - Use `"snapshot"` mode to re-evaluate live in-page DOM/CSS modifications without reloading.
+       - Use `"timespan"` mode for user interaction flows.
+       - Always honor explicit mode requests from the user.
+
+2. **Resolving Node References (`resolveDevtoolsNodePath`)**:
+   - When an audit references failing elements by DevTools node path (e.g. `"1,HTML,1,BODY,2,BUTTON"`), use `resolveDevtoolsNodePath` to resolve the path to a `backendNodeId` to identify the failing element (or inspect it using tools from other skills if active).
+
+# Considerations
+
+- Base all analysis on empirical Lighthouse audit data. Never fabricate audit scores or results.
+- When summarizing a full Lighthouse run, highlight overall category scores first, then detail failing audits (score < 90).

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

@@ -4,6 +4,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 Root from '../../../core/root/root.js';
 import * as Formatter from '../../formatter/formatter.js';
 import type {FunctionHandlerOptions} from '../agents/AiAgent.js';
@@ -16,11 +17,14 @@ import {
   isOriginAllowedByLock,
   type OriginLockCapability,
   type PageExecutionCapability,
+  PermissionPrompt,
   type StyleMutationCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
 
+const lockedString = i18n.i18n.lockedString;
+
 const MAX_FORMATTED_LINES = 40;
 const MAX_LINE_LENGTH = 120;
 const MAX_TOTAL_CHARACTERS = 2500;
@@ -35,6 +39,8 @@ export class ExecuteJavaScriptTool implements
     DataTool<ExecuteJavaScriptArgs, unknown,
              BaseToolCapability&PageExecutionCapability&StyleMutationCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.EXECUTE_JAVASCRIPT;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.ALLOW_ONCE;
+  readonly permissionTitle: string = lockedString('Allow running JavaScript on the page?');
 
   readonly description: string =
       'This function allows you to run JavaScript code on the inspected page to access the element styles and page content.\nCall this function to gather additional information or modify the page state. Call this function enough times to investigate the user request. Note: You cannot make network requests using this function.';

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

@@ -17,6 +17,7 @@ import {
   type DataHandlerResult,
   type DataTool,
   type OriginLockCapability,
+  PermissionPrompt,
   type ServerLoggingCapability,
   ToolAnnotation,
   type ToolArgs,
@@ -41,6 +42,8 @@ export interface GetCookieValuesResult {
 export class GetCookieValuesTool implements DataTool<GetCookieValuesArgs, GetCookieValuesResult,
                                                      BaseToolCapability&OriginLockCapability&ServerLoggingCapability> {
   readonly name: ToolName = ToolName.GET_COOKIE_VALUES;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.ALLOW_ONCE;
+  readonly permissionTitle: string = lockedString('Allow reading cookie values?');
   readonly description: string =
       'Retrieve the values and detailed metadata of specific cookies by their names across origins.';
 

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

@@ -12,6 +12,7 @@ import {
   type DataHandlerResult,
   type DataTool,
   type PerformanceTraceCapability,
+  PermissionPrompt,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -29,6 +30,7 @@ export interface GetDetailedCallTreeArgs extends ToolArgs {
 export class GetDetailedCallTreeTool implements
     DataTool<GetDetailedCallTreeArgs, string, BaseToolCapability&PerformanceTraceCapability> {
   readonly name: ToolName = ToolName.GET_DETAILED_CALL_TREE;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       'Retrieves a bottom-up call tree and execution breakdown for a specific main thread event by its eventKey.';
 

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

@@ -13,6 +13,7 @@ import {
   type DataTool,
   isOriginAllowedByLock,
   type OriginLockCapability,
+  PermissionPrompt,
   type TargetCapability,
   type ToolArgs,
   ToolName,
@@ -36,6 +37,7 @@ export interface GetElementAccessibilityDetailsArgs extends ToolArgs {
 export class GetElementAccessibilityDetailsTool implements
     DataTool<GetElementAccessibilityDetailsArgs, string, BaseToolCapability&TargetCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.GET_ELEMENT_ACCESSIBILITY_DETAILS;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       'Retrieves detailed accessibility properties (computed role, accessible name, name source, ARIA attributes, ignored state) and a DOM tree snapshot for an element by backend node ID.';
 

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

@@ -18,6 +18,7 @@ import {
   type DataTool,
   MAX_FUNCTION_RESULT_BYTE_LENGTH,
   type PerformanceTraceCapability,
+  PermissionPrompt,
   type TargetCapability,
   type ToolArgs,
   ToolName,
@@ -56,6 +57,7 @@ export interface GetInsightDetailsArgs extends ToolArgs {
 export class GetInsightDetailsTool implements
     DataTool<GetInsightDetailsArgs, string, BaseToolCapability&TargetCapability&PerformanceTraceCapability> {
   readonly name: ToolName = ToolName.GET_INSIGHT_DETAILS;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       'Retrieves detailed metrics, subpart timing breakdowns, related DOM elements, and diagnostic data for a performance insight (e.g., \'LCPBreakdown\', \'LCPDiscovery\', \'RenderBlocking\', \'CLSCulprits\', \'INPBreakdown\', \'ThirdParties\'). Use this before commenting on any specific performance issue.';
 

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

@@ -3,27 +3,28 @@
 // found in the LICENSE file.
 
 import * as Host from '../../../core/host/host.js';
-import type * as LHModel from '../../lighthouse/lighthouse.js';
-import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
+import {type LighthouseCategoryArg, LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
 
 import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
   type LighthouseReportCapability,
+  PermissionPrompt,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
 
 export interface GetLighthouseAuditsArgs extends ToolArgs {
-  categoryId: LHModel.RunTypes.CategoryId;
+  categoryId: LighthouseCategoryArg;
 }
 
 export class GetLighthouseAuditsTool implements
     DataTool<GetLighthouseAuditsArgs, {audits: string}, BaseToolCapability&LighthouseReportCapability> {
   readonly name: ToolName = ToolName.GET_LIGHTHOUSE_AUDITS;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
-      'Retrieves audit results and diagnostic details from the active Lighthouse report for a specific category (e.g., \'accessibility\').';
+      'Retrieves audit results and diagnostic details from the active Lighthouse report for all categories (using categoryId: "all") or a specific category (e.g., \'accessibility\').';
 
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetLighthouseAuditsArgs> = {
     type: Host.AidaClient.ParametersTypes.OBJECT,
@@ -32,7 +33,8 @@ export class GetLighthouseAuditsTool implements
     properties: {
       categoryId: {
         type: Host.AidaClient.ParametersTypes.STRING,
-        description: 'The category of audits to retrieve. E.g. "accessibility".',
+        description:
+            'The category of audits to retrieve. Use "all" to retrieve the full report and all categories, or specify a category: "accessibility", "performance", "best-practices", "seo".',
         nullable: false,
       },
     },
@@ -52,10 +54,9 @@ export class GetLighthouseAuditsTool implements
     if (!report) {
       return {error: 'Error: Active context is not a Lighthouse report.'};
     }
-    const audits = new LighthouseFormatter().audits(report, params.categoryId);
+    const audits = new LighthouseFormatter().formatReport(report, params.categoryId);
     return {
       result: {audits},
-      widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report}}],
     };
   }
 }

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

@@ -14,6 +14,7 @@ import {
   type DataTool,
   isOriginAllowedByLock,
   type OriginLockCapability,
+  PermissionPrompt,
   resolveOriginFromLock,
   type ToolArgs,
   ToolName,
@@ -35,6 +36,7 @@ export interface GetNetworkRequestDetailsArgs extends ToolArgs {
 export class GetNetworkRequestDetailsTool implements
     DataTool<GetNetworkRequestDetailsArgs, unknown, BaseToolCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.GET_NETWORK_REQUEST_DETAILS;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       'Retrieves the full headers, timing, status, and body details of a specific network request by ID.';
 

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

@@ -13,6 +13,7 @@ import {
   type DataHandlerResult,
   type DataTool,
   type OriginLockCapability,
+  PermissionPrompt,
   resolveOriginFromLock,
   type ToolArgs,
   ToolName,
@@ -35,6 +36,7 @@ export interface GetSourceContentArgs extends ToolArgs {
 export class GetSourceContentTool implements
     DataTool<GetSourceContentArgs, {content: string}, BaseToolCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.GET_SOURCE_CONTENT;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       'Retrieves the formatted content and metadata of a source file by its numeric ID obtained from listSources.';
 

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

@@ -14,6 +14,7 @@ import {
   type DataHandlerResult,
   type DataTool,
   type OriginLockCapability,
+  PermissionPrompt,
   ToolName,
 } from './Tool.js';
 
@@ -31,6 +32,7 @@ export interface GetStorageBreakdownResult {
 export class GetStorageBreakdownTool implements
     DataTool<Record<string, never>, GetStorageBreakdownResult, BaseToolCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.GET_STORAGE_BREAKDOWN;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       'Retrieves total storage usage and quota breakdown across all storage types (IndexedDB, CacheStorage, LocalStorage, SessionStorage, cookies) for the top-level page origin.';
 

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

@@ -15,6 +15,7 @@ import {
   type DataHandlerResult,
   type DataTool,
   type OriginLockCapability,
+  PermissionPrompt,
   type ServerLoggingCapability,
   ToolAnnotation,
   type ToolArgs,
@@ -46,6 +47,8 @@ export interface GetStorageValuesResult {
 export class GetStorageValuesTool implements DataTool<GetStorageValuesArgs, GetStorageValuesResult,
                                                       BaseToolCapability&OriginLockCapability&ServerLoggingCapability> {
   readonly name: ToolName = ToolName.GET_STORAGE_VALUES;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.ALLOW_ONCE;
+  readonly permissionTitle: string = lockedString('Allow reading storage values?');
   readonly description: string =
       'Retrieve specific string values from storage partitions for requested keys across origins.';
 

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

@@ -13,6 +13,7 @@ import {
   type DataTool,
   isOriginAllowedByLock,
   type OriginLockCapability,
+  PermissionPrompt,
   type TargetCapability,
   type ToolArgs,
   ToolName,
@@ -27,6 +28,7 @@ export interface GetStylesArgs extends ToolArgs {
 export class GetStylesTool implements
     DataTool<GetStylesArgs, unknown, BaseToolCapability&TargetCapability&OriginLockCapability> {
   readonly name: ToolName = ToolName.GET_STYLES;
+  readonly permissionPrompt: PermissionPrompt = PermissionPrompt.NEVER;
   readonly description: string =
       `Retrieves computed and authored CSS styles for one or more elements by their backend node IDs (uids).