chrome-devtools-frontend 1.0.1543082 → 1.0.1544076

package/AUTHORS

@@ -18,6 +18,7 @@ Alex Ho <wjhe1016@gmail.com>
 Alexander Stammbach <alexander@stammbach.io>
 Alexey Rodionov <fluorescent.hallucinogen@gmail.com>
 Ameen Basha <ameenbasha111@gmail.com>
+Ankit Kumar Sahu <sahuankit.murhu@gmail.com>
 Ankit Mishra <ankit.mishra131990@gmail.com>
 Anna Agoha <annaagoha@gmail.com>
 Anthony Xie <anthonyxie64@gmail.com>
@@ -68,6 +69,7 @@ Michael Rienstra <mrienstra@gmail.com>
 Mostafa Aboalkasim <mostafa.aboalkasim.offical@gmail.com>
 Muhammad Mahad <mahadtxt@gmail.com>
 Naoto Ono <onoto1998@gmail.com>
+Nourhan Hasan <nourhan.m.hasan@gmail.com>
 Paras Awasthi <awasthiparas6@gmail.com>
 Paul Fisher <paul@pfish.zone>
 Peng Zhou <zhoupeng.1996@bytedance.com>

package/front_end/core/common/Gzip.ts

@@ -5,7 +5,7 @@
 /**
  * Quickly determine if gzipped, by seeing if the first 3 bytes of the file header match the gzip signature
  */
