chrome-devtools-frontend 1.0.1602348 → 1.0.1603822

package/front_end/core/common/common.ts

@@ -34,6 +34,7 @@ import * as StringOutputStream from './StringOutputStream.js';
 import * as TextDictionary from './TextDictionary.js';
 import * as Throttler from './Throttler.js';
 import * as Trie from './Trie.js';
+import * as VersionController from './VersionController.js';
 
 /*
  * This is re-exported here because we moved UIString into platform from
@@ -74,4 +75,5 @@ export {
   TextDictionary,
   Throttler,
   Trie,
+  VersionController,
 };

package/front_end/core/platform/HostRuntime.ts

@@ -14,12 +14,18 @@ export const IS_BROWSER =
     typeof window !== 'undefined' || (typeof self !== 'undefined' && typeof self.postMessage === 'function');
 
 export const HOST_RUNTIME = await (async(): Promise<Api.HostRuntime.HostRuntime> => {
-  if (IS_NODE) {
-    return (await import('./node/node.js')).HostRuntime.HOST_RUNTIME;
-  }
+  // Check IS_BROWSER first: in some embedder environments, both IS_NODE
+  // and IS_BROWSER can be true because `process` is available in renderer
+  // contexts. The browser runtime is always correct when browser APIs
+  // (window/self) are available; the Node.js runtime should only be used in
+  // pure Node.js environments where those APIs don't exist.
   if (IS_BROWSER) {
     return (await import('./browser/browser.js')).HostRuntime.HOST_RUNTIME;
   }
 
+  if (IS_NODE) {
+    return (await import('./node/node.js')).HostRuntime.HOST_RUNTIME;
+  }
+
   throw new Error('Unknown runtime!');
 })();

package/front_end/core/protocol_client/InspectorBackend.ts

@@ -491,6 +491,10 @@ export class TargetBase {
     return this.getAgent('WebAuthn');
   }
 
+  webMCPAgent(): ProtocolProxyApi.WebMCPApi {
+    return this.getAgent('WebMCP');
+  }
+
   // Dispatcher registration and de-registration, keep alphabetically sorted.
 
   /**
@@ -638,6 +642,10 @@ export class TargetBase {
   registerWebAuthnDispatcher(dispatcher: ProtocolProxyApi.WebAuthnDispatcher): void {
     this.registerDispatcher('WebAuthn', dispatcher);
   }
+
+  registerWebMCPDispatcher(dispatcher: ProtocolProxyApi.WebMCPDispatcher): void {
+    this.registerDispatcher('WebMCP', dispatcher);
+  }
 }
 
 /** These are not logged as console.error */

package/front_end/core/root/Runtime.ts

@@ -606,6 +606,10 @@ interface DevToolsProtocolMonitor {
   enabled: boolean;
 }
 
