chrome-devtools-frontend 1.0.1650232 → 1.0.1651641

package/front_end/models/ai_assistance/README.md

@@ -105,6 +105,10 @@ To aid debugging, you can enable the AI Assistance logging. This setting is stor
 
 Now, when interacting with the AI and sending requests, you will see output logged to the console. You can use the `debugLog` helper to add your own logging as you are building out your feature.
 
+### Testing the Accessibility Skill
+
+The accessibility skill (`accessibility.md`) relies on an active Lighthouse report. Before interacting with the agent using this skill, ensure you have run a Lighthouse audit on the page you are inspecting so that the `getLighthouseAudits` tool can retrieve the report data.
+
 ## Security & Origin Isolation
 
 To prevent prompt injection attacks and cross-origin data leaks, the AI Assistance panel enforces strict origin-lock boundaries:

package/front_end/models/ai_assistance/agents/AccessibilityAgent.ts

@@ -483,6 +483,8 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
           name: 'DOM_TREE',
           data: {
             root: snapshot,
+            title: i18n.i18n.lockedString('Element details'),
+            accessibleRevealLabel: i18n.i18n.lockedString('Reveal element'),
           },
         });
 

package/front_end/models/ai_assistance/agents/AiAgent.ts

@@ -4,6 +4,7 @@
 
 import * as Host from '../../../core/host/host.js';
 import type {UrlString} from '../../../core/platform/DevToolsPath.js';
+import type * as Platform from '../../../core/platform/platform.js';
 import * as Root from '../../../core/root/root.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
 import type * as Protocol from '../../../generated/protocol.js';
@@ -274,6 +275,8 @@ export interface DomTreeAiWidget {
   name: 'DOM_TREE';
   data: {
     root: SDK.DOMModel.DOMNodeSnapshot,
+    title: Platform.UIString.LocalizedString,
+    accessibleRevealLabel: Platform.UIString.LocalizedString,
     networkRequest?: {
       url: string,
       size: number,

package/front_end/models/ai_assistance/agents/PerformanceAgent.ts

@@ -1051,6 +1051,8 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
                     data: {
                       root: snapshot,
                       networkRequest,
+                      title: lockedString('LCP element'),
+                      accessibleRevealLabel: lockedString('Reveal LCP element'),
                     },
                   });
                 }

package/front_end/models/ai_assistance/ai_assistance.ts

@@ -43,9 +43,11 @@ import * as AIQueries from './performance/AIQueries.js';
 import * as PerformanceAnnotations from './PerformanceAnnotations.js';
 import * as StorageItem from './StorageItem.js';
 import * as ExecuteJavaScript from './tools/ExecuteJavaScript.js';
+import * as GetLighthouseAudits from './tools/GetLighthouseAudits.js';
 import * as GetNetworkRequestDetails from './tools/GetNetworkRequestDetails.js';
 import * as GetStyles from './tools/GetStyles.js';
 import * as ListNetworkRequests from './tools/ListNetworkRequests.js';
+import * as ResolveLighthousePath from './tools/ResolveLighthousePath.js';
 import * as Tool from './tools/Tool.js';
 import * as ToolRegistry from './tools/ToolRegistry.js';
 