-export function isGzip(ab: ArrayBuffer): boolean {
+export function isGzip(ab: ArrayBufferLike): boolean {
   const buf = new Uint8Array(ab);
   if (!buf || buf.length < 3) {
     return false;
@@ -15,7 +15,7 @@ export function isGzip(ab: ArrayBuffer): boolean {
 }
 
 /** Decode a gzipped _or_ plain text ArrayBuffer to a decoded string */
-export async function arrayBufferToString(ab: ArrayBuffer): Promise<string> {
+export async function arrayBufferToString(ab: ArrayBufferLike): Promise<string> {
   if (isGzip(ab)) {
     return await decompress(ab);
   }
@@ -37,7 +37,7 @@ export async function fileToString(file: File): Promise<string> {
  * Decompress a gzipped ArrayBuffer to a string.
  * Consider using `arrayBufferToString` instead, which can handle both gzipped and plain text buffers.
  */
-export async function decompress(gzippedBuffer: ArrayBuffer): Promise<string> {
+export async function decompress(gzippedBuffer: ArrayBufferLike): Promise<string> {
   const buffer = await gzipCodec(gzippedBuffer, new DecompressionStream('gzip'));
   const str = new TextDecoder('utf-8').decode(buffer);
   return str;
@@ -50,7 +50,7 @@ export async function compress(str: string): Promise<ArrayBuffer> {
 
 /** Private coder/decoder **/
 async function gzipCodec(
-    buffer: Uint8Array<ArrayBufferLike>|ArrayBuffer,
+    buffer: Uint8Array<ArrayBufferLike>|ArrayBufferLike,
     codecStream: CompressionStream|DecompressionStream): Promise<ArrayBuffer> {
   const readable = new ReadableStream({
     start(controller) {

package/front_end/core/common/common.ts

@@ -21,7 +21,6 @@ import * as Mutex from './Mutex.js';
 import * as ObjectWrapper from './Object.js';
 import * as ParsedURL from './ParsedURL.js';
 import * as Progress from './Progress.js';
-import * as QueryParamHandler from './QueryParamHandler.js';
 import * as ResolverBase from './ResolverBase.js';
 import * as ResourceType from './ResourceType.js';
 import * as ReturnToPanel from './ReturnToPanel.js';
@@ -63,7 +62,6 @@ export {
   ObjectWrapper,
   ParsedURL,
   Progress,
-  QueryParamHandler,
   ResolverBase,
   ResourceType,
   ReturnToPanel,

package/front_end/core/host/AidaClient.ts

@@ -707,13 +707,16 @@ export class AidaClient {
     return {generatedSamples, metadata};
   }
 
-  async generateCode(request: GenerateCodeRequest): Promise<GenerateCodeResponse|null> {
-    const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>({
-      service: SERVICE_NAME,
-      path: '/v1/aida:generateCode',
-      method: 'POST',
-      body: JSON.stringify(request),
-    });
+  async generateCode(request: GenerateCodeRequest, options?: {signal?: AbortSignal}):
+      Promise<GenerateCodeResponse|null> {
+    const response = await DispatchHttpRequestClient.makeHttpRequest<GenerateCodeResponse>(
+        {
+          service: SERVICE_NAME,
+          path: '/v1/aida:generateCode',
+          method: 'POST',
+          body: JSON.stringify(request),
+        },
+        options);
 
     return response;
   }

package/front_end/core/host/DispatchHttpRequestClient.ts

@@ -8,6 +8,7 @@ import type {DispatchHttpRequestRequest, DispatchHttpRequestResult} from './Insp
 export enum ErrorType {
   HTTP_RESPONSE_UNAVAILABLE = 'HTTP_RESPONSE_UNAVAILABLE',
   NOT_FOUND = 'NOT_FOUND',
+  ABORT = 'ABORT',
 }
 
 export class DispatchHttpRequestError extends Error {
@@ -16,9 +17,23 @@ export class DispatchHttpRequestError extends Error {
   }
 }
 
-export async function makeHttpRequest<R>(request: DispatchHttpRequestRequest): Promise<R> {
-  const response = await new Promise<DispatchHttpRequestResult>(resolve => {
-    InspectorFrontendHostInstance.dispatchHttpRequest(request, resolve);
+export async function makeHttpRequest<R>(
+    request: DispatchHttpRequestRequest, options?: {signal?: AbortSignal}): Promise<R> {
+  const signal = options?.signal;
+  if (signal?.aborted) {
+    throw new DispatchHttpRequestError(ErrorType.ABORT);
+  }
+
+  const response = await new Promise<DispatchHttpRequestResult>((resolve, reject) => {
+    const onAbort = (): void => {
+      reject(new DispatchHttpRequestError(ErrorType.ABORT));
+    };
+
+    signal?.addEventListener('abort', onAbort, {once: true});
+    InspectorFrontendHostInstance.dispatchHttpRequest(request, result => {
+      signal?.removeEventListener('abort', onAbort);
+      resolve(result);
+    });
   });
 
   debugLog({request, response});

package/front_end/core/root/DevToolsContext.ts

@@ -0,0 +1,60 @@
+// 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.
+
+export type ConstructorT<T> = new (...args: any[]) => T;
+
+/**
+ * Container for singletons scoped to a single DevTools universe.
+ */
+export class DevToolsContext {
+  readonly #instances = new Map<ConstructorT<unknown>, unknown>();
+
+  get<T>(ctor: ConstructorT<T>): T {
+    const instance = this.#instances.get(ctor) as T | undefined;
+    if (!instance) {
+      throw new Error(`No instance for ${ctor.name}. Ensure the bootstrapper creates it.`);
+    }
+    return instance;
+  }
+
+  /** @deprecated Should only be used by existing `instance` accessors. */
+  has<T>(ctor: ConstructorT<T>): boolean {
+    return this.#instances.has(ctor);
+  }
+
+  /**
+   * @deprecated Should only be used by existing `instance` accessors and the bootstrapper.
+   * Exists on the public interface only for migration purposes for now.
+   */
+  set<T>(ctor: ConstructorT<T>, instance: T): void {
+    // TODO(crbug.com/458180550): We need to throw here if an instance was already set!
+    this.#instances.set(ctor, instance);
+  }
+
+  /** @deprecated Should only be used by existing `removeInstance` static methods. */
+  delete<T>(ctor: ConstructorT<T>): void {
+    this.#instances.delete(ctor);
+  }
+}
+
+let gInstance: DevToolsContext|null = null;
+
+/**
+ * @deprecated Exists to migrate instance() methods.
+ */
+export function globalInstance(): DevToolsContext {
+  if (!gInstance) {
+    // TODO(crbug.com/458180550): This should really throw to prevent side-effects and globals
+    //                            from leaking all over the place.
+    gInstance = new DevToolsContext();
+  }
+  return gInstance;
+}
+
+/**
+ * @deprecated Should only be called by test setup and MainImpl
+ */
+export function setGlobalInstance(context: DevToolsContext|null): void {
+  gInstance = context;
+}

package/front_end/core/root/Runtime.ts

@@ -70,21 +70,22 @@ export class Runtime {
     runtimeInstance = undefined;
   }
 
-  static queryParamsObject: URLSearchParams;
+  static #queryParamsObject: URLSearchParams;
 
-  static getSearchParams(): URLSearchParams {
-    if (!Runtime.queryParamsObject) {
-      Runtime.queryParamsObject = new URLSearchParams(location.search);
+  static #getSearchParams(): URLSearchParams|null {
+    // TODO(crbug.com/451502260): Find a more explicit way to support running in Node.js
+    if (!Runtime.#queryParamsObject && 'location' in globalThis) {
+      Runtime.#queryParamsObject = new URLSearchParams(location.search);
     }
-    return Runtime.queryParamsObject;
+    return Runtime.#queryParamsObject;
   }
 
   static queryParam(name: string): string|null {
-    return Runtime.getSearchParams().get(name);
+    return Runtime.#getSearchParams()?.get(name) ?? null;
   }
 
   static setQueryParamForTesting(name: string, value: string): void {
-    Runtime.getSearchParams().set(name, value);
+    Runtime.#getSearchParams()?.set(name, value);
   }
 
   static isNode(): boolean {

package/front_end/core/root/root.ts

@@ -1,6 +1,11 @@
 // Copyright 2020 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 DevToolsContext from './DevToolsContext.js';
 import * as Runtime from './Runtime.js';
 
-export {Runtime};
+export {
+  DevToolsContext,
+  Runtime,
+};

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -184,10 +184,6 @@ export interface EventTypes {
   [Events.HARDWARE_CONCURRENCY_CHANGED]: number;
 }
 
-export function throttlingManager(): CPUThrottlingManager {
-  return CPUThrottlingManager.instance();
-}
-
 export enum CPUThrottlingRates {
   NO_THROTTLING = 1,
   MID_TIER_MOBILE = 4,

package/front_end/core/sdk/CSSMatchedStyles.ts

@@ -41,7 +41,7 @@ import {
   VariableMatcher
 } from './CSSPropertyParserMatchers.js';
 import {
-  CSSFontPaletteValuesRule,
+  CSSAtRule,
   CSSFunctionRule,
   CSSKeyframeRule,
   CSSKeyframesRule,
@@ -210,7 +210,7 @@ export interface CSSMatchedStylesPayload {
   positionTryRules: Protocol.CSS.CSSPositionTryRule[];
   propertyRules: Protocol.CSS.CSSPropertyRule[];
   cssPropertyRegistrations: Protocol.CSS.CSSPropertyRegistration[];
-  fontPaletteValuesRule: Protocol.CSS.CSSFontPaletteValuesRule|undefined;
+  atRules: Protocol.CSS.CSSAtRule[];
   animationStylesPayload: Protocol.CSS.CSSAnimationStyle[];
   transitionsStylePayload: Protocol.CSS.CSSStyle|null;
   inheritedAnimatedPayload: Protocol.CSS.InheritedAnimatedStyleEntry[];
@@ -305,8 +305,8 @@ export class CSSMatchedStyles {
   #pseudoDOMCascades?: Map<Protocol.DOM.PseudoType, DOMInheritanceCascade>;
   #customHighlightPseudoDOMCascades?: Map<string, DOMInheritanceCascade>;
   #functionRules: CSSFunctionRule[];
+  #atRules: CSSAtRule[];
   #functionRuleMap = new Map<string, CSSFunctionRule>();
-  readonly #fontPaletteValuesRule: CSSFontPaletteValuesRule|undefined;
   #environmentVariables: Record<string, string> = {};
 
   static async create(payload: CSSMatchedStylesPayload): Promise<CSSMatchedStyles> {
@@ -323,9 +323,9 @@ export class CSSMatchedStyles {
     positionTryRules,
     propertyRules,
     cssPropertyRegistrations,
-    fontPaletteValuesRule,
     activePositionFallbackIndex,
     functionRules,
+    atRules,
   }: CSSMatchedStylesPayload) {
     this.#cssModel = cssModel;
     this.#node = node;
@@ -338,11 +338,9 @@ export class CSSMatchedStyles {
     }
     this.#positionTryRules = positionTryRules.map(rule => new CSSPositionTryRule(cssModel, rule));
     this.#parentLayoutNodeId = parentLayoutNodeId;
-    this.#fontPaletteValuesRule =
-        fontPaletteValuesRule ? new CSSFontPaletteValuesRule(cssModel, fontPaletteValuesRule) : undefined;
-
     this.#activePositionFallbackIndex = activePositionFallbackIndex;
     this.#functionRules = functionRules.map(rule => new CSSFunctionRule(cssModel, rule));
+    this.#atRules = atRules.map(rule => new CSSAtRule(cssModel, rule));
   }
 
   private async init({
@@ -799,8 +797,8 @@ export class CSSMatchedStyles {
     return this.#functionRules;
   }
 
-  fontPaletteValuesRule(): CSSFontPaletteValuesRule|undefined {
-    return this.#fontPaletteValuesRule;
+  atRules(): CSSAtRule[] {
+    return this.#atRules;
   }
 
   keyframes(): CSSKeyframesRule[] {

package/front_end/core/sdk/CSSModel.ts

@@ -358,7 +358,7 @@ export class CSSModel extends SDKModel<EventTypes> {
       propertyRules: matchedStylesResponse.cssPropertyRules ?? [],
       functionRules: matchedStylesResponse.cssFunctionRules ?? [],
       cssPropertyRegistrations: matchedStylesResponse.cssPropertyRegistrations ?? [],
-      fontPaletteValuesRule: matchedStylesResponse.cssFontPaletteValuesRule,
+      atRules: matchedStylesResponse.cssAtRules ?? [],
       activePositionFallbackIndex: matchedStylesResponse.activePositionFallbackIndex ?? -1,
       animationStylesPayload: animatedStylesResponse?.animationStyles || [],
       inheritedAnimatedPayload: animatedStylesResponse?.inherited || [],

package/front_end/core/sdk/CSSRule.ts

@@ -268,20 +268,32 @@ export class CSSPropertyRule extends CSSRule {
   }
 }
 
-export class CSSFontPaletteValuesRule extends CSSRule {
-  readonly #paletteName: CSSValue;
-  constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSFontPaletteValuesRule) {
+export class CSSAtRule extends CSSRule {
+  readonly #name: CSSValue|null;
+  readonly #type: string;
+  readonly #subsection: string|null;
+  constructor(cssModel: CSSModel, payload: Protocol.CSS.CSSAtRule) {
     super(cssModel, {
       origin: payload.origin,
       style: payload.style,
       header: styleSheetHeaderForRule(cssModel, payload),
       originTreeScopeNodeId: undefined
     });
-    this.#paletteName = new CSSValue(payload.fontPaletteName);
+    this.#name = payload.name ? new CSSValue(payload.name) : null;
+    this.#type = payload.type;
+    this.#subsection = payload.subsection ?? null;
   }
 
-  name(): CSSValue {
-    return this.#paletteName;
+  name(): CSSValue|null {
+    return this.#name;
+  }
+
+  type(): string {
+    return this.#type;
+  }
+
+  subsection(): string|null {
+    return this.#subsection;
   }
 }
 

package/front_end/core/sdk/ChildTargetManager.ts

@@ -13,7 +13,7 @@ import {SDKModel} from './SDKModel.js';
 import {SecurityOriginManager} from './SecurityOriginManager.js';
 import {StorageKeyManager} from './StorageKeyManager.js';
 import {Capability, type Target, Type} from './Target.js';
-import {Events as TargetManagerEvents, TargetManager} from './TargetManager.js';
+import {Events as TargetManagerEvents, type TargetManager} from './TargetManager.js';
 
 const UIStrings = {
   /**
@@ -126,7 +126,7 @@ export class ChildTargetManager extends SDKModel<EventTypes> implements Protocol
   }
 
   private fireAvailableTargetsChanged(): void {
-    TargetManager.instance().dispatchEventToListeners(
+    this.#targetManager.dispatchEventToListeners(
         TargetManagerEvents.AVAILABLE_TARGETS_CHANGED, [...this.#targetInfos.values()]);
   }
 

package/front_end/core/sdk/TargetManager.ts

@@ -13,7 +13,6 @@ import * as Root from '../root/root.js';
 import {SDKModel} from './SDKModel.js';
 import {Target, Type as TargetType} from './Target.js';
 
-let targetManagerInstance: TargetManager|undefined;
 type ModelClass<T = SDKModel> = new (arg1: Target) => T;
 
 export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
@@ -35,7 +34,7 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   #defaultScopeSet: boolean;
   readonly #scopeChangeListeners: Set<() => void>;
 
-  private constructor() {
+  constructor() {
     super();
     this.#targets = new Set();
     this.#observers = new Set();
@@ -52,15 +51,15 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   static instance({forceNew}: {
     forceNew: boolean,
   } = {forceNew: false}): TargetManager {
-    if (!targetManagerInstance || forceNew) {
-      targetManagerInstance = new TargetManager();
+    if (!Root.DevToolsContext.globalInstance().has(TargetManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(TargetManager, new TargetManager());
     }
 
-    return targetManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(TargetManager);
   }
 
   static removeInstance(): void {
-    targetManagerInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(TargetManager);
   }
 
   onInspectedURLChange(target: Target): void {

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshotLoader.ts

@@ -46,6 +46,8 @@ export class HeapSnapshotLoader {
   }
 
   async buildSnapshot(secondWorker: MessagePort): Promise<JSHeapSnapshot> {
+    await this.parsingComplete;
+
     this.#snapshot = this.#snapshot || {};
 
     this.#progress.updateStatus('Processing snapshot…');

package/front_end/entrypoints/inspector_main/InspectorMain.ts

@@ -46,20 +46,8 @@ const UIStrings = {
 } as const;
 const str_ = i18n.i18n.registerUIStrings('entrypoints/inspector_main/InspectorMain.ts', UIStrings);
 const i18nString = i18n.i18n.getLocalizedString.bind(undefined, str_);
-let inspectorMainImplInstance: InspectorMainImpl;
 
 export class InspectorMainImpl implements Common.Runnable.Runnable {
-  static instance(opts: {
-    forceNew: boolean|null,
-  } = {forceNew: null}): InspectorMainImpl {
-    const {forceNew} = opts;
-    if (!inspectorMainImplInstance || forceNew) {
-      inspectorMainImplInstance = new InspectorMainImpl();
-    }
-
-    return inspectorMainImplInstance;
-  }
-
   async run(): Promise<void> {
     let firstCall = true;
     await SDK.Connections.initMainConnection(async () => {
@@ -162,7 +150,7 @@ export class InspectorMainImpl implements Common.Runnable.Runnable {
   }
 }
 
-Common.Runnable.registerEarlyInitializationRunnable(InspectorMainImpl.instance);
+Common.Runnable.registerEarlyInitializationRunnable(() => new InspectorMainImpl());
 
 export class ReloadActionDelegate implements UI.ActionRegistration.ActionDelegate {
   handleAction(_context: UI.Context.Context, actionId: string): boolean {

package/front_end/entrypoints/main/MainImpl.ts

@@ -175,7 +175,8 @@ export class MainImpl {
         runSettingsMigration: !Host.InspectorFrontendHost.isUnderTest(),
       },
     };
-    new Foundation.Universe.Universe(creationOptions);
+    const universe = new Foundation.Universe.Universe(creationOptions);
+    Root.DevToolsContext.setGlobalInstance(universe.context);
 
     await this.requestAndRegisterLocaleData();
 
@@ -445,28 +446,9 @@ export class MainImpl {
         SDK.TargetManager.Events.SUSPEND_STATE_CHANGED, this.#onSuspendStateChanged.bind(this));
 
     Workspace.FileManager.FileManager.instance({forceNew: true});
-    Workspace.Workspace.WorkspaceImpl.instance();
 
     Bindings.NetworkProject.NetworkProjectManager.instance();
-    const resourceMapping = new Bindings.ResourceMapping.ResourceMapping(
-        targetManager,
-        Workspace.Workspace.WorkspaceImpl.instance(),
-    );
     new Bindings.PresentationConsoleMessageHelper.PresentationConsoleMessageManager();
-    Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding.instance({
-      forceNew: true,
-      resourceMapping,
-      targetManager,
-    });
-    Workspace.IgnoreListManager.IgnoreListManager.instance({
-      forceNew: true,
-    });
-    Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding.instance({
-      forceNew: true,
-      resourceMapping,
-      targetManager,
-      ignoreListManager: Workspace.IgnoreListManager.IgnoreListManager.instance(),
-    });
     targetManager.setScopeTarget(targetManager.primaryPageTarget());
     UI.Context.Context.instance().addFlavorChangeListener(SDK.Target.Target, ({data}) => {
       const outermostTarget = data?.outermostTarget();

package/front_end/foundation/Universe.ts

@@ -3,6 +3,10 @@
 // found in the LICENSE file.
 
 import * as Common from '../core/common/common.js';
+import * as Root from '../core/root/root.js';
+import * as SDK from '../core/sdk/sdk.js';
+import * as Bindings from '../models/bindings/bindings.js';
+import * as Workspace from '../models/workspace/workspace.js';
 
 export interface CreationOptions {
   // Settings things
@@ -10,12 +14,31 @@ export interface CreationOptions {
 }
 
 export class Universe {
+  readonly context = new Root.DevToolsContext.DevToolsContext();
+
   constructor(options: CreationOptions) {
     // TODO(crbug.com/458180550): Store instance on a "DevToolsContext" instead.
     //                            For now the global is fine as we don't anticipate the MCP server to change settings.
-    Common.Settings.Settings.instance({
+    const settings = Common.Settings.Settings.instance({
       forceNew: true,
       ...options.settingsCreationOptions,
     });
+
+    const targetManager = new SDK.TargetManager.TargetManager();
+    this.context.set(SDK.TargetManager.TargetManager, targetManager);
+
+    const workspace = new Workspace.Workspace.WorkspaceImpl();
+    this.context.set(Workspace.Workspace.WorkspaceImpl, workspace);
+
+    const ignoreListManager = new Workspace.IgnoreListManager.IgnoreListManager(settings, targetManager);
+    this.context.set(Workspace.IgnoreListManager.IgnoreListManager, ignoreListManager);
+
+    const resourceMapping = new Bindings.ResourceMapping.ResourceMapping(targetManager, workspace);
+    const cssWorkspaceBinding = new Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding(resourceMapping, targetManager);
+    this.context.set(Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding, cssWorkspaceBinding);
+
+    const debuggerWorkspaceBinding = new Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding(
+        resourceMapping, targetManager, ignoreListManager, workspace);
+    this.context.set(Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding, debuggerWorkspaceBinding);
   }
 }

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

@@ -204,6 +204,15 @@ export type FunctionCallHandlerResult<Result> = {
   requiresApproval: true,
 }|{error: string};
 
+export interface FunctionHandlerOptions {
+  /**
+   * Shows that the user approved
+   * the execution if it was required
+   */
+  approved?: boolean;
+  signal?: AbortSignal;
+}
+
 export interface FunctionDeclaration<Args extends Record<string, unknown>, ReturnType> {
   /**
    * Description of function, this is send to the LLM
@@ -228,14 +237,7 @@ export interface FunctionDeclaration<Args extends Record<string, unknown>, Retur
   /**
    * Function implementation that the LLM will try to execute,
    */
-  handler: (args: Args, options?: {
-    /**
-     * Shows that the user approved
-     * the execution if it was required
-     */
-    approved?: boolean,
-    signal?: AbortSignal,
-  }) => Promise<FunctionCallHandlerResult<ReturnType>>;
+  handler: (args: Args, options?: FunctionHandlerOptions) => Promise<FunctionCallHandlerResult<ReturnType>>;
 }
 
 interface AidaFetchResult {

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

@@ -151,7 +151,13 @@ export class PatchAgent extends AiAgent<Workspace.Workspace.Project> {
         return {
           result: {
             matches: await this.#project.searchFiles(
-                args.query, args.caseSensitive, args.isRegex, {signal: options?.signal}),
+                args.query,
+                args.caseSensitive,
+                args.isRegex,
+                {
+                  signal: options?.signal,
+                },
+                ),
           }
         };
       },

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

@@ -10,7 +10,6 @@ import * as Root from '../../../core/root/root.js';
 import * as SDK from '../../../core/sdk/sdk.js';
 import * as Tracing from '../../../services/tracing/tracing.js';
 import * as Trace from '../../trace/trace.js';
-import {ConversationType} from '../AiHistoryStorage.js';
 import {
   PerformanceInsightFormatter,
 } from '../data_formatters/PerformanceInsightFormatter.js';
@@ -323,10 +322,6 @@ export class PerformanceAgent extends AiAgent<AgentFocus> {
     };
   }
 
-  getConversationType(): ConversationType {
-    return ConversationType.PERFORMANCE;
-  }
-
   async *
       handleContextDetails(context: ConversationContext<AgentFocus>|null): AsyncGenerator<ContextResponse, void, void> {
     if (!context) {

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

@@ -21,9 +21,10 @@ import {
   ConversationContext,
   type ConversationSuggestions,
   type FunctionCallHandlerResult,
+  type FunctionHandlerOptions,
   MultimodalInputType,
   type RequestOptions,
-  ResponseType,
+  ResponseType
 } from './AiAgent.js';
 
 /*
@@ -268,11 +269,7 @@ export class StylingAgent extends AiAgent<SDK.DOMModel.DOMNode> {
   #createExtensionScope: CreateExtensionScopeFunction;
 
   constructor(opts: AgentOptions) {
-    super({
-      aidaClient: opts.aidaClient,
-      serverSideLoggingEnabled: opts.serverSideLoggingEnabled,
-      confirmSideEffectForTest: opts.confirmSideEffectForTest,
-    });
+    super(opts);
 
     this.#changes = opts.changeManager || new ChangeManager();
     this.#execJs = opts.execJs ?? executeJsCode;
@@ -633,8 +630,7 @@ const data = {
     };
   }
 
-  async executeAction(action: string, options?: {signal?: AbortSignal, approved?: boolean}):
-      Promise<FunctionCallHandlerResult<unknown>> {
+  async executeAction(action: string, options?: FunctionHandlerOptions): Promise<FunctionCallHandlerResult<unknown>> {
     debugLog(`Action to execute: ${action}`);
 
     if (options?.approved === false) {

package/front_end/models/ai_code_completion/AiCodeCompletion.ts

@@ -46,7 +46,7 @@ export interface Callbacks {
 }
 
 /* clang-format off */
-const consoleAdditionalContextFileContent = `/**
+export const consoleAdditionalContextFileContent = `/**
  * This file describes the execution environment of the Chrome DevTools Console.
  * The code is JavaScript, but with special global functions and variables.
  * Top-level await is available.