+interface DevToolsWebMCPSupport {
+  enabled: boolean;
+}
+
 /**
  * The host configuration that we expect from the DevTools back-end.
  *
@@ -657,6 +661,7 @@ export type HostConfig = Platform.TypeScriptUtilities.RecursivePartial<{
   devToolsConsoleInsightsTeasers: ConsoleInsightsTeasers,
   devToolsGeminiRebranding: HostConfigGeminiRebranding,
   devToolsProtocolMonitor: DevToolsProtocolMonitor,
+  devToolsWebMCPSupport: DevToolsWebMCPSupport,
 }>;
 
 /**

package/front_end/core/sdk/OverlayModel.ts

@@ -97,10 +97,10 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
     target.registerOverlayDispatcher(this);
     this.overlayAgent = target.overlayAgent();
 
+    const settings = this.target().targetManager().settings;
     this.#debuggerModel = target.model(DebuggerModel);
     if (this.#debuggerModel) {
-      Common.Settings.Settings.instance()
-          .moduleSetting('disable-paused-state-overlay')
+      settings.moduleSetting('disable-paused-state-overlay')
           .addChangeListener(this.updatePausedInDebuggerMessage, this);
       this.#debuggerModel.addEventListener(
           DebuggerModelEvents.DebuggerPaused, this.updatePausedInDebuggerMessage, this);
@@ -114,21 +114,19 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
     this.#defaultHighlighter = new DefaultHighlighter(this);
     this.#highlighter = this.#defaultHighlighter;
 
-    this.#showPaintRectsSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('show-paint-rects');
-    this.#showLayoutShiftRegionsSetting =
-        Common.Settings.Settings.instance().moduleSetting<boolean>('show-layout-shift-regions');
-    this.#showAdHighlightsSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('show-ad-highlights');
-    this.#showDebugBordersSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('show-debug-borders');
-    this.#showFPSCounterSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('show-fps-counter');
-    this.#showScrollBottleneckRectsSetting =
-        Common.Settings.Settings.instance().moduleSetting<boolean>('show-scroll-bottleneck-rects');
+    this.#showPaintRectsSetting = settings.moduleSetting<boolean>('show-paint-rects');
+    this.#showLayoutShiftRegionsSetting = settings.moduleSetting<boolean>('show-layout-shift-regions');
+    this.#showAdHighlightsSetting = settings.moduleSetting<boolean>('show-ad-highlights');
+    this.#showDebugBordersSetting = settings.moduleSetting<boolean>('show-debug-borders');
+    this.#showFPSCounterSetting = settings.moduleSetting<boolean>('show-fps-counter');
+    this.#showScrollBottleneckRectsSetting = settings.moduleSetting<boolean>('show-scroll-bottleneck-rects');
 
     if (!target.suspended()) {
       void this.overlayAgent.invoke_enable();
       void this.wireAgentToSettings();
     }
 
-    this.#persistentHighlighter = new OverlayPersistentHighlighter(this, {
+    this.#persistentHighlighter = new OverlayPersistentHighlighter(this, settings, {
       onGridOverlayStateChanged: ({nodeId, enabled}) => {
         this.#domModel.nodeForId(nodeId)?.dispatchEventToListeners(DOMNodeEvents.GRID_OVERLAY_STATE_CHANGED, {enabled});
         this.dispatchEventToListeners(Events.PERSISTENT_GRID_OVERLAY_STATE_CHANGED, {nodeId, enabled});
@@ -291,8 +289,9 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
     if (this.target().suspended()) {
       return;
     }
+    const settings = this.target().targetManager().settings;
     const message = this.#debuggerModel && this.#debuggerModel.isPaused() &&
-            !Common.Settings.Settings.instance().moduleSetting('disable-paused-state-overlay').get() ?
+            !settings.moduleSetting('disable-paused-state-overlay').get() ?
         i18nString(UIStrings.pausedInDebugger) :
         undefined;
     void this.overlayAgent.invoke_setPausedInDebuggerMessage({message});
@@ -524,7 +523,8 @@ export class OverlayModel extends SDKModel<EventTypes> implements ProtocolProxyA
 
   private buildHighlightConfig(mode: string|undefined = 'all', showDetailedToolip: boolean|undefined = false):
       Protocol.Overlay.HighlightConfig {
-    const showRulers = Common.Settings.Settings.instance().moduleSetting('show-metrics-rulers').get();
+    const settings = this.target().targetManager().settings;
+    const showRulers = settings.moduleSetting('show-metrics-rulers').get();
     const highlightConfig: Protocol.Overlay.HighlightConfig = {
       showInfo: mode === 'all' || mode === 'container-outline',
       showRulers,

package/front_end/core/sdk/OverlayPersistentHighlighter.ts

@@ -33,9 +33,7 @@ export interface PersistentHighlighterCallbacks {
 export class OverlayPersistentHighlighter {
   readonly #model: OverlayModel;
   readonly #colors = new Map<Protocol.DOM.NodeId, Common.Color.Color>();
-  readonly #persistentHighlightSetting =
-      Common.Settings.Settings.instance().createLocalSetting<PersistentHighlightSettingItem[]>(
-          'persistent-highlight-setting', []);
+  readonly #persistentHighlightSetting: Common.Settings.Setting<PersistentHighlightSettingItem[]>;
   #gridHighlights = new Map<Protocol.DOM.NodeId, Protocol.Overlay.GridHighlightConfig>();
   #scrollSnapHighlights = new Map<Protocol.DOM.NodeId, Protocol.Overlay.ScrollSnapContainerHighlightConfig>();
   #flexHighlights = new Map<Protocol.DOM.NodeId, Protocol.Overlay.FlexContainerHighlightConfig>();
@@ -47,18 +45,23 @@ export class OverlayPersistentHighlighter {
   /**
    * @see `front_end/core/sdk/sdk-meta.ts`
    */