@@ -74,6 +76,7 @@ export {
   FileAgent,
   FileContext,
   FileFormatter,
+  GetLighthouseAudits,
   GetNetworkRequestDetails,
   GetStyles,
   GreenDevAgent,
@@ -90,6 +93,7 @@ export {
   PerformanceInsightFormatter,
   PerformanceTraceFormatter,
   RequestContext,
+  ResolveLighthousePath,
   StorageAgent,
   StorageItem,
   StylingAgent,

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

@@ -3,7 +3,7 @@
 // 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';
+export type SkillName = 'styling'|'network'|'accessibility';
 
 export interface Skill {
   name: SkillName;

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

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import {skill as accessibilitySkill} from './accessibility.skill.js';
 import {skill as networkSkill} from './network.skill.js';
 import type {Skill, SkillName} from './Skill.js';
 import {skill as stylingSkill} from './styling.skill.js';
@@ -9,4 +10,5 @@ import {skill as stylingSkill} from './styling.skill.js';
 export const SKILLS: Record<SkillName, Skill> = {
   styling: stylingSkill,
   network: networkSkill,
+  accessibility: accessibilitySkill,
 };

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

@@ -0,0 +1,13 @@
+---
+name: accessibility
+description: Accessibility audits and report querying.
+allowed-tools:
+  - getLighthouseAudits
+  - resolveLighthousePath
+  - getStyles
+---
+You are an expert accessibility debugging assistant.
+Use getLighthouseAudits to query details from the active report.
+
+* ALWAYS use resolveLighthousePath to resolve failing element paths to backend node IDs.
+* Once resolved, use getStyles on the backend node ID to inspect layout and styling properties.

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

@@ -0,0 +1,54 @@
+// 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 type * as LHModel from '../../lighthouse/lighthouse.js';
+import type {FunctionCallHandlerResult} from '../agents/AiAgent.js';
+import {AccessibilityContext} from '../contexts/AccessibilityContext.js';
+import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
+
+import {type BaseToolCapability, type Tool, type ToolArgs, ToolName} from './Tool.js';
+
+export interface GetLighthouseAuditsArgs extends ToolArgs {
+  categoryId: LHModel.RunTypes.CategoryId;
+}
+
+export class GetLighthouseAuditsTool implements Tool<GetLighthouseAuditsArgs, {audits: string}, BaseToolCapability> {
+  readonly name = ToolName.GET_LIGHTHOUSE_AUDITS;
+  readonly description = 'Returns the audits for a specific Lighthouse category.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof GetLighthouseAuditsArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for retrieving Lighthouse category audits.',
+    nullable: false,
+    properties: {
+      categoryId: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'The category of audits to retrieve. E.g. "accessibility".',
+        nullable: false,
+      },
+    },
+    required: ['categoryId'],
+  };
+
+  displayInfoFromArgs(params: GetLighthouseAuditsArgs): {title: string, action: string} {
+    return {
+      title: `Getting Lighthouse audits for ${params.categoryId}`,
+      action: `getLighthouseAudits('${params.categoryId}')`,
+    };
+  }
+
+  async handler(params: GetLighthouseAuditsArgs,
+                context: BaseToolCapability): Promise<FunctionCallHandlerResult<{audits: string}>> {
+    if (!(context.conversationContext instanceof AccessibilityContext)) {
+      return {error: 'Error: Active context is not a Lighthouse report.'};
+    }
+    const report = context.conversationContext.getItem();
+    const audits = new LighthouseFormatter().audits(report, params.categoryId);
+    return {
+      result: {audits},
+      widgets: [{name: 'LIGHTHOUSE_REPORT', data: {report}}],
+    };
+  }
+}

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

@@ -0,0 +1,124 @@
+// 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 SDK from '../../../core/sdk/sdk.js';
+import type {FunctionCallHandlerResult} from '../agents/AiAgent.js';
+import {DOMNodeContext} from '../contexts/DOMNodeContext.js';
+
+import {
+  type BaseToolCapability,
+  type OriginLockCapability,
+  type TargetCapability,
+  type Tool,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
+
+/**
+ * Arguments for resolving a Lighthouse path to a backend node ID.
+ */
+export interface ResolveLighthousePathArgs extends ToolArgs {
+  /**
+   * A Lighthouse-style element path.
+   * This is typically a comma-separated list of child indices and tag names
+   * representing the path from the root to the target element (e.g., "1,HTML,1,BODY").
+   */
+  path: string;
+  explanation: string;
+}
+
+/**
+ * A tool that resolves a Lighthouse-style element path to a backend node ID.
+ *
+ * This is used by the AI assistant to identify specific DOM nodes referred to in
+ * Lighthouse reports. It ensures the resolved node belongs to the locked origin.
+ */
+export class ResolveLighthousePathTool implements
+    Tool<ResolveLighthousePathArgs, {backendNodeId: number}, BaseToolCapability&TargetCapability&OriginLockCapability> {
+  readonly name = ToolName.RESOLVE_LIGHTHOUSE_PATH;
+  readonly description = 'Resolves a Lighthouse path to a backend node ID.';
+
+  readonly parameters: Host.AidaClient.FunctionObjectParam<keyof ResolveLighthousePathArgs> = {
+    type: Host.AidaClient.ParametersTypes.OBJECT,
+    description: 'Arguments for resolving a Lighthouse path to a backend node ID.',
+    nullable: false,
+    properties: {
+      explanation: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'Reason for requesting this resolution.',
+        nullable: false,
+      },
+      path: {
+        type: Host.AidaClient.ParametersTypes.STRING,
+        description: 'Lighthouse path string.',
+        nullable: false,
+      },
+    },
+    required: ['explanation', 'path'],
+  };
+
+  displayInfoFromArgs(params: ResolveLighthousePathArgs): {
+    title: string,
+    thought: string,
+    action: string,
+  } {
+    return {
+      title: 'Resolving element path',
+      thought: params.explanation,
+      action: `resolveLighthousePath('${params.path}')`,
+    };
+  }
+
+  /**
+   * Handles the resolution request.
+   *
+   * It retrieves the node path using the target's DOMModel and verifies
+   * that the node's origin matches the established origin lock to prevent
+   * access to nodes from other origins.
+   */
+  async handler(
+      params: ResolveLighthousePathArgs,
+      context: BaseToolCapability&TargetCapability&OriginLockCapability,
+      ): Promise<FunctionCallHandlerResult<{backendNodeId: number}>> {
+    const establishedOrigin = context.getEstablishedOrigin();
+    if (!establishedOrigin) {
+      return {error: 'Error: Origin lock is not established.'};
+    }
+
+    const target = context.getTarget();
+    const domModel = target?.model(SDK.DOMModel.DOMModel);
+    if (!domModel) {
+      return {error: 'Error: Inspected target not found.'};
+    }
+
+    let nodeId;
+    try {
+      // Resolves the Lighthouse path (a representation of the path to a node)
+      // and ensures the node is loaded into the frontend DOM model, returning its ID.
+      nodeId = await domModel.pushNodeByPathToFrontend(params.path);
+    } catch {
+      return {error: 'Error: Could not find node by path.'};
+    }
+    if (!nodeId) {
+      return {error: 'Error: Could not find node by path.'};
+    }
+
+    const node = domModel.nodeForId(nodeId);
+    if (!node) {
+      return {error: 'Error: Could not retrieve resolved node.'};
+    }
+
+    const nodeContext = new DOMNodeContext(node);
+    // Security check: Ensure the resolved node belongs to the same origin
+    // that this AI assistance session is locked to, preventing cross-origin access.
+    if (!nodeContext.isOriginAllowed(establishedOrigin)) {
+      return {error: 'Error: Node does not belong to the locked origin.'};
+    }
+
+    return {
+      result: {backendNodeId: node.backendNodeId()},
+    };
+  }
+}

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

@@ -4,6 +4,7 @@
 
 import type * as Host from '../../../core/host/host.js';
 import type * as SDK from '../../../core/sdk/sdk.js';
+import type * as LHModel from '../../lighthouse/lighthouse.js';
 import type {ConversationContext, FunctionCallHandlerResult, FunctionHandlerOptions} from '../agents/AiAgent.js';
 import type {executeJsCode} from '../agents/ExecuteJavascript.js';
 import type {ChangeManager} from '../ChangeManager.js';
@@ -72,12 +73,19 @@ export interface OriginLockCapability {
   getEstablishedOrigin(): string|undefined;
 }
 
+/**
+ * Capability for tools that need to run or query Lighthouse audits.
+ */
+export interface LighthouseCapability {
+  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+}
+
 /**
  * Unified context interface providing all capabilities available in the project.
  * Used by the agent to pass a complete context to any tool type-safely.
  */
-export type AllToolsContext =
-    BaseToolCapability&PageExecutionCapability&StyleMutationCapability&TargetCapability&OriginLockCapability;
+export type AllToolsContext = BaseToolCapability&PageExecutionCapability&StyleMutationCapability&TargetCapability&
+    OriginLockCapability&LighthouseCapability;
 
 /**
  * Base argument type for AI Tools.
@@ -89,6 +97,8 @@ export const enum ToolName {
   GET_STYLES = 'getStyles',
   LIST_NETWORK_REQUESTS = 'listNetworkRequests',
   GET_NETWORK_REQUEST_DETAILS = 'getNetworkRequestDetails',
+  GET_LIGHTHOUSE_AUDITS = 'getLighthouseAudits',
+  RESOLVE_LIGHTHOUSE_PATH = 'resolveLighthousePath',
 }
 
 /**

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

@@ -3,9 +3,11 @@
 // found in the LICENSE file.
 
 import {ExecuteJavaScriptTool} from './ExecuteJavaScript.js';
+import {GetLighthouseAuditsTool} from './GetLighthouseAudits.js';
 import {GetNetworkRequestDetailsTool} from './GetNetworkRequestDetails.js';
 import {GetStylesTool} from './GetStyles.js';
 import {ListNetworkRequestsTool} from './ListNetworkRequests.js';
+import {ResolveLighthousePathTool} from './ResolveLighthousePath.js';
 import {type AllToolsContext, type Tool, type ToolArgs, ToolName} from './Tool.js';
 
 /**
@@ -21,6 +23,8 @@ export const TOOLS = {
   [ToolName.GET_STYLES]: new GetStylesTool(),
   [ToolName.LIST_NETWORK_REQUESTS]: new ListNetworkRequestsTool(),
   [ToolName.GET_NETWORK_REQUEST_DETAILS]: new GetNetworkRequestDetailsTool(),
+  [ToolName.GET_LIGHTHOUSE_AUDITS]: new GetLighthouseAuditsTool(),
+  [ToolName.RESOLVE_LIGHTHOUSE_PATH]: new ResolveLighthousePathTool(),
 };
 
 /**

package/front_end/models/heap_snapshot/HeapSnapshotModel.ts

@@ -303,3 +303,17 @@ export interface DominatorNode {
 }
 
 export type DominatorChain = DominatorNode[];
+
+export interface DuplicateStringGroup {
+  value: string;
+  count: number;
+  totalSelfSize: number;
+  totalRetainedSize: number;
+  nodes: Array<{
+    id: number,
+    selfSize: number,
+    retainedSize: number,
+    distance: number,
+  }>;
+  truncated?: boolean;
+}

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -272,6 +272,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('aggregatesWithFilter', filter);
   }
 
+  getDuplicateStrings(): Promise<HeapSnapshotModel.DuplicateStringGroup[]> {
+    return this.callMethodPromise('getDuplicateStrings');
+  }
+
   aggregatesForDiff(interfaceDefinitions: string): Promise<Record<string, HeapSnapshotModel.AggregateForDiff>> {
     return this.callMethodPromise('aggregatesForDiff', interfaceDefinitions);
   }

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -8402,6 +8402,10 @@ export const NativeFunctions = [
     name: "getPathData",
     signatures: [["?settings"]]
   },
+  {
+    name: "setPathData",
+    signatures: [["pathData"]]
+  },
   {
     name: "ByteLengthQueuingStrategy",
     signatures: [["init"]]

package/front_end/models/persistence/NetworkPersistenceManager.ts

@@ -888,6 +888,10 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
   }
 
   handleHeaderInterception(interceptedRequest: SDK.NetworkManager.InterceptedRequest): Protocol.Fetch.HeaderEntry[] {
+    if (NetworkPersistenceManager.isForbiddenNetworkUrl(interceptedRequest.request.url as
+                                                        Platform.DevToolsPath.UrlString)) {
+      return [];
+    }
     let result: Protocol.Fetch.HeaderEntry[] = interceptedRequest.responseHeaders || [];
     // 'rawPathFromUrl()''s return value is already (singly-)encoded, so we can
     // treat it as an 'EncodedPathString' here.
@@ -914,8 +918,12 @@ export class NetworkPersistenceManager extends Common.ObjectWrapper.ObjectWrappe
     if (!this.#active || (method === 'OPTIONS')) {
       return;
     }
+    const requestUrl = interceptedRequest.request.url as Platform.DevToolsPath.UrlString;
+    if (NetworkPersistenceManager.isForbiddenNetworkUrl(requestUrl)) {
+      return;
+    }
     const proj = this.#project as FileSystem;
-    const path = this.fileUrlFromNetworkUrl(interceptedRequest.request.url as Platform.DevToolsPath.UrlString);
+    const path = this.fileUrlFromNetworkUrl(requestUrl);
     const fileSystemUISourceCode = proj.uiSourceCodeForURL(path);
     let responseHeaders = this.handleHeaderInterception(interceptedRequest);
     if (!fileSystemUISourceCode && !responseHeaders.length) {

package/front_end/panels/ai_assistance/components/ChatMessage.ts

@@ -223,10 +223,6 @@ const UIStringsNotTranslate = {
    * @description Accessible label for the reveal button in the render-blocking requests widget.
    */
   revealRenderBlockingBreakdown: 'Reveal render-blocking requests',
-  /**
-   * @description Accessible label for the reveal button in the LCP element widget.
-   */
-  revealLcpElement: 'Reveal LCP element',
   /**
    * @description Accessible label for the reveal button in the performance summary widget.
    */
@@ -291,10 +287,6 @@ const UIStringsNotTranslate = {
    * @description Title for the 3rd parties widget.
    */
   thirdParties: '3rd parties',
-  /**
-   * @description Title for the LCP element widget.
-   */
-  lcpElement: 'LCP element',
   /**
    * @description Title for the performance summary widget.
    */
@@ -987,7 +979,7 @@ interface WidgetMakerResponse {
   // Can be null if the widget is only used to add the Reveal CTA.
   title: Lit.LitTemplate|Platform.UIString.LocalizedString|null;
   jslogContext?: string;
-  accessibleRevealLabel: string;
+  accessibleRevealLabel: Platform.UIString.LocalizedString;
 }
 
 const nodeCache = new Map<Protocol.DOM.BackendNodeId, SDK.DOMModel.DOMNode>();
@@ -1620,8 +1612,8 @@ async function makeDomTreeWidget(widgetData: DomTreeAiWidget): Promise<WidgetMak
   return {
     renderedWidget,
     revealable: new SDK.DOMModel.DeferredDOMNode(root.domModel().target(), root.backendNodeId()),
-    accessibleRevealLabel: lockedString(UIStringsNotTranslate.revealLcpElement),
-    title: lockedString(UIStringsNotTranslate.lcpElement),
+    accessibleRevealLabel: widgetData.data.accessibleRevealLabel,
+    title: widgetData.data.title,
     jslogContext: 'dom-snapshot',
   };
 }