chrome-devtools-frontend 1.0.1682249 → 1.0.1684555

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

@@ -202,7 +202,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
 
       handler: async args => {
-        this.setServerSideLoggingActive(false);
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.targetManager, this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -288,7 +288,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
       },
 
       handler: async (args, options) => {
-        this.setServerSideLoggingActive(false);
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.targetManager, this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -388,7 +388,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
         };
       },
       handler: async args => {
-        this.setServerSideLoggingActive(false);
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.targetManager, this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -448,7 +448,7 @@ export class StorageAgent extends AiAgent<StorageItem> {
         };
       },
       handler: async (args, options) => {
-        this.setServerSideLoggingActive(false);
+        this.disableServerSideLogging();
         if (!isSamePrimaryPageOrigin(this.targetManager, this.context)) {
           return {error: 'No origin available or not allowed.'};
         }
@@ -618,9 +618,9 @@ export class StorageAgent extends AiAgent<StorageItem> {
   protected override async preRun(): Promise<void> {
     const item = this.context?.getItem();
     if (item instanceof CookieItem && Boolean(item.name)) {
-      this.setServerSideLoggingActive(false);
+      this.disableServerSideLogging();
     } else if (item instanceof DOMStorageItem && Boolean(item.key)) {
-      this.setServerSideLoggingActive(false);
+      this.disableServerSideLogging();
     }
   }
 

package/front_end/models/ai_assistance/ai_assistance.ts

@@ -38,6 +38,8 @@ import * as AICallTree from './performance/AICallTree.js';
 import * as AIContext from './performance/AIContext.js';
 import * as AIQueries from './performance/AIQueries.js';
 import * as PerformanceAnnotations from './PerformanceAnnotations.js';
+import * as Skill from './skills/Skill.js';
+import * as SkillRegistry from './skills/SkillRegistry.js';
 import * as StorageItem from './StorageItem.js';
 import * as DOMStorageUtils from './tools/DOMStorageUtils.js';
 import * as ExecuteJavaScript from './tools/ExecuteJavaScript.js';
@@ -122,6 +124,8 @@ export {
   ResolveDevtoolsNodePath,
   RunLighthouse,
   SelectTraceEventByKey,
+  Skill,
+  SkillRegistry,
   StorageAgent,
   StorageContext,
   StorageItem,

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

@@ -4,17 +4,23 @@
 
 import * as Host from '../../../core/host/host.js';
 import type * as LHModel from '../../lighthouse/lighthouse.js';
-import {AccessibilityContext} from '../contexts/AccessibilityContext.js';
 import {LighthouseFormatter} from '../data_formatters/LighthouseFormatter.js';
 
-import {type BaseToolCapability, type DataHandlerResult, type DataTool, type ToolArgs, ToolName} from './Tool.js';
+import {
+  type BaseToolCapability,
+  type DataHandlerResult,
+  type DataTool,
+  type LighthouseReportCapability,
+  type ToolArgs,
+  ToolName,
+} from './Tool.js';
 
 export interface GetLighthouseAuditsArgs extends ToolArgs {
   categoryId: LHModel.RunTypes.CategoryId;
 }
 
 export class GetLighthouseAuditsTool implements
-    DataTool<GetLighthouseAuditsArgs, {audits: string}, BaseToolCapability> {
+    DataTool<GetLighthouseAuditsArgs, {audits: string}, BaseToolCapability&LighthouseReportCapability> {
   readonly name = ToolName.GET_LIGHTHOUSE_AUDITS;
   readonly description = 'Returns the audits for a specific Lighthouse category.';
 
@@ -40,11 +46,11 @@ export class GetLighthouseAuditsTool implements
   }
 
   async handler(params: GetLighthouseAuditsArgs,
-                context: BaseToolCapability): Promise<DataHandlerResult<{audits: string}>> {
-    if (!(context.conversationContext instanceof AccessibilityContext)) {
+                context: BaseToolCapability&LighthouseReportCapability): Promise<DataHandlerResult<{audits: string}>> {
+    const report = context.getLighthouseReport();
+    if (!report) {
       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},

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

@@ -97,7 +97,7 @@ export class GetStorageValuesTool implements DataTool<GetStorageValuesArgs, GetS
       context: BaseToolCapability&OriginLockCapability&ServerLoggingCapability,
       options?: FunctionHandlerOptions,
       ): Promise<DataHandlerResult<GetStorageValuesResult>> {
-    context.setLoggingEnabled(false);
+    context.disableLogging();
 
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     const targetManager = SDK.TargetManager.TargetManager.instance();

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

@@ -84,7 +84,7 @@ export class ListStorageKeysTool implements DataTool<ListStorageKeysArgs, ListSt
       args: ListStorageKeysArgs,
       context: BaseToolCapability&OriginLockCapability&ServerLoggingCapability,
       ): Promise<DataHandlerResult<ListStorageKeysResult>> {
-    context.setLoggingEnabled(false);
+    context.disableLogging();
 
     // eslint-disable-next-line @devtools/no-instance-of-migrated-singletons
     const targetManager = SDK.TargetManager.TargetManager.instance();

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

@@ -10,7 +10,7 @@ import {
   type BaseToolCapability,
   type DataHandlerResult,
   type DataTool,
-  type LighthouseCapability,
+  type LighthouseRecordingCapability,
   type ToolArgs,
   ToolName,
 } from './Tool.js';
@@ -22,7 +22,7 @@ export interface RunLighthouseArgs extends ToolArgs {
 }
 
 export class RunLighthouseTool implements
-    DataTool<RunLighthouseArgs, {audits: string}, BaseToolCapability&LighthouseCapability> {
+    DataTool<RunLighthouseArgs, {audits: string}, BaseToolCapability&LighthouseRecordingCapability> {
   readonly name = ToolName.RUN_LIGHTHOUSE;
   readonly description =
       'Runs Lighthouse audits on the active page. Supports "navigation" (for full initial page load audits), "snapshot" (for inspecting live in-page modifications without reload), and "timespan" (for interactions).';
@@ -60,14 +60,11 @@ export class RunLighthouseTool implements
     };
   }
 
-  async handler(params: RunLighthouseArgs,
-                context: BaseToolCapability&LighthouseCapability): Promise<DataHandlerResult<{audits: string}>> {
-    if (!context.lighthouseRecording) {
-      return {error: 'Error: Lighthouse recording capability is not available.'};
-    }
+  async handler(params: RunLighthouseArgs, context: BaseToolCapability&LighthouseRecordingCapability):
+      Promise<DataHandlerResult<{audits: string}>> {
     const mode = params.mode ?? 'snapshot';
     try {
-      const report = await context.lighthouseRecording({
+      const report = await context.runLighthouse({
         mode,
         categoryIds: [params.category],
         isAIControlled: true,

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

@@ -122,10 +122,17 @@ export interface OriginLockCapability {
 }
 
 /**
- * Capability for tools that need to run or query Lighthouse audits.
+ * Capability for tools that need to inspect an active Lighthouse report from context.
  */
-export interface LighthouseCapability {
-  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+export interface LighthouseReportCapability {
+  getLighthouseReport(): LHModel.ReporterTypes.ReportJSON|null;
+}
+
+/**
+ * Capability for tools that trigger new Lighthouse audit runs.
+ */
+export interface LighthouseRecordingCapability {
+  runLighthouse(overrides?: LHModel.RunTypes.RunOverrides): Promise<LHModel.ReporterTypes.ReportJSON|null>;
 }
 
 /**
@@ -139,8 +146,9 @@ export interface PerformanceRecordingCapability {
  * 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 AllToolsCapabilities = BaseToolCapability&PageExecutionCapability&StyleMutationCapability&TargetCapability&
-    OriginLockCapability&LighthouseCapability&PerformanceRecordingCapability&ServerLoggingCapability;
+export type AllToolsCapabilities =
+    BaseToolCapability&PageExecutionCapability&StyleMutationCapability&TargetCapability&OriginLockCapability&
+    LighthouseReportCapability&LighthouseRecordingCapability&PerformanceRecordingCapability&ServerLoggingCapability;
 
 /**
  * Base argument type for AI Tools.
@@ -263,8 +271,13 @@ export type Tool<
     CapabilitiesType extends BaseToolCapability = BaseToolCapability,
     > = DataTool<ArgsType, ReturnType, CapabilitiesType>|ContextTool<ArgsType, ReturnType, CapabilitiesType>;
 
+/**
+ * Capability provided to tools that handle sensitive user data (e.g. cookies or storage values).
+ * Calling `disableLogging()` irreversibly disables server-side logging for the remainder of
+ * the conversation session to prevent sensitive data from being logged on future turns.
+ */
 export interface ServerLoggingCapability {
-  setLoggingEnabled(enabled: boolean): void;
+  disableLogging(): void;
 }
 
 export const enum ToolAnnotation {

package/front_end/models/issues_manager/DOMIssuesManager.ts

@@ -0,0 +1,144 @@
+// 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 Platform from '../../core/platform/platform.js';
+import * as SDK from '../../core/sdk/sdk.js';
+import type * as Protocol from '../../generated/protocol.js';
+
+import type {Issue} from './Issue.js';
+import type {IssueAddedEvent, IssueHiddenStatusUpdatedEvent, IssuesManager} from './IssuesManager.js';
+import {Events as IssuesManagerEvents} from './IssuesManagerEvents.js';
+
+export const enum Events {
+  DOM_ISSUE_ADDED = 'DOMIssueAdded',
+  DOM_ISSUE_REMOVED = 'DOMIssueRemoved',
+}
+
+export interface EventTypes {
+  [Events.DOM_ISSUE_ADDED]: {node: SDK.DOMModel.DOMNode, issue: Issue};
+  [Events.DOM_ISSUE_REMOVED]: {node: SDK.DOMModel.DOMNode, issue: Issue};
+}
+
+export class DOMIssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> {
+  readonly #issuesManager: IssuesManager;
+  readonly #targetManager: SDK.TargetManager.TargetManager;
+  #currentIssues = new Set<Issue>();
+  #nodeToIssues = new Platform.MapUtilities.Multimap<SDK.DOMModel.DOMNode, Issue>();
+  readonly #nodeIdSubscribers = new Platform.MapUtilities.Multimap<Protocol.DOM.NodeId, () => void>();
+
+  constructor(issuesManager: IssuesManager, targetManager: SDK.TargetManager.TargetManager) {
+    super();
+    this.#issuesManager = issuesManager;
+    this.#targetManager = targetManager;
+    this.#issuesManager.addEventListener(IssuesManagerEvents.ISSUE_ADDED, this.#onIssueAdded, this);
+    this.#issuesManager.addEventListener(IssuesManagerEvents.ISSUE_HIDDEN_STATUS_UPDATED,
+                                         this.#onIssueHiddenStatusUpdated, this);
+    this.#issuesManager.addEventListener(IssuesManagerEvents.FULL_UPDATE_REQUIRED, this.#onFullUpdateRequired, this);
+    this.#targetManager.addModelListener(SDK.DOMModel.DOMModel, SDK.DOMModel.Events.DocumentUpdated,
+                                         this.#onDocumentUpdated, this, {scoped: true});
+  }
+
+  subscribeByNodeId(nodeId: Protocol.DOM.NodeId, callback: () => void): void {
+    this.#nodeIdSubscribers.set(nodeId, callback);
+  }
+
+  unsubscribeByNodeId(nodeId: Protocol.DOM.NodeId, callback: () => void): void {
+    this.#nodeIdSubscribers.delete(nodeId, callback);
+  }
+
+  issuesForNode(node: SDK.DOMModel.DOMNode): Issue[] {
+    return Array.from(this.#nodeToIssues.get(node));
+  }
+
+  #onIssueAdded(event: Common.EventTarget.EventTargetEvent<IssueAddedEvent>): void {
+    void this.#addIssue(event.data.issue);
+  }
+
+  #onIssueHiddenStatusUpdated(event: Common.EventTarget.EventTargetEvent<IssueHiddenStatusUpdatedEvent>): void {
+    const {issue} = event.data;
+    if (issue.isHidden()) {
+      void this.#removeIssue(issue);
+    } else {
+      void this.#addIssue(issue);
+    }
+  }
+
+  #onFullUpdateRequired(): void {
+    const newIssues = new Set(this.#issuesManager.issues());
+    for (const issue of this.#currentIssues) {
+      if (!newIssues.has(issue) || issue.isHidden()) {
+        void this.#removeIssue(issue);
+      }
+    }
+    for (const issue of newIssues) {
+      if (!issue.isHidden()) {
+        void this.#addIssue(issue);
+      }
+    }
+  }
+
+  #onDocumentUpdated(_event: Common.EventTarget.EventTargetEvent<SDK.DOMModel.DOMModel>): void {
+    this.#nodeToIssues.clear();
+    for (const issue of this.#issuesManager.issues()) {
+      if (!issue.isHidden()) {
+        void this.#addIssue(issue);
+      }
+    }
+  }
+
+  async #resolveNodesForIssue(issue: Issue): Promise<SDK.DOMModel.DOMNode[]> {
+    const primaryTarget = this.#targetManager.primaryPageTarget() ?? this.#targetManager.targets()[0];
+    const nodes: SDK.DOMModel.DOMNode[] = [];
+    for (const element of issue.elements()) {
+      const elementTarget = (element.target && typeof (element.target as SDK.Target.Target).model === 'function') ?
+          (element.target as SDK.Target.Target) :
+          primaryTarget;
+      if (!elementTarget) {
+        continue;
+      }
+      const domModel = elementTarget.model(SDK.DOMModel.DOMModel);
+      if (!domModel) {
+        continue;
+      }
+      const deferredDOMNode = new SDK.DOMModel.DeferredDOMNode(elementTarget, element.backendNodeId);
+      const node = await deferredDOMNode.resolvePromise();
+      if (node) {
+        nodes.push(node);
+      }
+    }
+    return nodes;
+  }
+
+  async #addIssue(issue: Issue): Promise<void> {
+    if (issue.isHidden()) {
+      return;
+    }
+    this.#currentIssues.add(issue);
+    const nodes = await this.#resolveNodesForIssue(issue);
+    for (const node of nodes) {
+      if (!this.#nodeToIssues.hasValue(node, issue)) {
+        this.#nodeToIssues.set(node, issue);
+        this.dispatchEventToListeners(Events.DOM_ISSUE_ADDED, {node, issue});
+        for (const callback of this.#nodeIdSubscribers.get(node.id)) {
+          callback();
+        }
+      }
+    }
+  }
+
+  async #removeIssue(issue: Issue): Promise<void> {
+    this.#currentIssues.delete(issue);
+    const nodes = await this.#resolveNodesForIssue(issue);
+    for (const node of nodes) {
+      if (this.#nodeToIssues.hasValue(node, issue)) {
+        this.#nodeToIssues.delete(node, issue);
+        this.dispatchEventToListeners(Events.DOM_ISSUE_REMOVED, {node, issue});
+        for (const callback of this.#nodeIdSubscribers.get(node.id)) {
+          callback();
+        }
+      }
+    }
+  }
+}

package/front_end/models/issues_manager/ElementAccessibilityIssue.ts

@@ -5,7 +5,7 @@
 import type * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
-import {Issue, IssueCategory, IssueKind} from './Issue.js';
+import {type AffectedElement, Issue, IssueCategory, IssueKind} from './Issue.js';
 import {
   type LazyMarkdownIssueDescription,
   type MarkdownIssueDescription,
@@ -23,6 +23,18 @@ export class ElementAccessibilityIssue extends Issue<Protocol.Audits.ElementAcce
     super(issueCode, issueDetails, issuesModel, issueId);
   }
 
+  override elements(): Iterable<AffectedElement> {
+    const details = this.details();
+    if (details.nodeId) {
+      return [{
+        backendNodeId: details.nodeId,
+        nodeName: '',
+        target: this.model()?.target() ?? null,
+      }];
+    }
+    return [];
+  }
+
   primaryKey(): string {
     return JSON.stringify(this.details());
   }

package/front_end/models/issues_manager/GenericIssue.ts

@@ -6,11 +6,11 @@ import * as i18n from '../../core/i18n/i18n.js';
 import type * as SDK from '../../core/sdk/sdk.js';
 import * as Protocol from '../../generated/protocol.js';
 
-import {Issue, IssueCategory, IssueKind} from './Issue.js';
+import {type AffectedElement, Issue, IssueCategory, IssueKind} from './Issue.js';
 import {
-  resolveLazyDescription,
   type LazyMarkdownIssueDescription,
   type MarkdownIssueDescription,
+  resolveLazyDescription,
 } from './MarkdownIssueDescription.js';
 
 const UIStrings = {
@@ -72,6 +72,18 @@ export class GenericIssue extends Issue<Protocol.Audits.GenericIssueDetails> {
     return [];
   }
 
+  override elements(): Iterable<AffectedElement> {
+    const details = this.details();
+    if (details.violatingNodeId) {
+      return [{
+        backendNodeId: details.violatingNodeId,
+        nodeName: '',
+        target: this.model()?.target() ?? null,
+      }];
+    }
+    return [];
+  }
+
   getCategory(): IssueCategory {
     return IssueCategory.GENERIC;
   }

package/front_end/models/issues_manager/IssuesManager.ts

@@ -233,7 +233,6 @@ export class IssuesManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   #issuesByOutermostTarget: WeakMap<SDK.Target.Target, Set<Issue>> = new Map();
   #frameManager: SDK.FrameManager.FrameManager;
   #targetManager: SDK.TargetManager.TargetManager;
-
   constructor(
       private readonly showThirdPartyIssuesSetting?: Common.Settings.Setting<boolean>,
       private readonly hideIssueSetting?: Common.Settings.Setting<HideIssueMenuSetting>,

package/front_end/models/issues_manager/issues_manager.ts

@@ -10,6 +10,7 @@ import * as CookieIssue from './CookieIssue.js';
 import * as CorsIssue from './CorsIssue.js';
 import * as CrossOriginEmbedderPolicyIssue from './CrossOriginEmbedderPolicyIssue.js';
 import * as DeprecationIssue from './DeprecationIssue.js';
+import * as DOMIssuesManager from './DOMIssuesManager.js';
 import * as ElementAccessibilityIssue from './ElementAccessibilityIssue.js';
 import * as EmailVerificationRequestIssue from './EmailVerificationRequestIssue.js';
 import * as FederatedAuthRequestIssue from './FederatedAuthRequestIssue.js';
@@ -45,6 +46,7 @@ export {
   CorsIssue,
   CrossOriginEmbedderPolicyIssue,
   DeprecationIssue,
+  DOMIssuesManager,
   ElementAccessibilityIssue,
   EmailVerificationRequestIssue,
   FederatedAuthRequestIssue,

package/front_end/models/javascript_metadata/NativeFunctions.js

@@ -6718,6 +6718,10 @@ export const NativeFunctions = [
     name: "copyElementImageToTexture",
     signatures: [["source","destination"]]
   },
+  {
+    name: "drawElementImageToTexture",
+    signatures: [["source","destination"]]
+  },
   {
     name: "multiDrawIndirect",
     signatures: [["indirectBuffer","indirectOffset","maxDrawCount","?drawCountBuffer","?drawCountBufferOffset"]]
@@ -7898,6 +7902,10 @@ export const NativeFunctions = [
     name: "receiveFeatureReport",
     signatures: [["reportId"]]
   },
+  {
+    name: "playHaptics",
+    signatures: [["effect","?intensity"]]
+  },
   {
     name: "addStroke",
     signatures: [["stroke"]]

package/front_end/models/trace/Processor.ts

@@ -606,6 +606,7 @@ export class TraceProcessor extends EventTarget {
         'missing metric scores for main frame',
         'missing metric: FCP',
         'missing metric: LCP',
+        'NO_LCP',
         'No network requests found in trace',
         'Trace is too old',
       ];

package/front_end/panels/ai_assistance/ExternalHandler.ts

@@ -0,0 +1,89 @@
+// 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 * as AiAssistanceModel from '../../models/ai_assistance/ai_assistance.js';
+import * as NetworkTimeCalculator from '../../models/network_time_calculator/network_time_calculator.js';
+import * as UI from '../../ui/legacy/legacy.js';
+
+export type ContextType = 'NETWORK_REQUEST';
+
+export interface ExternalAIRequestOptions {
+  context?: {
+    type: ContextType,
+    contextIdentifier: string,
+  };
+  prompts: string[];
+}
+
+export interface IndividualPromptRequestResponse {
+  prompt: string;
+  response: string;
+  error?: string;
+}
+
+function resolveConversationType(contextType?: ContextType): AiAssistanceModel.AiHistoryStorage.ConversationType {
+  switch (contextType) {
+    case 'NETWORK_REQUEST':
+      return AiAssistanceModel.AiHistoryStorage.ConversationType.NETWORK;
+    default:
+      return AiAssistanceModel.AiHistoryStorage.ConversationType.NONE;
+  }
+}
+
+function getMatchingFlavorContext(
+    contextOptions?: ExternalAIRequestOptions['context'],
+    ): AiAssistanceModel.AiAgent.ConversationContext<unknown>|null {
+  if (!contextOptions?.contextIdentifier) {
+    return null;
+  }
+  if (contextOptions.type === 'NETWORK_REQUEST') {
+    const raw = UI.Context.Context.instance().flavor(SDK.NetworkRequest.NetworkRequest);
+    if (raw) {
+      if (raw.name() !== contextOptions.contextIdentifier && raw.url() !== contextOptions.contextIdentifier) {
+        return null;
+      }
+      return new AiAssistanceModel.RequestContext.RequestContext(
+          raw, new NetworkTimeCalculator.NetworkTransferTimeCalculator());
+    }
+  }
+  return null;
+}
+
+export async function handleExternalAIRequest(options: ExternalAIRequestOptions): Promise<unknown[]> {
+  localStorage.setItem('aiAssistanceStructuredLogEnabled', 'true');
+  localStorage.removeItem('aiAssistanceStructuredLog');
+
+  const conversationType = resolveConversationType(options.context?.type);
+
+  const aidaClient = new Host.AidaClient.AidaClient();
+  const conversation = new AiAssistanceModel.AiConversation.AiConversation({
+    type: conversationType,
+    data: [],
+    isReadOnly: false,
+    aidaClient,
+  });
+
+  const resolvedContext = getMatchingFlavorContext(options.context);
+  if (resolvedContext) {
+    conversation.setContext(resolvedContext);
+  }
+
+  for (const prompt of options.prompts) {
+    await Array.fromAsync(conversation.run(prompt));
+  }
+
+  const logsRaw = localStorage.getItem('aiAssistanceStructuredLog');
+  return logsRaw ? JSON.parse(logsRaw) : [];
+}
+
+declare global {
+  interface Window {
+    handleExternalAIRequest?: typeof handleExternalAIRequest;
+  }
+}
+
+// @ts-expect-error
+globalThis.handleExternalAIRequest = handleExternalAIRequest;

package/front_end/panels/ai_assistance/ai_assistance.ts

@@ -16,4 +16,5 @@ export * as DisabledWidget from './components/DisabledWidget.js';
 export * as WalkthroughUtils from './components/WalkthroughUtils.js';
 export * as WalkthroughView from './components/WalkthroughView.js';
 export * as ExportConversation from './ExportConversation.js';
+export * as ExternalHandler from './ExternalHandler.js';
 export * as ImageResize from './components/ImageResize.js';

package/front_end/panels/application/BackgroundServiceModel.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 * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
 import type * as Protocol from '../../generated/protocol.js';
@@ -44,9 +45,9 @@ export class BackgroundServiceModel extends SDK.SDKModel.SDKModel<EventTypes> im
 
   backgroundServiceEventReceived({backgroundServiceEvent}:
                                      Protocol.BackgroundService.BackgroundServiceEventReceivedEvent): void {
-    // TODO(crbug.com/1172300) Ignored during the jsdoc to ts migration)
-    // @ts-expect-error
-    this.events.get(backgroundServiceEvent.service).push(backgroundServiceEvent);
+    const events = this.events.get(backgroundServiceEvent.service);
+    Platform.assertNotNullOrUndefined(events);
+    events.push(backgroundServiceEvent);
     this.dispatchEventToListeners(Events.BackgroundServiceEventReceived, backgroundServiceEvent);
   }
 }

package/front_end/panels/application/IndexedDBModel.ts

@@ -423,13 +423,6 @@ export class IndexedDBModel extends SDK.SDKModel.SDKModel<EventTypes> implements
   cacheStorageContentUpdated(_event: Protocol.Storage.CacheStorageContentUpdatedEvent): void {
   }
 
-  sharedStorageAccessed(_event: Protocol.Storage.SharedStorageAccessedEvent): void {
-  }
-
-  sharedStorageWorkletOperationExecutionFinished(
-      _event: Protocol.Storage.SharedStorageWorkletOperationExecutionFinishedEvent): void {
-  }
-
   storageBucketCreatedOrUpdated(_event: Protocol.Storage.StorageBucketCreatedOrUpdatedEvent): void {
   }