chrome-devtools-frontend 1.0.1643855 → 1.0.1645245

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

@@ -9,22 +9,76 @@ import type {executeJsCode} from '../agents/ExecuteJavascript.js';
 import type {ChangeManager} from '../ChangeManager.js';
 
 /**
- * Context provided to the tool's handler execution.
+ * Base capability for all tool contexts, providing access to the conversation context.
  */
-export interface ToolContext {
+export interface BaseToolCapability {
+  /**
+   * The active context for the current conversation step, if any.
+   */
   conversationContext: ConversationContext<unknown>|null;
-  changeManager?: ChangeManager;
-  createExtensionScope?: (changes: ChangeManager) => {
-    install(): Promise<void>, uninstall(): Promise<void>,
-  };
-  execJs?: typeof executeJsCode;
+}
+
+/**
+ * Capability for tools that need to execute JavaScript code on the inspected page.
+ */
+export interface PageExecutionCapability {
+  /**
+   * Function to execute JavaScript code in the page context.
+   */
+  execJs: typeof executeJsCode;
+
   /**
    * Returns the DOM node that acts as the execution context (i.e. `$0` inside the execution context)
    * for running JavaScript.
    */
-  getExecutionContextNode?: () => SDK.DOMModel.DOMNode | null;
+  getExecutionContextNode(): SDK.DOMModel.DOMNode|null;
 }
 
+/**
+ * Capability for tools that need to manage and apply style mutations to the page.
+ */
+export interface StyleMutationCapability {
+  /**
+   * The change manager for tracking and applying style changes.
+   */
+  changeManager: ChangeManager;
+
+  /**
+   * Creates an extension scope for applying changes, ensuring they can be uninstalled when done.
+   */
+  createExtensionScope(changes: ChangeManager): {
+    install(): Promise<void>,
+    uninstall(): Promise<void>,
+  };
+}
+
+/**
+ * Capability for tools that need access to the current SDK Target of the inspected page.
+ */
+export interface TargetCapability {
+  /**
+   * Returns the current SDK Target for the inspected page.
+   */
+  getTarget(): SDK.Target.Target|null;
+}
+
+/**
+ * Capability for tools that need to enforce origin locking for security.
+ */
+export interface OriginLockCapability {
+  /**
+   * Returns the origin that the current conversation is locked to, if any.
+   */
+  getEstablishedOrigin(): string|undefined;
+}
+
+/**
+ * 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;
+
 /**
  * Base argument type for AI Tools.
  */
@@ -50,21 +104,30 @@ export interface BaseTool {
 
 /**
  * Main generic interface for defining a Tool.
- * Binds the parameter schema properties and the handler implementation to a strict `Args` contract.
+ * Binds the parameter schema properties and the handler implementation to a strict `Args` and `ContextType` contract.
  *
  * @template Args - The expected object type for tool arguments. Must be an object type.
  * @template ReturnType - The type of data returned by the handler function.
+ * @template ContextType - The interface defining the capabilities this tool requires. Defaults to `BaseToolCapability`.
  */
-export interface Tool<Args extends ToolArgs = ToolArgs, ReturnType = unknown, > extends BaseTool {
+export interface Tool<Args extends ToolArgs = ToolArgs, ReturnType = unknown,
+                                   ContextType extends BaseToolCapability = BaseToolCapability> extends BaseTool {
   readonly parameters: Host.AidaClient.FunctionObjectParam<keyof Args>;
   readonly displayInfoFromArgs?: (
       args: Args,
       ) => {
     title?: string, thought?: string, action?: string, suggestions?: [string, ...string[]],
   };
+  /**
+   * The implementation function called when the AI invokes this tool.
+   *
+   * @param args The arguments provided by the AI model matching the tool's parameter schema.
+   * @param context The context object providing the capabilities requested by `ContextType`.
+   * @param options Additional runtime options for the handler execution.
+   */
   handler(
       args: Args,
-      context: ToolContext,
+      context: ContextType,
       options?: FunctionHandlerOptions,
       ): Promise<FunctionCallHandlerResult<ReturnType>>;
 }

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

@@ -4,11 +4,15 @@
 
 import {ExecuteJavaScriptTool} from './ExecuteJavaScript.js';
 import {GetStylesTool} from './GetStyles.js';
-import {type Tool, ToolName} from './Tool.js';
+import {type AllToolsContext, type Tool, type ToolArgs, ToolName} from './Tool.js';
 
 /**
  * Plain object registry containing concrete instantiated tools.
- * Keep this type concrete (no type-erasure) to preserve exact tool types.
+ *
+ * This object is deliberately declared as a plain object without an explicit type annotation
+ * (like `Record<ToolName, Tool>`) to preserve the exact concrete type of each registered tool.
+ * This is required to support compile-time type safety and inference in the overloaded
+ * `ToolRegistry.get()` method, which maps a literal `ToolName` key to its specific class type.
  */
 export const TOOLS = {
   [ToolName.EXECUTE_JAVASCRIPT]: new ExecuteJavaScriptTool(),
@@ -23,14 +27,26 @@ export class ToolRegistry {
    * Retrieves a tool by its literal name with 100% type safety.
    *
    * @template K - A key from the `TOOLS` registry.
+   * @param name The literal name of the tool to retrieve.
    * @returns The concrete class type of the requested tool.
    */
   static get<K extends keyof typeof TOOLS>(name: K): typeof TOOLS[K];
   /**
    * Fallback retrieval signature for general or runtime string lookups.
+   *
+   * @param name The string name of the tool to retrieve, used when the tool name is only known at runtime.
+   * @returns The generic Tool interface, or undefined if not found.
    */
-  static get(name: string): Tool|undefined;
-  static get(name: string): Tool|undefined {
-    return Object.prototype.hasOwnProperty.call(TOOLS, name) ? TOOLS[name as keyof typeof TOOLS] as Tool : undefined;
+  static get(name: string): Tool<ToolArgs, unknown, AllToolsContext>|undefined;
+  static get(name: string): Tool<ToolArgs, unknown, AllToolsContext>|undefined {
+    // We use a double assertion (`as unknown as Tool<...>`) here. TypeScript's variance
+    // rules prevent direct casting from specific concrete tools (which have narrowed,
+    // capability-specific contexts) to the generic `Tool` signature that uses `AllToolsContext`.
+    // This cast is runtime-safe because any capability requested by a specific tool is
+    // guaranteed to be satisfied by `AllToolsContext`, and the handler will only access
+    // the capabilities it expects.
+    return Object.prototype.hasOwnProperty.call(TOOLS, name) ?
+        TOOLS[name as keyof typeof TOOLS] as unknown as Tool<ToolArgs, unknown, AllToolsContext>:
+        undefined;
   }
 }

package/front_end/models/heap_snapshot/HeapSnapshotModel.ts

@@ -136,10 +136,16 @@ export class Diff {
   removedCount = 0;
   addedSize = 0;
   removedSize = 0;
-  deletedIndexes: number[] = [];
-  addedIndexes: number[] = [];
   countDelta!: number;
   sizeDelta!: number;
+  // Data about added nodes
+  addedIndexes: number[] = [];
+  addedIds: number[] = [];
+  addedSelfSizes: number[] = [];
+  // Data about deleted nodes
+  deletedIndexes: number[] = [];
+  deletedIds: number[] = [];
+  deletedSelfSizes: number[] = [];
   constructor(name: string) {
     this.name = name;
   }
@@ -287,3 +293,13 @@ export interface RetainingPaths {
     siblings?: boolean,
   };
 }
+
+export interface DominatorNode {
+  nodeId: number;
+  nodeIndex: number;
+  nodeName: string;
+  retainedSize: number;
+  selfSize: number;
+}
+
+export type DominatorChain = DominatorNode[];

package/front_end/models/heap_snapshot/HeapSnapshotProxy.ts

@@ -370,6 +370,10 @@ export class HeapSnapshotProxy extends HeapSnapshotProxyObject {
     return this.callMethodPromise('getRetainingPaths', nodeIndex, maxDepth, maxNodes, maxSiblings);
   }
 
+  getDominatorsOf(nodeIndex: number): Promise<HeapSnapshotModel.DominatorChain> {
+    return this.callMethodPromise('getDominatorsOf', nodeIndex);
+  }
+
   unignoreNodeInRetainersView(nodeIndex: number): Promise<void> {
     return this.callMethodPromise('unignoreNodeInRetainersView', nodeIndex);
   }

package/front_end/models/stack_trace/DetailedErrorStackParser.ts

@@ -10,13 +10,15 @@ import type {RawFrame} from './Trie.js';
 
 const CALL_FRAME_REGEX = /^\s*at\s+/;
 
+export type ResolveURLCallback = (url: Platform.DevToolsPath.UrlString) => Platform.DevToolsPath.UrlString|null;
+
 /**
  * Takes a V8 Error#stack string and extracts structured information.
  *
  * @returns Null if the provided string has an unexpected format. A
  *          populated `RawFrame[]` otherwise.
  */
-export function parseRawFramesFromErrorStack(stack: string): RawFrame[]|null {
+export function parseRawFramesFromErrorStack(stack: string, resolveURL?: ResolveURLCallback): RawFrame[]|null {
   const lines = stack.split('\n');
   const firstAtLineIndex = findFramesStartLine(lines);
   const rawFrames: RawFrame[] = [];
@@ -66,6 +68,8 @@ export function parseRawFramesFromErrorStack(stack: string): RawFrame[]|null {
     if (lineContent.endsWith(')') && openParenIndex !== -1) {
       functionName = lineContent.substring(0, openParenIndex).trim();
       location = lineContent.substring(openParenIndex + 2, lineContent.length - 1);
+    } else if (lineContent.startsWith('(') && lineContent.endsWith(')')) {
+      location = lineContent.substring(1, lineContent.length - 1);
     } else {
       location = lineContent;
     }
@@ -90,9 +94,9 @@ export function parseRawFramesFromErrorStack(stack: string): RawFrame[]|null {
       if (innerOpenParen !== -1) {
         evalFunctionName = evalOriginStr.substring(0, innerOpenParen).trim();
         evalLocation = evalOriginStr.substring(innerOpenParen + 2, evalOriginStr.length - 1);
-        evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName} (${evalLocation})`)?.[0];
+        evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName} (${evalLocation})`, resolveURL)?.[0];
       } else {
-        evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName}`)?.[0];
+        evalOrigin = parseRawFramesFromErrorStack(`    at ${evalFunctionName}`, resolveURL)?.[0];
       }
     }
 
@@ -112,9 +116,18 @@ export function parseRawFramesFromErrorStack(stack: string): RawFrame[]|null {
       }
     } else if (location) {
       const splitResult = Common.ParsedURL.ParsedURL.splitLineAndColumn(location);
-      url = splitResult.url;
       lineNumber = splitResult.lineNumber ?? -1;
       columnNumber = splitResult.columnNumber ?? -1;
+
+      if (resolveURL && splitResult.url !== '<anonymous>' && splitResult.url !== 'native') {
+        const resolved = resolveURL(splitResult.url);
+        if (!resolved) {
+          return null;
+        }
+        url = resolved;
+      } else {
+        url = splitResult.url;
+      }
     }
 
     // Handle "typeName.methodName [as alias]"

package/front_end/models/stack_trace/StackTraceModel.ts

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 import * as Common from '../../core/common/common.js';
+import type * as Platform from '../../core/platform/platform.js';
 import * as SDK from '../../core/sdk/sdk.js';
 import type * as Protocol from '../../generated/protocol.js';
 
@@ -65,7 +66,17 @@ export class StackTraceModel extends SDK.SDKModel.SDKModel<unknown> {
   async createFromErrorStackLikeString(
       stack: string, rawFramesToUIFrames: TranslateRawFrames,
       exceptionDetails?: Protocol.Runtime.ExceptionDetails): Promise<StackTrace.StackTrace.ParsedErrorStackTrace|null> {
-    const rawFrames = parseRawFramesFromErrorStack(stack);
+    const debuggerModel = this.target().model(SDK.DebuggerModel.DebuggerModel) as SDK.DebuggerModel.DebuggerModel;
+    const baseURL = this.target().inspectedURL();
+    const resolveURL = (url: Platform.DevToolsPath.UrlString): Platform.DevToolsPath.UrlString|null => {
+      let urlWithScheme = parseOrScriptMatch(debuggerModel, url);
+      if (!urlWithScheme && Common.ParsedURL.ParsedURL.isRelativeURL(url)) {
+        urlWithScheme = parseOrScriptMatch(debuggerModel, Common.ParsedURL.ParsedURL.completeURL(baseURL, url));
+      }
+      return urlWithScheme;
+    };
+
+    const rawFrames = parseRawFramesFromErrorStack(stack, resolveURL);
     if (!rawFrames) {
       return null;
     }
@@ -267,4 +278,26 @@ async function translateEvalOrigin(
   return new EvalOrigin(frames, parentEvalOrigin);
 }
 
+function parseOrScriptMatch(debuggerModel: SDK.DebuggerModel.DebuggerModel,
+                            url: Platform.DevToolsPath.UrlString|null): Platform.DevToolsPath.UrlString|null {
+  if (!url) {
+    return null;
+  }
+  if (Common.ParsedURL.ParsedURL.isValidUrlString(url)) {
+    return url;
+  }
+  if (debuggerModel.scriptsForSourceURL(url).length) {
+    return url;
+  }
+  // nodejs stack traces contain (absolute) file paths, but v8 reports them as file: urls.
+  try {
+    const fileUrl = new URL(url, 'file://');
+    if (debuggerModel.scriptsForSourceURL(fileUrl.href as Platform.DevToolsPath.UrlString).length) {
+      return fileUrl.href as Platform.DevToolsPath.UrlString;
+    }
+  } catch {
+  }
+  return null;
+}
+
 SDK.SDKModel.SDKModel.register(StackTraceModel, {capabilities: SDK.Target.Capability.NONE, autostart: false});

package/front_end/models/trace/Styles.ts

@@ -291,6 +291,10 @@ const UIStrings = {
    * @description Text in Timeline UIUtils of the Performance panel
    */
   frameStartedLoading: 'Frame started loading',
+  /**
+   * @description Text in Timeline UIUtils of the Performance panel
+   */
+  softNavigationStart: 'Soft navigation start',
   /**
    * @description Text in Timeline UIUtils of the Performance panel
    */
@@ -307,6 +311,10 @@ const UIStrings = {
    * @description Text in Timeline UIUtils of the Performance panel
    */
   firstContentfulPaint: 'First Contentful Paint',
+  /**
+   * @description Text in Timeline UIUtils of the Performance panel
+   */
+  softFirstContentfulPaint: 'Soft First Contentful Paint',
   /**
    * @description Text in Timeline UIUtils of the Performance panel
    */
@@ -866,6 +874,12 @@ export function maybeInitSylesMap(): EventStylesMap {
         true,
         ),
 
+    [Types.Events.Name.SOFT_NAVIGATION_START]: new TimelineRecordStyle(
+        i18nString(UIStrings.softNavigationStart),
+        defaultCategoryStyles.loading,
+        true,
+        ),
+
     [Types.Events.Name.MARK_FIRST_PAINT]: new TimelineRecordStyle(
         i18nString(UIStrings.firstPaint),
         defaultCategoryStyles.painting,
@@ -878,6 +892,12 @@ export function maybeInitSylesMap(): EventStylesMap {
         true,
         ),
 
+    [Types.Events.Name.MARK_SOFT_FCP]: new TimelineRecordStyle(
+        i18nString(UIStrings.softFirstContentfulPaint),
+        defaultCategoryStyles.rendering,
+        true,
+        ),
+
     [Types.Events.Name.MARK_LCP_CANDIDATE]: new TimelineRecordStyle(
         i18nString(UIStrings.largestContentfulPaint),
         defaultCategoryStyles.rendering,
@@ -1024,11 +1044,11 @@ export function maybeInitSylesMap(): EventStylesMap {
     [Types.Events.Name.ASYNC_TASK]:
         new TimelineRecordStyle(i18nString(UIStrings.asyncTask), defaultCategoryStyles.async),
 
-    [Types.Events.Name.LAYOUT_SHIFT]: new TimelineRecordStyle(
-        i18nString(UIStrings.layoutShift), defaultCategoryStyles.experience,
-        /* Mark LayoutShifts as hidden; in the timeline we render
-        * SyntheticLayoutShifts so those are the ones visible to the user */
-        true),
+    [Types.Events.Name.LAYOUT_SHIFT]:
+        new TimelineRecordStyle(i18nString(UIStrings.layoutShift), defaultCategoryStyles.experience,
+                                /* Mark LayoutShifts as hidden; in the timeline we render
+                                 * SyntheticLayoutShifts so those are the ones visible to the user */
+                                true),
 
     [Types.Events.Name.SYNTHETIC_LAYOUT_SHIFT]:
         new TimelineRecordStyle(i18nString(UIStrings.layoutShift), defaultCategoryStyles.experience),
@@ -1123,9 +1143,11 @@ export function markerDetailsForEvent(event: Types.Events.Event): {
 } {
   let title = '';
   let color = 'var(--color-text-primary)';
-  if (Types.Events.isFirstContentfulPaint(event)) {
+  if (Types.Events.isAnyFirstContentfulPaint(event)) {
     color = 'var(--sys-color-green-bright)';
-    title = Handlers.ModelHandlers.PageLoadMetrics.MetricName.FCP;
+    title = (Types.Events.isSoftFirstContentfulPaint(event)) ?
+        Handlers.ModelHandlers.PageLoadMetrics.MetricName.SOFT_FCP :
+        Handlers.ModelHandlers.PageLoadMetrics.MetricName.FCP;
   }
   if (Types.Events.isAnyLargestContentfulPaintCandidate(event)) {
     color = 'var(--sys-color-green)';

package/front_end/models/trace/handlers/PageLoadMetricsHandler.ts

@@ -75,6 +75,28 @@ export function handleEvent(event: Types.Events.Event): void {
     return;
   }
   pageLoadEventsArray.push(event);
+
+  // A soft nav entry includes the Soft FCP details but we want to process both
+  // so push a separate Soft FCP event
+  if (Types.Events.isSoftNavigationStart(event) && event.args?.context?.firstContentfulPaint) {
+    const syntheticSoftFcpEvent = Helpers.SyntheticEvents.SyntheticEventsManager
+                                      .registerSyntheticEvent<Types.Events.SyntheticSoftFirstContentfulPaint>({
+                                        name: Types.Events.Name.MARK_SOFT_FCP,
+                                        ph: Types.Events.Phase.MARK,
+                                        rawSourceEvent: event,
+                                        pid: event.pid,
+                                        tid: event.tid,
+                                        ts: Types.Timing.Micro(event.args.context.firstContentfulPaint),
+                                        cat: event.cat,
+                                        args: {
+                                          frame: event.args.frame,
+                                          context: {
+                                            ...event.args.context,
+                                          },
+                                        },
+                                      });
+    pageLoadEventsArray.push(syntheticSoftFcpEvent);
+  }
 }
 
 function storePageLoadMetricAgainstNavigationId(
@@ -101,7 +123,7 @@ function storePageLoadMetricAgainstNavigationId(
     return;
   }
 
-  if (Types.Events.isFirstContentfulPaint(event)) {
+  if (Types.Events.isAnyFirstContentfulPaint(event)) {
     const fcpTime = Types.Timing.Micro(event.ts - navigation.ts);
     const classification = scoreClassificationForFirstContentfulPaint(fcpTime);
     const metricScore = {event, metricName: MetricName.FCP, classification, navigation, timing: fcpTime};
@@ -226,7 +248,7 @@ function storeMetricScore(frameId: string, navigation: AnyNavigationStart, metri
 }
 
 export function getFrameIdForPageLoadEvent(event: Types.Events.PageLoadEvent): string {
-  if (Types.Events.isFirstContentfulPaint(event) || Types.Events.isInteractiveTime(event) ||
+  if (Types.Events.isAnyFirstContentfulPaint(event) || Types.Events.isInteractiveTime(event) ||
       Types.Events.isAnyLargestContentfulPaintCandidate(event) || Types.Events.isNavigationStart(event) ||
       Types.Events.isSoftNavigationStart(event) || Types.Events.isLayoutShift(event) ||
       Types.Events.isFirstPaint(event)) {
@@ -243,7 +265,7 @@ export function getFrameIdForPageLoadEvent(event: Types.Events.PageLoadEvent): s
 }
 
 function getNavigationForPageLoadEvent(event: Types.Events.PageLoadEvent): AnyNavigationStart|null {
-  if (Types.Events.isFirstContentfulPaint(event) || Types.Events.isAnyLargestContentfulPaintCandidate(event) ||
+  if (Types.Events.isAnyFirstContentfulPaint(event) || Types.Events.isAnyLargestContentfulPaintCandidate(event) ||
       Types.Events.isFirstPaint(event)) {
     const {navigationsByNavigationId, softNavigationsById} = metaHandlerData();
 
@@ -255,6 +277,12 @@ function getNavigationForPageLoadEvent(event: Types.Events.PageLoadEvent): AnyNa
         // The most recent soft navigation must have been before the trace started.
         return null;
       }
+    } else if (Types.Events.isSoftFirstContentfulPaint(event) && event.args.context?.performanceTimelineNavigationId) {
+      navigation = softNavigationsById.get(event.args.context.performanceTimelineNavigationId);
+      if (!navigation) {
+        // The most recent soft navigation must have been before the trace started.
+        return null;
+      }
     } else {
       const navigationId = event.args.data?.navigationId;
       if (!navigationId) {
@@ -428,7 +456,7 @@ export async function finalize(): Promise<void> {
   // Filter out LCP candidates to use only definitive LCP values
   const allEventsButLCP =
       pageLoadEventsArray.filter(event => !Types.Events.isAnyLargestContentfulPaintCandidate(event));
-  const markerEvents = [...allFinalLCPEvents, ...allEventsButLCP].filter(Types.Events.isMarkerEvent);
+  const markerEvents = [...allEventsButLCP, ...allFinalLCPEvents].filter(Types.Events.isMarkerEvent);
   // Filter by main frame and sort.
   allMarkerEvents =
       markerEvents.filter(event => getFrameIdForPageLoadEvent(event) === mainFrame).sort((a, b) => a.ts - b.ts);
@@ -495,6 +523,7 @@ export const enum MetricName {
   NAV = 'Nav',
   // Soft Navigation and Soft Metrics
   SOFT_NAV = 'Nav*',
+  SOFT_FCP = 'FCP*',
   SOFT_LCP = 'LCP*',
   // Note: INP is handled in UserInteractionsHandler
 }

package/front_end/models/trace/helpers/Timing.ts

@@ -32,6 +32,16 @@ export function timeStampForEventAdjustedByClosestNavigation(
     if (navigationForEvent) {
       eventTimeStamp = event.ts - navigationForEvent.ts;
     }
+  } else if (Types.Events.isSoftFirstContentfulPaint(event) && event.args?.context?.performanceTimelineNavigationId) {
+    const navigationForEvent = softNavigationsById.get(event.args.context.performanceTimelineNavigationId);
+    if (navigationForEvent) {
+      eventTimeStamp = event.ts - navigationForEvent.ts;
+    }
+  } else if (Types.Events.isSoftNavigationStart(event)) {
+    const navigationForEvent = getNavigationForTraceEvent(event, event.args.frame, navigationsByFrameId);
+    if (navigationForEvent) {
+      eventTimeStamp = event.ts - navigationForEvent.ts;
+    }
   } else if (event.args?.data?.navigationId) {
     const navigationForEvent = navigationsByNavigationId.get(event.args.data.navigationId);
     if (navigationForEvent) {

package/front_end/models/trace/types/TraceEvents.ts

@@ -737,6 +737,16 @@ export interface FirstContentfulPaint extends Mark {
   };
 }
 
+// Soft FCP is basically a copy of SoftNavigationStart but with a different name
+// and a different ts.
+export interface SyntheticSoftFirstContentfulPaint extends Omit<SoftNavigationStart, 'name'|'ph'>,
+                                                           Omit<SyntheticBased, 'name'|'ph'|'args'> {
+  name: Name.MARK_SOFT_FCP;
+  ph: Phase.MARK;
+}
+
+export type AnyFirstContentfulPaint = FirstContentfulPaint|SyntheticSoftFirstContentfulPaint;
+
 export interface FirstPaint extends Mark {
   name: Name.MARK_FIRST_PAINT;
   args: Args&{
@@ -747,14 +757,14 @@ export interface FirstPaint extends Mark {
   };
 }
 
-export type PageLoadEvent = FirstContentfulPaint|MarkDOMContent|InteractiveTime|AnyLargestContentfulPaintCandidate|
+export type PageLoadEvent = AnyFirstContentfulPaint|MarkDOMContent|InteractiveTime|AnyLargestContentfulPaintCandidate|
     LayoutShift|FirstPaint|MarkLoad|NavigationStart|SoftNavigationStart;
 
 const markerTypeGuards = [
   isMarkDOMContent,
   isMarkLoad,
   isFirstPaint,
-  isFirstContentfulPaint,
+  isAnyFirstContentfulPaint,
   isAnyLargestContentfulPaintCandidate,
   isNavigationStart,
   isSoftNavigationStart,
@@ -765,6 +775,7 @@ export const MarkerName = [
   Name.MARK_LOAD,
   Name.MARK_FIRST_PAINT,
   Name.MARK_FCP,
+  Name.MARK_SOFT_FCP,
   Name.MARK_LCP_CANDIDATE,
   Name.MARK_LCP_CANDIDATE_FOR_SOFT_NAVIGATION,
   Name.NAVIGATION_START,
@@ -2285,6 +2296,14 @@ export function isFirstContentfulPaint(event: Event): event is FirstContentfulPa
   return event.name === Name.MARK_FCP;
 }
 
+export function isSoftFirstContentfulPaint(event: Event): event is SyntheticSoftFirstContentfulPaint {
+  return event.name === Name.MARK_SOFT_FCP;
+}
+
+export function isAnyFirstContentfulPaint(event: Event): event is AnyFirstContentfulPaint {
+  return event.name === Name.MARK_FCP || event.name === Name.MARK_SOFT_FCP;
+}
+
 export function isAnyLargestContentfulPaintCandidate(event: Event): event is AnyLargestContentfulPaintCandidate {
   return event.name === Name.MARK_LCP_CANDIDATE || event.name === Name.MARK_LCP_CANDIDATE_FOR_SOFT_NAVIGATION;
 }
@@ -3168,6 +3187,7 @@ export const enum Name {
   MARK_DOM_CONTENT = 'MarkDOMContent',
   MARK_FIRST_PAINT = 'firstPaint',
   MARK_FCP = 'firstContentfulPaint',
+  MARK_SOFT_FCP = 'SyntheticSoftFirstContentfulPaint',
   MARK_LCP_CANDIDATE = 'largestContentfulPaint::Candidate',
   MARK_LCP_CANDIDATE_FOR_SOFT_NAVIGATION = 'largestContentfulPaint::CandidateForSoftNavigation',
   MARK_LCP_INVALIDATE = 'largestContentfulPaint::Invalidate',

package/front_end/panels/ai_assistance/AiAssistancePanel.ts

@@ -1575,7 +1575,12 @@ export class AiAssistancePanel extends UI.Panel.Panel {
         break;
       }
       case 'ai-assistance.storage-floating-button': {
-        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceOpenedFromStoragePanelFloatingButton);
+        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceOpenedFromApplicationPanelFloatingButton);
+        targetConversationType = AiAssistanceModel.AiHistoryStorage.ConversationType.STORAGE;
+        break;
+      }
+      case 'ai-assistance.application-panel-context': {
+        Host.userMetrics.actionTaken(Host.UserMetrics.Action.AiAssistanceOpenedFromApplicationPanel);
         targetConversationType = AiAssistanceModel.AiHistoryStorage.ConversationType.STORAGE;
         break;
       }
@@ -2116,7 +2121,8 @@ export class ActionDelegate implements UI.ActionRegistration.ActionDelegate {
       case 'drjones.performance-panel-context':
       case 'drjones.sources-floating-button':
       case 'drjones.sources-panel-context':
-      case 'ai-assistance.storage-floating-button': {
+      case 'ai-assistance.storage-floating-button':
+      case 'ai-assistance.application-panel-context': {
         void (async () => {
           const view = UI.ViewManager.ViewManager.instance().view(
               AiAssistancePanel.panelName,

package/front_end/panels/ai_assistance/ai_assistance-meta.ts

@@ -313,3 +313,19 @@ UI.ActionRegistration.registerActionExtension({
   condition: config =>
       isStorageAgentFeatureAvailable(config) && !isPolicyRestricted(config) && !isGeoRestricted(config),
 });
+
+UI.ActionRegistration.registerActionExtension({
+  actionId: 'ai-assistance.application-panel-context',
+  contextTypes(): [] {
+    return [];
+  },
+  category: UI.ActionRegistration.ActionCategory.GLOBAL,
+  title: i18nAiBrandedString(UIStrings.debugWithGemini, UIStrings.debugWithAi),
+  configurableBindings: false,
+  async loadActionDelegate() {
+    const AiAssistance = await loadAiAssistanceModule();
+    return new AiAssistance.ActionDelegate();
+  },
+  condition: config =>
+      isStorageAgentFeatureAvailable(config) && !isPolicyRestricted(config) && !isGeoRestricted(config),
+});