-  readonly #showGridLineLabelsSetting =
-      Common.Settings.Settings.instance().moduleSetting<string>('show-grid-line-labels');
-  readonly #extendGridLinesSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('extend-grid-lines');
-  readonly #showGridAreasSetting = Common.Settings.Settings.instance().moduleSetting<boolean>('show-grid-areas');
-  readonly #showGridTrackSizesSetting =
-      Common.Settings.Settings.instance().moduleSetting<boolean>('show-grid-track-sizes');
+  readonly #showGridLineLabelsSetting: Common.Settings.Setting<string>;
+  readonly #extendGridLinesSetting: Common.Settings.Setting<boolean>;
+  readonly #showGridAreasSetting: Common.Settings.Setting<boolean>;
+  readonly #showGridTrackSizesSetting: Common.Settings.Setting<boolean>;
 
   readonly #callbacks: PersistentHighlighterCallbacks;
-  constructor(model: OverlayModel, callbacks: PersistentHighlighterCallbacks) {
+  constructor(model: OverlayModel, settings: Common.Settings.Settings, callbacks: PersistentHighlighterCallbacks) {
     this.#model = model;
     this.#callbacks = callbacks;
 
+    this.#persistentHighlightSetting =
+        settings.createLocalSetting<PersistentHighlightSettingItem[]>('persistent-highlight-setting', []);
+    this.#showGridLineLabelsSetting = settings.moduleSetting<string>('show-grid-line-labels');
+    this.#extendGridLinesSetting = settings.moduleSetting<boolean>('extend-grid-lines');
+    this.#showGridAreasSetting = settings.moduleSetting<boolean>('show-grid-areas');
+    this.#showGridTrackSizesSetting = settings.moduleSetting<boolean>('show-grid-track-sizes');
+
     this.#showGridLineLabelsSetting.addChangeListener(this.onSettingChange, this);
     this.#extendGridLinesSetting.addChangeListener(this.onSettingChange, this);
     this.#showGridAreasSetting.addChangeListener(this.onSettingChange, this);

package/front_end/core/sdk/RuntimeModel.ts

@@ -32,13 +32,12 @@ export class RuntimeModel extends SDKModel<EventTypes> {
     this.target().registerRuntimeDispatcher(new RuntimeDispatcher(this));
     void this.agent.invoke_enable();
 
-    if (Common.Settings.Settings.instance().moduleSetting('custom-formatters').get()) {
+    const settings = this.target().targetManager().context.get(Common.Settings.Settings);
+    if (settings.moduleSetting('custom-formatters').get()) {
       void this.agent.invoke_setCustomObjectFormatterEnabled({enabled: true});
     }
 
-    Common.Settings.Settings.instance()
-        .moduleSetting('custom-formatters')
-        .addChangeListener(this.customFormattersStateChanged.bind(this));
+    settings.moduleSetting('custom-formatters').addChangeListener(this.customFormattersStateChanged.bind(this));
   }
 
   static isSideEffectFailure(response: Protocol.Runtime.EvaluateResponse|EvaluationResult): boolean {
@@ -301,7 +300,8 @@ export class RuntimeModel extends SDKModel<EventTypes> {
       return;
     }
 
-    const indent = Common.Settings.Settings.instance().moduleSetting('text-editor-indent').get();
+    const indent =
+        this.target().targetManager().context.get(Common.Settings.Settings).moduleSetting('text-editor-indent').get();
     void object
         .callFunctionJSON(toStringForClipboard, [{
                             value: {

package/front_end/core/sdk/ServiceWorkerManager.ts

@@ -77,8 +77,10 @@ export class ServiceWorkerManager extends SDKModel<EventTypes> {
     target.registerServiceWorkerDispatcher(new ServiceWorkerDispatcher(this));
     this.#agent = target.serviceWorkerAgent();
     void this.enable();
-    this.#forceUpdateSetting =
-        Common.Settings.Settings.instance().createSetting('service-worker-update-on-reload', false);
+    this.#forceUpdateSetting = this.target()
+                                   .targetManager()
+                                   .context.get(Common.Settings.Settings)
+                                   .createSetting('service-worker-update-on-reload', false);
     if (this.#forceUpdateSetting.get()) {
       this.forceUpdateSettingChanged();
     }

package/front_end/core/sdk/Target.ts

@@ -6,6 +6,7 @@ import type * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
 import * as Platform from '../platform/platform.js';
 import * as ProtocolClient from '../protocol_client/protocol_client.js';
+import * as Root from '../root/root.js';
 
 import {SDKModel, type SDKModelConstructor} from './SDKModel.js';
 import type {TargetManager} from './TargetManager.js';
@@ -50,6 +51,9 @@ export class Target extends ProtocolClient.InspectorBackend.TargetBase {
             Capability.LOG | Capability.NETWORK | Capability.TARGET | Capability.TRACING | Capability.EMULATION |
             Capability.INPUT | Capability.INSPECTOR | Capability.AUDITS | Capability.WEB_AUTHN | Capability.IO |
             Capability.MEDIA | Capability.EVENT_BREAKPOINTS | Capability.DOM_STORAGE;
+        if (Root.Runtime.hostConfig.devToolsWebMCPSupport?.enabled) {
+          this.#capabilitiesMask |= Capability.WEB_MCP;
+        }
         if (parentTarget?.type() !== Type.FRAME) {
           // This matches backend exposing certain capabilities only for the main frame.
           this.#capabilitiesMask |=
@@ -320,5 +324,6 @@ export const enum Capability {
   MEDIA = 1 << 18,
   EVENT_BREAKPOINTS = 1 << 19,
   DOM_STORAGE = 1 << 20,
+  WEB_MCP = 1 << 21,
   NONE = 0,
 }

package/front_end/core/sdk/TargetManager.ts

@@ -26,6 +26,11 @@ export class TargetManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes
   readonly context: Root.DevToolsContext.DevToolsContext;
   #targets: Set<Target>;
   readonly #observers: Set<Observer>;
+
+  get settings(): Common.Settings.Settings {
+    return this.context.get(Common.Settings.Settings);
+  }
+
   /* eslint-disable @typescript-eslint/no-explicit-any */
   #modelListeners: Platform.MapUtilities.Multimap<string|symbol|number, {
     modelClass: SDKModelConstructor,

package/front_end/core/sdk/WebMCPModel.ts

@@ -0,0 +1,104 @@
+// 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 type * as ProtocolProxyApi from '../../generated/protocol-proxy-api.js';
+import type * as Protocol from '../../generated/protocol.js';
+import type * as Common from '../common/common.js';
+
+import {Events as RuntimeModelEvents, type ExecutionContext, RuntimeModel} from './RuntimeModel.js';
+import {SDKModel} from './SDKModel.js';
+import {Capability, type Target} from './Target.js';
+
+export const enum Events {
+  TOOLS_ADDED = 'ToolsAdded',
+  TOOLS_REMOVED = 'ToolsRemoved',
+}
+
+export interface EventTypes {
+  [Events.TOOLS_ADDED]: ReadonlyArray<Readonly<Protocol.WebMCP.Tool>>;
+  [Events.TOOLS_REMOVED]: ReadonlyArray<Readonly<Protocol.WebMCP.Tool>>;
+}
+
+export class WebMCPModel extends SDKModel<EventTypes> {
+  readonly #tools = new Map<Protocol.Page.FrameId, Map<string, Protocol.WebMCP.Tool>>();
+  readonly agent: ProtocolProxyApi.WebMCPApi;
+  #enabled = false;
+
+  constructor(target: Target) {
+    super(target);
+    this.agent = target.webMCPAgent();
+    target.registerWebMCPDispatcher(new WebMCPDispatcher(this));
+
+    const runtimeModel = target.model(RuntimeModel);
+    if (runtimeModel) {
+      runtimeModel.addEventListener(
+          RuntimeModelEvents.ExecutionContextDestroyed, this.#executionContextDestroyed, this);
+    }
+
+    void this.enable();
+  }
+
+  get tools(): IteratorObject<Protocol.WebMCP.Tool> {
+    return this.#tools.values().flatMap(toolMap => toolMap.values());
+  }
+
+  async enable(): Promise<void> {
+    if (this.#enabled) {
+      return;
+    }
+    await this.agent.invoke_enable();
+    this.#enabled = true;
+  }
+
+  #executionContextDestroyed(event: Common.EventTarget.EventTargetEvent<ExecutionContext>): void {
+    const executionContext = event.data;
+    if (executionContext.isDefault && executionContext.frameId) {
+      const frameTools = this.#tools.get(executionContext.frameId);
+      if (frameTools) {
+        const toolsToRemove = [...frameTools.values()];
+        this.#tools.delete(executionContext.frameId);
+        this.dispatchEventToListeners(Events.TOOLS_REMOVED, toolsToRemove);
+      }
+    }
+  }
+
+  onToolsRemoved(tools: Protocol.WebMCP.Tool[]): void {
+    const deletedTools = tools.filter(tool => this.#tools.get(tool.frameId)?.delete(tool.name));
+    this.dispatchEventToListeners(Events.TOOLS_REMOVED, deletedTools);
+  }
+
+  onToolsAdded(tools: Protocol.WebMCP.Tool[]): void {
+    for (const tool of tools) {
+      const frameTools = this.#tools.get(tool.frameId) ?? new Map();
+      if (!this.#tools.has(tool.frameId)) {
+        this.#tools.set(tool.frameId, frameTools);
+      }
+      frameTools.set(tool.name, tool);
+    }
+    this.dispatchEventToListeners(Events.TOOLS_ADDED, tools);
+  }
+}
+
+class WebMCPDispatcher implements ProtocolProxyApi.WebMCPDispatcher {
+  readonly #model: WebMCPModel;
+  constructor(model: WebMCPModel) {
+    this.#model = model;
+  }
+
+  toolsAdded(params: Protocol.WebMCP.ToolsAddedEvent): void {
+    this.#model.onToolsAdded(params.tools);
+  }
+
+  toolsRemoved(params: Protocol.WebMCP.ToolsRemovedEvent): void {
+    this.#model.onToolsRemoved(params.tools);
+  }
+
+  toolInvoked(): void {
+  }
+
+  toolResponded(): void {
+  }
+}
+
+SDKModel.register(WebMCPModel, {capabilities: Capability.WEB_MCP, autostart: true});

package/front_end/core/sdk/sdk.ts

@@ -90,6 +90,7 @@ import * as Target from './Target.js';
 import * as TargetManager from './TargetManager.js';
 import * as TraceObject from './TraceObject.js';
 import * as WebAuthnModel from './WebAuthnModel.js';
+import * as WebMCPModel from './WebMCPModel.js';
 
 export {
   AccessibilityModel,
@@ -173,4 +174,5 @@ export {
   TargetManager,
   TraceObject,
   WebAuthnModel,
+  WebMCPModel,
 };

package/front_end/entrypoints/heap_snapshot_worker/HeapSnapshot.ts

@@ -875,7 +875,7 @@ export abstract class HeapSnapshot {
     interfaceDefinitions: string,
     aggregates: Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregateForDiff>,
   };
-  #aggregates: Record<string, Record<string, AggregatedInfo>> = {};
+  #aggregates: Record<string, Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo>> = {};
   #aggregatesSortedFlags: Record<string, boolean> = {};
   profile: Profile;
   nodeTypeOffset!: number;
@@ -1288,7 +1288,7 @@ export abstract class HeapSnapshot {
   }
 
   aggregatesWithFilter(nodeFilter: HeapSnapshotModel.HeapSnapshotModel.NodeFilter):
-      Record<string, HeapSnapshotModel.HeapSnapshotModel.Aggregate> {
+      Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo> {
     const filter = this.createFilter(nodeFilter);
     // @ts-expect-error key is added in createFilter
     const key = filter ? filter.key : 'allObjects';
@@ -1473,8 +1473,8 @@ export abstract class HeapSnapshot {
   }
 
   getAggregatesByClassKey(sortedIndexes: boolean, key?: string, filter?: ((arg0: HeapSnapshotNode) => boolean)):
-      Record<string, HeapSnapshotModel.HeapSnapshotModel.Aggregate> {
-    let aggregates: Record<string, HeapSnapshotModel.HeapSnapshotModel.Aggregate>;
+      Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo> {
+    let aggregates: Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo>;
     if (key && this.#aggregates[key]) {
       aggregates = this.#aggregates[key];
     } else {
@@ -1504,7 +1504,7 @@ export abstract class HeapSnapshot {
       }
     }
 
-    return aggregates as Record<string, HeapSnapshotModel.HeapSnapshotModel.Aggregate>;
+    return aggregates;
   }
 
   allocationTracesTops(): HeapSnapshotModel.HeapSnapshotModel.SerializedAllocationNode[] {
@@ -1653,8 +1653,9 @@ export abstract class HeapSnapshot {
     }
   }
 
-  private buildAggregates(filter?: ((arg0: HeapSnapshotNode) => boolean)): Map<string|number, AggregatedInfo> {
-    const aggregates = new Map<string|number, AggregatedInfo>();
+  private buildAggregates(filter?: ((arg0: HeapSnapshotNode) => boolean)):
+      Map<string|number, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo> {
+    const aggregates = new Map<string|number, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo>();
 
     const nodes = this.nodes;
     const nodesLength = nodes.length;
@@ -1703,7 +1704,8 @@ export abstract class HeapSnapshot {
   }
 
   private calculateClassesRetainedSize(
-      aggregates: Map<string|number, AggregatedInfo>, filter?: ((arg0: HeapSnapshotNode) => boolean)): void {
+      aggregates: Map<string|number, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo>,
+      filter?: ((arg0: HeapSnapshotNode) => boolean)): void {
     const rootNodeIndex = this.rootNodeIndexInternal;
     const node = this.createNode(rootNodeIndex);
     const list = [rootNodeIndex];
@@ -1725,7 +1727,7 @@ export abstract class HeapSnapshot {
       const dominatedIndexTo = firstDominatedNodeIndex[nodeOrdinal + 1];
 
       if (!seen && (!filter || filter(node)) && node.selfSize()) {
-        (aggregates.get(classKey) as AggregatedInfo).maxRet += node.retainedSize();
+        (aggregates.get(classKey) as HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo).maxRet += node.retainedSize();
         if (dominatedIndexFrom !== dominatedIndexTo) {
           seenClassKeys.set(classKey, true);
           sizes.push(list.length);
@@ -1745,7 +1747,7 @@ export abstract class HeapSnapshot {
     }
   }
 
-  private sortAggregateIndexes(aggregates: Record<string, AggregatedInfo>): void {
+  private sortAggregateIndexes(aggregates: Record<string, HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo>): void {
     const nodeA = this.createNode();
     const nodeB = this.createNode();
 
@@ -2700,7 +2702,7 @@ export abstract class HeapSnapshot {
 
   private calculateDiffForClass(
       baseAggregate: HeapSnapshotModel.HeapSnapshotModel.AggregateForDiff,
-      aggregate?: HeapSnapshotModel.HeapSnapshotModel.Aggregate): HeapSnapshotModel.HeapSnapshotModel.Diff|null {
+      aggregate?: HeapSnapshotModel.HeapSnapshotModel.AggregatedInfo): HeapSnapshotModel.HeapSnapshotModel.Diff|null {
     const baseIds = baseAggregate.ids;
     const baseIndexes = baseAggregate.indexes;
     const baseSelfSizes = baseAggregate.selfSizes;
@@ -4024,11 +4026,3 @@ export class JSHeapSnapshotRetainerEdge extends HeapSnapshotRetainerEdge {
     return this.edge().isWeak();
   }
 }
-export interface AggregatedInfo {
-  count: number;
-  distance: number;
-  self: number;
-  maxRet: number;
-  name: string;
-  idxs: number[];
-}

package/front_end/generated/InspectorBackendCommands.ts

@@ -1517,8 +1517,11 @@ inspectorBackend.registerType("WebAuthn.VirtualAuthenticatorOptions", [{"name":
 inspectorBackend.registerType("WebAuthn.Credential", [{"name": "credentialId", "type": "string", "optional": false, "description": "", "typeRef": null}, {"name": "isResidentCredential", "type": "boolean", "optional": false, "description": "", "typeRef": null}, {"name": "rpId", "type": "string", "optional": true, "description": "Relying Party ID the credential is scoped to. Must be set when adding a credential.", "typeRef": null}, {"name": "privateKey", "type": "string", "optional": false, "description": "The ECDSA P-256 private key in PKCS#8 format.", "typeRef": null}, {"name": "userHandle", "type": "string", "optional": true, "description": "An opaque byte sequence with a maximum size of 64 bytes mapping the credential to a specific user.", "typeRef": null}, {"name": "signCount", "type": "number", "optional": false, "description": "Signature counter. This is incremented by one for each successful assertion. See https://w3c.github.io/webauthn/#signature-counter", "typeRef": null}, {"name": "largeBlob", "type": "string", "optional": true, "description": "The large blob associated with the credential. See https://w3c.github.io/webauthn/#sctn-large-blob-extension", "typeRef": null}, {"name": "backupEligibility", "type": "boolean", "optional": true, "description": "Assertions returned by this credential will have the backup eligibility (BE) flag set to this value. Defaults to the authenticator's defaultBackupEligibility value.", "typeRef": null}, {"name": "backupState", "type": "boolean", "optional": true, "description": "Assertions returned by this credential will have the backup state (BS) flag set to this value. Defaults to the authenticator's defaultBackupState value.", "typeRef": null}, {"name": "userName", "type": "string", "optional": true, "description": "The credential's user.name property. Equivalent to empty if not set. https://w3c.github.io/webauthn/#dom-publickeycredentialentity-name", "typeRef": null}, {"name": "userDisplayName", "type": "string", "optional": true, "description": "The credential's user.displayName property. Equivalent to empty if not set. https://w3c.github.io/webauthn/#dom-publickeycredentialuserentity-displayname", "typeRef": null}]);
 
 // WebMCP.
+inspectorBackend.registerEnum("WebMCP.InvocationStatus", {Success: "Success", Canceled: "Canceled", Error: "Error"});
 inspectorBackend.registerEvent("WebMCP.toolsAdded", ["tools"]);
 inspectorBackend.registerEvent("WebMCP.toolsRemoved", ["tools"]);
+inspectorBackend.registerEvent("WebMCP.toolInvoked", ["toolName", "frameId", "invocationId", "input"]);
+inspectorBackend.registerEvent("WebMCP.toolResponded", ["invocationId", "status", "output", "errorText", "exception"]);
 inspectorBackend.registerCommand("WebMCP.enable", [], [], "Enables the WebMCP domain, allowing events to be sent. Enabling the domain will trigger a toolsAdded event for all currently registered tools.");
 inspectorBackend.registerType("WebMCP.Annotation", [{"name": "readOnly", "type": "boolean", "optional": true, "description": "A hint indicating that the tool does not modify any state.", "typeRef": null}, {"name": "autosubmit", "type": "boolean", "optional": true, "description": "If the declarative tool was declared with the autosubmit attribute.", "typeRef": null}]);
 inspectorBackend.registerType("WebMCP.Tool", [{"name": "name", "type": "string", "optional": false, "description": "Tool name.", "typeRef": null}, {"name": "description", "type": "string", "optional": false, "description": "Tool description.", "typeRef": null}, {"name": "inputSchema", "type": "object", "optional": true, "description": "Schema for the tool's input parameters.", "typeRef": null}, {"name": "annotations", "type": "object", "optional": true, "description": "Optional annotations for the tool.", "typeRef": "WebMCP.Annotation"}, {"name": "frameId", "type": "string", "optional": false, "description": "Frame identifier associated with the tool registration.", "typeRef": "Page.FrameId"}, {"name": "backendNodeId", "type": "number", "optional": true, "description": "Optional node ID for declarative tools.", "typeRef": "DOM.BackendNodeId"}, {"name": "stackTrace", "type": "object", "optional": true, "description": "The stack trace at the time of the registration.", "typeRef": "Runtime.StackTrace"}]);

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

@@ -938,6 +938,14 @@ export namespace ProtocolMapping {
      * Event fired when tools are removed.
      */
     'WebMCP.toolsRemoved': [Protocol.WebMCP.ToolsRemovedEvent];
+    /**
+     * Event fired when a tool invocation starts.
+     */
+    'WebMCP.toolInvoked': [Protocol.WebMCP.ToolInvokedEvent];
+    /**
+     * Event fired when a tool invocation completes or fails.
+     */
+    'WebMCP.toolResponded': [Protocol.WebMCP.ToolRespondedEvent];
     /**
      * Fired when breakpoint is resolved to an actual script and location.
      * Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event.

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

@@ -4872,6 +4872,16 @@ declare namespace ProtocolProxyApi {
      */
     toolsRemoved(params: Protocol.WebMCP.ToolsRemovedEvent): void;
 
+    /**
+     * Event fired when a tool invocation starts.
+     */
+    toolInvoked(params: Protocol.WebMCP.ToolInvokedEvent): void;
+
+    /**
+     * Event fired when a tool invocation completes or fails.
+     */
+    toolResponded(params: Protocol.WebMCP.ToolRespondedEvent): void;
+
   }
 
   export interface DebuggerApi {

package/front_end/generated/protocol.ts

@@ -20602,6 +20602,15 @@ export namespace WebMCP {
     autosubmit?: boolean;
   }
 
+  /**
+   * Represents the status of a tool invocation.
+   */
+  export const enum InvocationStatus {
+    Success = 'Success',
+    Canceled = 'Canceled',
+    Error = 'Error',
+  }
+
   /**
    * Definition of a tool that can be invoked.
    */
@@ -20655,6 +20664,54 @@ export namespace WebMCP {
      */
     tools: Tool[];
   }
+
+  /**
+   * Event fired when a tool invocation starts.
+   */
+  export interface ToolInvokedEvent {
+    /**
+     * Name of the tool to invoke.
+     */
+    toolName: string;
+    /**
+     * Frame id
+     */
+    frameId: Page.FrameId;
+    /**
+     * Invocation identifier.
+     */
+    invocationId: string;
+    /**
+     * The input parameters used for the invocation.
+     */
+    input: string;
+  }
+
+  /**
+   * Event fired when a tool invocation completes or fails.
+   */
+  export interface ToolRespondedEvent {
+    /**
+     * Invocation identifier.
+     */
+    invocationId: string;
+    /**
+     * Status of the invocation.
+     */
+    status: InvocationStatus;
+    /**
+     * Output or error delivered as delivered to the agent. Missing if `status` is anything other than Success.
+     */
+    output?: any;
+    /**
+     * Error text for protocol users.
+     */
+    errorText?: string;
+    /**
+     * The exception object, if the javascript tool threw an error>
+     */
+    exception?: Runtime.RemoteObject;
+  }
 }
 
 /**

package/front_end/models/ai_assistance/AiConversation.ts

@@ -54,7 +54,7 @@ export interface AiConversationOptions {
   performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
   onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
   networkTimeCalculator?: NetworkTimeCalculator.NetworkTransferTimeCalculator;
-  lighthouseRecording?: () => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
 }
 
 export class AiConversation {
@@ -91,7 +91,7 @@ export class AiConversation {
   #contexts: Array<ConversationContext<unknown>> = [];
 
   #performanceRecordAndReload?: () => Promise<Trace.TraceModel.ParsedTrace>;
-  #lighthouseRecording?: () => Promise<LHModel.ReporterTypes.ReportJSON|null>;
+  #lighthouseRecording?: (overrides?: LHModel.RunTypes.RunOverrides) => Promise<LHModel.ReporterTypes.ReportJSON|null>;
   #onInspectElement?: () => Promise<SDK.DOMModel.DOMNode|null>;
   #networkTimeCalculator?: NetworkTimeCalculator.NetworkTransferTimeCalculator;
 
@@ -334,9 +334,9 @@ export class AiConversation {
       sessionId: this.id,
       changeManager: this.#changeManager,
       performanceRecordAndReload: this.#performanceRecordAndReload,
-      lighthouseRecording: this.#lighthouseRecording,
       onInspectElement: this.#onInspectElement,
       networkTimeCalculator: this.#networkTimeCalculator,
+      lighthouseRecording: this.#lighthouseRecording,
       allowedOrigin: this.allowedOrigin,
       history,
     };