chrome-devtools-frontend 1.0.1717196 → 1.0.1721762

package/front_end/generated/protocol-mapping.d.ts

@@ -1180,6 +1180,7 @@ export namespace ProtocolMapping {
     /**
      * Trigger autofill on a form identified by the fieldId.
      * If the field and related form cannot be autofilled, returns an error.
+     * Returns once the values have been applied to the form fields.
      */
     'Autofill.trigger': {
       paramsType: [Protocol.Autofill.TriggerRequest];

package/front_end/generated/protocol-proxy-api.d.ts

@@ -446,6 +446,7 @@ declare namespace ProtocolProxyApi {
     /**
      * Trigger autofill on a form identified by the fieldId.
      * If the field and related form cannot be autofilled, returns an error.
+     * Returns once the values have been applied to the form fields.
      */
     invoke_trigger(params: Protocol.Autofill.TriggerRequest): Promise<Protocol.ProtocolResponseWithError>;
 

package/front_end/generated/protocol.ts

@@ -2679,9 +2679,10 @@ export namespace Browser {
 
   export interface AddMockCameraRequest {
     /**
-     * Required non-empty identifier for the mock camera. This is mapped to an
-     * internal virtual-device identifier and is not the MediaDeviceInfo.deviceId
-     * exposed to the page.
+     * Required non-empty identifier for the mock camera within the current
+     * DevTools session. Different sessions can use the same identifier
+     * without replacing each other's cameras. This is not the
+     * MediaDeviceInfo.deviceId exposed to the page.
      */
     deviceId: string;
   }
@@ -12304,6 +12305,7 @@ export namespace Network {
     RefreshedAsWaiter = 'RefreshedAsWaiter',
     TransientSigningError = 'TransientSigningError',
     InScopeRefreshNotYetNeeded = 'InScopeRefreshNotYetNeeded',
+    Canceled = 'Canceled',
   }
 
   /**
@@ -14848,6 +14850,7 @@ export namespace Page {
     SyncXhr = 'sync-xhr',
     Tools = 'tools',
     Translator = 'translator',
+    UnboundedElement = 'unbounded-element',
     Unload = 'unload',
     Usb = 'usb',
     UsbUnrestricted = 'usb-unrestricted',

package/front_end/models/{ai_assistance → ai-utils}/AiHistoryStorage.ts

@@ -6,8 +6,6 @@
 import * as Common from '../../core/common/common.js';
 import * as Root from '../../core/root/root.js';
 
-import {ResponseType, type SerializedResponseData} from './agents/AiAgent.js';
-
 export const enum ConversationType {
   NONE = 'none',
   STYLING = 'freestyler',
@@ -18,10 +16,13 @@ export const enum ConversationType {
   STORAGE = 'storage',
 }
 
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type SerializedResponseItem = Record<string, any>;
+
 export interface SerializedConversation {
   id: string;
   type: ConversationType;
-  history: SerializedResponseData[];
+  history: SerializedResponseItem[];
 }
 
 export interface SerializedImage {
@@ -108,9 +109,9 @@ export class AiHistoryStorage extends Common.ObjectWrapper.ObjectWrapper<EventTy
     return structuredClone(this.#recentPromptsSetting.get());
   }
 
-  #getImageIdsFromHistory(history: SerializedResponseData[]): string[] {
+  #getImageIdsFromHistory(history: SerializedResponseItem[]): string[] {
     return history.flatMap(item => {
-      if (item.type === ResponseType.USER_QUERY && item.imageId) {
+      if (item.type === 'user-query' && typeof item.imageId === 'string' && item.imageId) {
         return [item.imageId];
       }
       return [];

package/front_end/models/{ai_assistance → ai-utils}/AiUtils.ts

@@ -5,10 +5,19 @@
 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 type * as Platform from '../../core/platform/platform.js';
 import * as Root from '../../core/root/root.js';
 
 import {debugLog} from './debug.js';
 
+/**
+ * The Google legal troubleshooter form that users are sent to when they
+ * report a legal issue with AI generated content.
+ */
+export const REPORT_LEGAL_ISSUE_URL =
+    'https://support.google.com/legal/troubleshooter/1114905?hl=en#ts=1115658%2C13380504' as
+    Platform.DevToolsPath.UrlString;
+
 export const enum DisabledReason {
   GEO_RESTRICTED = 'geo-restricted',
   POLICY_RESTRICTED = 'policy-restricted',
@@ -126,6 +135,10 @@ export function isNaturalLanguageInterfaceEnabled(): boolean {
   return Boolean(Root.Runtime.hostConfig.devToolsAiNaturalLanguageInterface?.enabled);
 }
 
+export function isAiV2Enabled(): boolean {
+  return Boolean(Root.Runtime.hostConfig.devToolsAiV2Architecture?.enabled);
+}
+
 /**
  * Returns true if context selection / dynamic context switching is enabled.
  *
@@ -138,8 +151,7 @@ export function isNaturalLanguageInterfaceEnabled(): boolean {
  * removed in the future when V2 ships permanently and the V1 architecture is removed.
  */
 export function isContextSelectionEnabled(): boolean {
-  return Boolean(Root.Runtime.hostConfig.devToolsAiAssistanceContextSelectionAgent?.enabled) ||
-      Boolean(Root.Runtime.hostConfig.devToolsAiV2Architecture?.enabled);
+  return Boolean(Root.Runtime.hostConfig.devToolsAiAssistanceContextSelectionAgent?.enabled) || isAiV2Enabled();
 }
 
 /**

package/front_end/models/{ai_assistance → ai-utils}/BuiltInAi.ts

@@ -1,4 +1,4 @@
-// Copyright 2025 The Chromium Authors. All rights reserved.
+// Copyright 2025 The Chromium Authors
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 

package/front_end/models/ai-utils/ai-utils.ts

@@ -0,0 +1,17 @@
+// 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 AiHistoryStorage from './AiHistoryStorage.js';
+import * as AiSetting from './AiSetting.js';
+import * as AiUtils from './AiUtils.js';
+import * as BuiltInAi from './BuiltInAi.js';
+import * as Debug from './debug.js';
+
+export {
+  AiHistoryStorage,
+  AiSetting,
+  AiUtils,
+  BuiltInAi,
+  Debug,
+};

package/front_end/models/ai_assistance/AiAgent2.ts

@@ -5,6 +5,7 @@
 import * as Host from '../../core/host/host.js';
 import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
+import * as AiUtils from '../ai-utils/ai-utils.js';
 import type * as LHModel from '../lighthouse/lighthouse.js';
 import type * as Trace from '../trace/trace.js';
 
@@ -23,7 +24,6 @@ import {ChangeManager} from './ChangeManager.js';
 import {DOMNodeContext} from './contexts/DOMNodeContext.js';
 import {LighthouseContext} from './contexts/LighthouseContext.js';
 import {PerformanceTraceContext} from './contexts/PerformanceTraceContext.js';
-import {debugLog} from './debug.js';
 import {ExtensionScope} from './ExtensionScope.js';
 import type {Skill, SkillName} from './skills/Skill.js';
 import {SKILLS} from './skills/SkillRegistry.js';
@@ -36,6 +36,8 @@ import {
 } from './tools/Tool.js';
 import {ToolRegistry} from './tools/ToolRegistry.js';
 
+const {debugLog} = AiUtils.Debug;
+
 const SKILL_DISPLAY_NAMES: Record<SkillName, string> = {
   styling: 'CSS and styling',
   network: 'Network requests',
@@ -82,7 +84,7 @@ export interface AiAgent2Options extends ExecuteJsAgentOptions {
    * Supplies the origin lock state for the conversation.
    */
   originLock: () => OriginLockState;
-  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
   performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
 }
 
@@ -201,8 +203,7 @@ export class AiAgent2 extends AiAgent<unknown> {
   #changes: ChangeManager;
   #execJs: typeof executeJsCode;
   readonly #originLock: () => OriginLockState;
-  readonly #lighthouseRecording?:
-      (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  readonly #lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
   readonly #performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
 
   get options(): RequestOptions {
@@ -297,8 +298,15 @@ export class AiAgent2 extends AiAgent<unknown> {
         };
       },
       handler: async args => {
+        const previouslyLoaded = new Set(this.#activeSkills);
         const result = await this.learnSkill(args.skills);
-        return {result};
+        // The LLM may hallucinate skill names. Filter out any skills that were not newly activated.
+        const loadedSkills =
+            [...new Set(args.skills)].filter(skill => !previouslyLoaded.has(skill) && this.#activeSkills.has(skill));
+        return {
+          result,
+          loadedSkills: loadedSkills.length > 0 ? loadedSkills : undefined,
+        };
       },
     });
   }
@@ -443,7 +451,7 @@ User query: ${enhancedQuery}`;
           getTarget: () => this.#getTarget(),
           getOriginLock: () => this.#originLock(),
           getLighthouseReport: () => (this.context instanceof LighthouseContext ? this.context.getItem() : null),
-          runLighthouse: async overrides => await (this.#lighthouseRecording?.(overrides) ?? null),
+          runLighthouse: async overrides => await (this.#lighthouseRecording?.(overrides) ?? {status: 'failed'}),
           getPerformanceTraceContext: () => (this.context instanceof PerformanceTraceContext ? this.context : null),
           performanceRecordAndReload: this.#performanceRecordAndReload,
           disableLogging: () => {

package/front_end/models/ai_assistance/AiConversation.ts

@@ -8,6 +8,7 @@ import * as Root from '../../core/root/root.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as LHModel from '../../models/lighthouse/lighthouse.js';
 import type * as Trace from '../../models/trace/trace.js';
+import * as AiUtils from '../ai-utils/ai-utils.js';
 import type * as NetworkTimeCalculator from '../network_time_calculator/network_time_calculator.js';
 
 import {AccessibilityAgent} from './agents/AccessibilityAgent.js';
@@ -21,6 +22,7 @@ import {
   type MultimodalInput,
   type ResponseData,
   ResponseType,
+  type SerializedResponseData,
   type UserQuery,
 } from './agents/AiAgent.js';
 import {ContextSelectionAgent} from './agents/ContextSelectionAgent.js';
@@ -30,8 +32,7 @@ import {PerformanceAgent} from './agents/PerformanceAgent.js';
 import {StorageAgent} from './agents/StorageAgent.js';
 import {StylingAgent} from './agents/StylingAgent.js';
 import {AiAgent2} from './AiAgent2.js';
-import {AiHistoryStorage, ConversationType, type SerializedConversation} from './AiHistoryStorage.js';
-import {isContextSelectionEnabled} from './AiUtils.js';
+import type {AlwaysAllowedTools} from './AlwaysAllowedTools.js';
 import type {ChangeManager} from './ChangeManager.js';
 import {DOMNodeContext} from './contexts/DOMNodeContext.js';
 import {FileContext} from './contexts/FileContext.js';
@@ -42,6 +43,10 @@ import {StorageContext} from './contexts/StorageContext.js';
 import {type OriginLockState, ToolAnnotation} from './tools/Tool.js';
 import {ToolRegistry} from './tools/ToolRegistry.js';
 
+type AiHistoryStorage = AiUtils.AiHistoryStorage.AiHistoryStorage;
+type ConversationType = AiUtils.AiHistoryStorage.ConversationType;
+type SerializedConversation = AiUtils.AiHistoryStorage.SerializedConversation;
+
 export const NOT_FOUND_IMAGE_DATA = '';
 export const CONTEXT_TITLE = 'Analyzing data';
 const MAX_TITLE_LENGTH = 80;
@@ -74,14 +79,15 @@ export interface AiConversationOptions {
   performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
   onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
   networkTimeCalculator?: NetworkTimeCalculator.NetworkTransferTimeCalculator;
-  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
   aiHistoryStorage?: AiHistoryStorage;
+  alwaysAllowedTools?: AlwaysAllowedTools;
   targetManager?: SDK.TargetManager.TargetManager;
 }
 
 export class AiConversation {
   static fromSerializedConversation(serializedConversation: SerializedConversation): AiConversation {
-    const history = serializedConversation.history.map(entry => {
+    const history = (serializedConversation.history as SerializedResponseData[]).map(entry => {
       if (entry.type === ResponseType.SIDE_EFFECT) {
         return {...entry, confirm: () => {}};
       }
@@ -112,11 +118,12 @@ export class AiConversation {
   #contexts: Array<ConversationContext<unknown>> = [];
 
   #performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
-  #lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  #lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
   #onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
   #networkTimeCalculator?: NetworkTimeCalculator.NetworkTransferTimeCalculator;
   readonly #aiHistoryStorage: AiHistoryStorage;
   readonly #targetManager: SDK.TargetManager.TargetManager;
+  readonly #alwaysAllowedTools?: AlwaysAllowedTools;
 
   constructor(options: AiConversationOptions) {
     const {
@@ -130,9 +137,10 @@ export class AiConversation {
       onInspectElement,
       networkTimeCalculator,
       lighthouseRecording,
-      aiHistoryStorage = AiHistoryStorage.instance(),
+      aiHistoryStorage = AiUtils.AiHistoryStorage.AiHistoryStorage.instance(),
       // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
       targetManager = SDK.TargetManager.TargetManager.instance(),
+      alwaysAllowedTools,
     } = options;
     this.#changeManager = changeManager;
     this.#aidaClient = aidaClient;
@@ -142,6 +150,7 @@ export class AiConversation {
     this.#lighthouseRecording = lighthouseRecording;
     this.#aiHistoryStorage = aiHistoryStorage;
     this.#targetManager = targetManager;
+    this.#alwaysAllowedTools = alwaysAllowedTools;
 
     this.id = id;
     this.#isReadOnly = isReadOnly;
@@ -155,7 +164,8 @@ export class AiConversation {
   }
 
   static titleForSerialized(serialized: SerializedConversation): string|undefined {
-    const query = serialized.history.find(item => item.type === ResponseType.USER_QUERY)?.query;
+    const query =
+        (serialized.history as SerializedResponseData[]).find(item => item.type === ResponseType.USER_QUERY)?.query;
     if (!query) {
       return undefined;
     }
@@ -189,8 +199,8 @@ export class AiConversation {
   setContext(updateContext: ConversationContext<unknown>|null): void {
     if (!updateContext) {
       this.#contexts = [];
-      if (isContextSelectionEnabled()) {
-        this.#updateAgent(ConversationType.NONE);
+      if (AiUtils.AiUtils.isContextSelectionEnabled()) {
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.NONE);
       }
 
       return;
@@ -198,19 +208,19 @@ export class AiConversation {
 
     this.#contexts = [updateContext];
 
-    if (isContextSelectionEnabled()) {
+    if (AiUtils.AiUtils.isContextSelectionEnabled()) {
       if (updateContext instanceof FileContext) {
-        this.#updateAgent(ConversationType.FILE);
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.FILE);
       } else if (updateContext instanceof DOMNodeContext) {
-        this.#updateAgent(ConversationType.STYLING);
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.STYLING);
       } else if (updateContext instanceof RequestContext) {
-        this.#updateAgent(ConversationType.NETWORK);
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.NETWORK);
       } else if (updateContext instanceof PerformanceTraceContext) {
-        this.#updateAgent(ConversationType.PERFORMANCE);
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.PERFORMANCE);
       } else if (updateContext instanceof LighthouseContext) {
-        this.#updateAgent(ConversationType.ACCESSIBILITY);
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.ACCESSIBILITY);
       } else if (updateContext instanceof StorageContext) {
-        this.#updateAgent(ConversationType.STORAGE);
+        this.#updateAgent(AiUtils.AiHistoryStorage.ConversationType.STORAGE);
       }
     }
   }
@@ -337,6 +347,7 @@ export class AiConversation {
                            ...item,
                            output: shouldRedact ? '<redacted>' : item.output,
                            widgets: undefined,
+                           loadedSkills: undefined,
                          };
                        }
                        default:
@@ -379,7 +390,8 @@ export class AiConversation {
     // In legacy V1 architecture, agents are recreated when switching conversation types.
     // Discard conversation history when transitioning away from Storage to prevent
     // sensitive data (e.g. cookies or storage items) from leaking into subsequent agent queries.
-    const isTransitioningFromStorage = previousType === ConversationType.STORAGE && type !== ConversationType.STORAGE;
+    const isTransitioningFromStorage = previousType === AiUtils.AiHistoryStorage.ConversationType.STORAGE &&
+        type !== AiUtils.AiHistoryStorage.ConversationType.STORAGE;
     const history = isTransitioningFromStorage ? [] : this.#filterHistoryForNewAgent();
 
     const baseOptions = {
@@ -393,6 +405,7 @@ export class AiConversation {
       lighthouseRecording: this.#lighthouseRecording,
       history,
       targetManager: this.#targetManager,
+      alwaysAllowedTools: this.#alwaysAllowedTools,
     };
 
     this.#agent = Root.Runtime.hostConfig.devToolsAiV2Architecture?.enabled ? new AiAgent2({
@@ -407,19 +420,19 @@ export class AiConversation {
 
   #createV1Agent(type: ConversationType, options: AgentOptions): AiAgent<unknown> {
     switch (type) {
-      case ConversationType.STYLING:
+      case AiUtils.AiHistoryStorage.ConversationType.STYLING:
         return new StylingAgent(options);
-      case ConversationType.NETWORK:
+      case AiUtils.AiHistoryStorage.ConversationType.NETWORK:
         return new NetworkAgent(options);
-      case ConversationType.FILE:
+      case AiUtils.AiHistoryStorage.ConversationType.FILE:
         return new FileAgent(options);
-      case ConversationType.PERFORMANCE:
+      case AiUtils.AiHistoryStorage.ConversationType.PERFORMANCE:
         return new PerformanceAgent(options);
-      case ConversationType.ACCESSIBILITY:
+      case AiUtils.AiHistoryStorage.ConversationType.ACCESSIBILITY:
         return new AccessibilityAgent(options);
-      case ConversationType.STORAGE:
+      case AiUtils.AiHistoryStorage.ConversationType.STORAGE:
         return new StorageAgent(options);
-      case ConversationType.NONE:
+      case AiUtils.AiHistoryStorage.ConversationType.NONE:
         return new ContextSelectionAgent(options);
       default:
         Platform.assertNever(type, 'Unknown conversation type');

package/front_end/models/ai_assistance/AlwaysAllowedTools.ts

@@ -0,0 +1,107 @@
+// 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 Common from '../../core/common/common.js';
+import * as AiUtils from '../ai-utils/ai-utils.js';
+
+import type {ToolName} from './tools/Tool.js';
+
+/**
+ * AI tools the user allowed with "Yes, always allow".
+ */
+export const alwaysAllowedToolsSettingDescriptor: Common.Settings.SettingDescriptor<ToolName[]> = {
+  name: 'ai-assistance-always-allowed-tools',
+  type: Common.Settings.SettingType.ARRAY,
+  defaultValue: [],
+};
+
+export const enum Events {
+  TOOLS_CHANGED = 'ToolsChanged',
+}
+
+export interface EventTypes {
+  [Events.TOOLS_CHANGED]: void;
+}
+
+export class AlwaysAllowedTools extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  readonly #impl: Impl;
+
+  constructor(settings: Common.Settings.Settings) {
+    super();
+    const onChange = (): void => this.dispatchEventToListeners(Events.TOOLS_CHANGED);
+    this.#impl =
+        AiUtils.AiUtils.isNaturalLanguageInterfaceEnabled() ? new SettingImpl(settings, onChange) : new DisabledImpl();
+  }
+
+  isAllowed(toolName: ToolName): boolean {
+    return this.#impl.isAllowed(toolName);
+  }
+
+  allow(toolName: ToolName): void {
+    this.#impl.allow(toolName);
+  }
+
+  remove(toolName: ToolName): void {
+    this.#impl.remove(toolName);
+  }
+
+  list(): readonly ToolName[] {
+    return this.#impl.list();
+  }
+}
+
+interface Impl {
+  isAllowed(toolName: ToolName): boolean;
+  allow(toolName: ToolName): void;
+  remove(toolName: ToolName): void;
+  list(): readonly ToolName[];
+}
+
+/**
+ * Actual implementation.
+ */
+class SettingImpl implements Impl {
+  readonly #setting: Common.Settings.Setting<ToolName[]>;
+
+  constructor(settings: Common.Settings.Settings, onChange: () => void) {
+    this.#setting = settings.resolve(alwaysAllowedToolsSettingDescriptor);
+    this.#setting.addChangeListener(onChange);
+  }
+
+  isAllowed(toolName: ToolName): boolean {
+    return this.#setting.get().includes(toolName);
+  }
+
+  allow(toolName: ToolName): void {
+    this.#setting.set([...new Set([...this.#setting.get(), toolName])]);
+  }
+
+  remove(toolName: ToolName): void {
+    const toolNames = this.#setting.get().filter(tn => tn !== toolName);
+    this.#setting.set([...new Set(toolNames)]);
+  }
+
+  list(): readonly ToolName[] {
+    return [...new Set(this.#setting.get())];
+  }
+}
+
+/**
+ * Fake implementation when natural language interface is disabled.
+ */
+class DisabledImpl implements Impl {
+  isAllowed(): boolean {
+    return false;
+  }
+
+  allow(): void {
+  }
+
+  remove(): void {
+  }
+
+  list(): readonly ToolName[] {
+    return [];
+  }
+}

package/front_end/models/ai_assistance/ConversationSummary.ts

@@ -4,8 +4,9 @@
 
 import * as Host from '../../core/host/host.js';
 import * as Root from '../../core/root/root.js';
+import * as AiUtils from '../ai-utils/ai-utils.js';
 
-import {runOneShotPrompt} from './AiUtils.js';
+const {runOneShotPrompt} = AiUtils.AiUtils;
 
 const preamble = `### Role
 You are a Conversation Summarizer. Your task is to take a transcript of a conversation between a user and a DevTools AI agent and produce a succinct, actionable Markdown summary. This summary will be used to help apply fixes in an IDE, so it must capture all relevant technical details, findings, and proposed code changes without any conversational fluff.

package/front_end/models/ai_assistance/PerformanceAnnotations.ts

@@ -4,10 +4,12 @@
 
 import * as Host from '../../core/host/host.js';
 import * as Root from '../../core/root/root.js';
+import * as AiUtils from '../ai-utils/ai-utils.js';
 
-import {runOneShotPrompt} from './AiUtils.js';
 import type {AICallTree} from './performance/AICallTree.js';
 
+const {runOneShotPrompt} = AiUtils.AiUtils;
+
 const callTreePreamble = `You are an expert performance analyst embedded within Chrome DevTools.
 You meticulously examine web application behavior captured by the Chrome DevTools Performance Panel and Chrome tracing.
 You will receive a structured text representation of a call tree, derived from a user-selected call frame within a performance trace's flame chart.

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

@@ -6,10 +6,10 @@ 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 SDK from '../../../core/sdk/sdk.js';
+import * as AiUtils from '../../ai-utils/ai-utils.js';
 import type * as LHModel from '../../lighthouse/lighthouse.js';
 import {ChangeManager} from '../ChangeManager.js';
 import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
-import {debugLog} from '../debug.js';
 import {ExtensionScope} from '../ExtensionScope.js';
 import {
   type OriginLockState,
@@ -31,6 +31,8 @@ import {
   executeJsCode,
 } from './ExecuteJavascript.js';
 
+const {debugLog} = AiUtils.Debug;
+
 /**
  * WARNING: preamble defined in code is only used when userTier is
  * TESTERS. Otherwise, a server-side preamble is used (see
@@ -88,8 +90,7 @@ If the user asks a question that requires an investigation of a problem, use thi
 export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON> {
   readonly preamble: string = preamble;
   readonly clientFeature: Host.AidaClient.ClientFeature = Host.AidaClient.ClientFeature.CHROME_ACCESSIBILITY_AGENT;
-  readonly #lighthouseRecording?:
-      (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  readonly #lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.RunTypes.RunResult>;
 
   #execJs: typeof executeJsCode;
   #changes: ChangeManager;
@@ -300,14 +301,20 @@ export class AccessibilityAgent extends AiAgent<LHModel.ReporterTypes.ReportJSON
         if (!this.#lighthouseRecording) {
           return {error: 'Lighthouse recording is not available.'};
         }
-        const report = await this.#lighthouseRecording({
+        const result = await this.#lighthouseRecording({
           mode: 'snapshot',
           categoryIds: ['accessibility'],
           isAIControlled: true,
         });
-        if (!report) {
+        if (result.status === 'cancelled') {
+          return {
+            error: 'The user cancelled the accessibility audits. Do not run them again unless the user asks you to.',
+          };
+        }
+        if (result.status === 'failed') {
           return {error: 'Failed to run accessibility audits.'};
         }
+        const {report} = result;
         const audits = new LighthouseFormatter().audits(report, 'accessibility');
         return {
           result: {audits},