chrome-devtools-frontend 1.0.1596260 → 1.0.1596535

package/front_end/core/common/Console.ts

@@ -2,24 +2,24 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+import * as Root from '../root/root.js';
+
 import {ObjectWrapper} from './Object.js';
 import {reveal} from './Revealer.js';
 
-let consoleInstance: Console|undefined;
-
 export class Console extends ObjectWrapper<EventTypes> {
   readonly #messages: Message[] = [];
 
   static instance(opts?: {forceNew: boolean}): Console {
-    if (!consoleInstance || opts?.forceNew) {
-      consoleInstance = new Console();
+    if (!Root.DevToolsContext.globalInstance().has(Console) || opts?.forceNew) {
+      Root.DevToolsContext.globalInstance().set(Console, new Console());
     }
 
-    return consoleInstance;
+    return Root.DevToolsContext.globalInstance().get(Console);
   }
 
   static removeInstance(): void {
-    consoleInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(Console);
   }
 
   /**

package/front_end/core/common/Settings.ts

@@ -22,8 +22,6 @@ import {
   SettingType,
 } from './SettingRegistration.js';
 
-let settingsInstance: Settings|undefined;
-
 export interface SettingsCreationOptions {
   syncedStorage: SettingsStorage;
   globalStorage: SettingsStorage;
@@ -85,7 +83,7 @@ export class Settings {
   }
 
   static hasInstance(): boolean {
-    return typeof settingsInstance !== 'undefined';
+    return Root.DevToolsContext.globalInstance().has(Settings);
   }
 
   static instance(opts: {
@@ -107,20 +105,26 @@ export class Settings {
       logSettingAccess,
       runSettingsMigration
     } = opts;
-    if (!settingsInstance || forceNew) {
+    if (!Root.DevToolsContext.globalInstance().has(Settings) || forceNew) {
       if (!syncedStorage || !globalStorage || !localStorage || !settingRegistrations) {
         throw new Error(`Unable to create settings: global and local storage must be provided: ${new Error().stack}`);
       }
 
-      settingsInstance = new Settings(
-          {syncedStorage, globalStorage, localStorage, settingRegistrations, logSettingAccess, runSettingsMigration});
+      Root.DevToolsContext.globalInstance().set(Settings, new Settings({
+                                                  syncedStorage,
+                                                  globalStorage,
+                                                  localStorage,
+                                                  settingRegistrations,
+                                                  logSettingAccess,
+                                                  runSettingsMigration
+                                                }));
     }
 
-    return settingsInstance;
+    return Root.DevToolsContext.globalInstance().get(Settings);
   }
 
   static removeInstance(): void {
-    settingsInstance = undefined;
+    Root.DevToolsContext.globalInstance().delete(Settings);
   }
 
   private registerModuleSetting(setting: Setting<unknown>): void {

package/front_end/core/root/DevToolsContext.ts

@@ -11,7 +11,14 @@ export type ConstructorT<T> = new (...args: any[]) => T;
  * via constructor, and not just pass a {@link DevToolsContext} around. That would hide
  * dependencies and we want to be explicit.
  */
-export class DevToolsContext {
+export interface DevToolsContext {
+  get<T>(ctor: ConstructorT<T>): T;
+}
+
+/**
+ * The actual implementation. Should only be accessed by test-setup code or the bootstrapper.
+ */
+export class WritableDevToolsContext implements DevToolsContext {
   readonly #instances = new Map<ConstructorT<unknown>, unknown>();
 
   get<T>(ctor: ConstructorT<T>): T {
@@ -28,8 +35,7 @@ export class DevToolsContext {
   }
 
   /**
-   * @deprecated Should only be used by existing `instance` accessors and the bootstrapper.
-   * Exists on the public interface only for migration purposes for now.
+   * Should only be used by existing `instance` accessors and the bootstrapper.
    */
   set<T>(ctor: ConstructorT<T>, instance: T): void {
     // TODO(crbug.com/458180550): We need to throw here if an instance was already set!
@@ -42,16 +48,16 @@ export class DevToolsContext {
   }
 }
 
-let gInstance: DevToolsContext|null = null;
+let gInstance: WritableDevToolsContext|null = null;
 
 /**
  * @deprecated Exists to migrate instance() methods.
  */
-export function globalInstance(): DevToolsContext {
+export function globalInstance(): WritableDevToolsContext {
   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();
+    gInstance = new WritableDevToolsContext();
   }
   return gInstance;
 }
@@ -59,6 +65,6 @@ export function globalInstance(): DevToolsContext {
 /**
  * @deprecated Should only be called by test setup and MainImpl
  */
-export function setGlobalInstance(context: DevToolsContext|null): void {
+export function setGlobalInstance(context: WritableDevToolsContext|null): void {
   gInstance = context;
 }

package/front_end/core/sdk/CPUThrottlingManager.ts

@@ -39,24 +39,27 @@ let throttlingManagerInstance: CPUThrottlingManager;
 
 export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes> implements
     SDKModelObserver<EmulationModel> {
+  readonly #targetManager: TargetManager;
   #cpuThrottlingOption: CPUThrottlingOption;
   #calibratedThrottlingSetting: Common.Settings.Setting<CalibratedCPUThrottling>;
   #hardwareConcurrency?: number;
   #pendingMainTargetPromise?: (r: number) => void;
 
-  private constructor() {
+  private constructor(settings: Common.Settings.Settings, targetManager: TargetManager) {
     super();
+    this.#targetManager = targetManager;
     this.#cpuThrottlingOption = NoThrottlingOption;
-    this.#calibratedThrottlingSetting = Common.Settings.Settings.instance().createSetting<CalibratedCPUThrottling>(
+    this.#calibratedThrottlingSetting = settings.createSetting<CalibratedCPUThrottling>(
         'calibrated-cpu-throttling', {}, Common.Settings.SettingStorageType.GLOBAL);
     this.#calibratedThrottlingSetting.addChangeListener(this.#onCalibratedSettingChanged, this);
-    TargetManager.instance().observeModels(EmulationModel, this);
+    targetManager.observeModels(EmulationModel, this);
   }
 
   static instance(opts: {forceNew: boolean|null} = {forceNew: null}): CPUThrottlingManager {
     const {forceNew} = opts;
     if (!throttlingManagerInstance || forceNew) {
-      throttlingManagerInstance = new CPUThrottlingManager();
+      throttlingManagerInstance =
+          new CPUThrottlingManager(Common.Settings.Settings.instance(), TargetManager.instance());
     }
 
     return throttlingManagerInstance;
@@ -84,7 +87,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
       return;
     }
 
-    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
       void emulationModel.setCPUThrottlingRate(rate);
     }
     this.dispatchEventToListeners(Events.RATE_CHANGED, rate);
@@ -96,7 +99,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     }
 
     this.#cpuThrottlingOption = option;
-    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
       void emulationModel.setCPUThrottlingRate(this.#cpuThrottlingOption.rate());
     }
     this.dispatchEventToListeners(Events.RATE_CHANGED, this.#cpuThrottlingOption.rate());
@@ -104,7 +107,7 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
 
   setHardwareConcurrency(concurrency: number): void {
     this.#hardwareConcurrency = concurrency;
-    for (const emulationModel of TargetManager.instance().models(EmulationModel)) {
+    for (const emulationModel of this.#targetManager.models(EmulationModel)) {
       void emulationModel.setHardwareConcurrency(concurrency);
     }
     this.dispatchEventToListeners(Events.HARDWARE_CONCURRENCY_CHANGED, this.#hardwareConcurrency);
@@ -115,14 +118,14 @@ export class CPUThrottlingManager extends Common.ObjectWrapper.ObjectWrapper<Eve
     // target may error. So if we get any errors here at all, assume that we do
     // not have a target.
     try {
-      return TargetManager.instance().primaryPageTarget() !== null;
+      return this.#targetManager.primaryPageTarget() !== null;
     } catch {
       return false;
     }
   }
 
   async getHardwareConcurrency(): Promise<number> {
-    const target = TargetManager.instance().primaryPageTarget();
+    const target = this.#targetManager.primaryPageTarget();
     const existingCallback = this.#pendingMainTargetPromise;
 
     // If the main target hasn't attached yet, block callers until it appears.

package/front_end/core/sdk/FrameManager.ts

@@ -4,14 +4,13 @@
 
 import type * as Protocol from '../../generated/protocol.js';
 import * as Common from '../common/common.js';
+import * as Root from '../root/root.js';
 
 import type {Resource} from './Resource.js';
 import {Events as ResourceTreeModelEvents, type ResourceTreeFrame, ResourceTreeModel} from './ResourceTreeModel.js';
 import type {Target} from './Target.js';
 import {type SDKModelObserver, TargetManager} from './TargetManager.js';
 
-let frameManagerInstance: FrameManager|null = null;
-
 /**
  * The FrameManager is a central storage for all #frames. It collects #frames from all
  * ResourceTreeModel-instances (one per target), so that #frames can be found by id
@@ -37,22 +36,22 @@ export class FrameManager extends Common.ObjectWrapper.ObjectWrapper<EventTypes>
   }>();
   #awaitedFrames = new Map<string, Array<{resolve: (frame: ResourceTreeFrame) => void, notInTarget?: Target}>>();
 
-  constructor() {
+  constructor(targetManager: TargetManager) {
     super();
-    TargetManager.instance().observeModels(ResourceTreeModel, this);
+    targetManager.observeModels(ResourceTreeModel, this);
   }
 
   static instance({forceNew}: {
     forceNew: boolean,
   } = {forceNew: false}): FrameManager {
-    if (!frameManagerInstance || forceNew) {
-      frameManagerInstance = new FrameManager();
+    if (!Root.DevToolsContext.globalInstance().has(FrameManager) || forceNew) {
+      Root.DevToolsContext.globalInstance().set(FrameManager, new FrameManager(TargetManager.instance()));
     }
-    return frameManagerInstance;
+    return Root.DevToolsContext.globalInstance().get(FrameManager);
   }
 
   static removeInstance(): void {
-    frameManagerInstance = null;
+    Root.DevToolsContext.globalInstance().delete(FrameManager);
   }
 
   modelAdded(resourceTreeModel: ResourceTreeModel): void {

package/front_end/entrypoints/greendev_floaty/FloatyEntrypoint.ts

@@ -431,7 +431,7 @@ async function init(): Promise<void> {
         settingRegistrations: Common.SettingRegistration.getRegisteredSettings(),
       }
     });
-    Root.DevToolsContext.setGlobalInstance(universe.context);
+    Root.DevToolsContext.setGlobalInstance(universe.context as Root.DevToolsContext.WritableDevToolsContext);
 
     await i18n.i18n.fetchAndRegisterLocaleData('en-US');
     Host.InspectorFrontendHost.InspectorFrontendHostInstance.connectionReady();

package/front_end/entrypoints/main/MainImpl.ts

@@ -201,7 +201,7 @@ export class MainImpl {
       },
     };
     this.#universe = new Foundation.Universe.Universe(creationOptions);
-    Root.DevToolsContext.setGlobalInstance(this.#universe.context);
+    Root.DevToolsContext.setGlobalInstance(this.#universe.context as Root.DevToolsContext.WritableDevToolsContext);
 
     await this.requestAndRegisterLocaleData();
 
@@ -488,7 +488,6 @@ export class MainImpl {
 
     // These instances need to be created early so they don't miss any events about requests/issues/etc.
     Logs.NetworkLog.NetworkLog.instance();
-    SDK.FrameManager.FrameManager.instance();
     Logs.LogManager.LogManager.instance();
     IssuesManager.IssuesManager.IssuesManager.instance({
       forceNew: true,

package/front_end/foundation/Universe.ts

@@ -14,38 +14,49 @@ export interface CreationOptions {
 }
 
 export class Universe {
-  readonly context = new Root.DevToolsContext.DevToolsContext();
+  readonly context: 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.
+    const context = new Root.DevToolsContext.WritableDevToolsContext();
+    this.context = context;
+
+    // TODO(crbug.com/458180550): Store instance only on this.context instead.
+    //                            For now the global is required as not everything in foundation cleanly
+    //                            reads from the scoped `Settings` instance.
     const settings = Common.Settings.Settings.instance({
       forceNew: true,
       ...options.settingsCreationOptions,
     });
+    context.set(Common.Settings.Settings, settings);
+
+    const console = new Common.Console.Console();
+    context.set(Common.Console.Console, console);
+
+    const targetManager = new SDK.TargetManager.TargetManager(context, options.overrideAutoStartModels);
+    context.set(SDK.TargetManager.TargetManager, targetManager);
 
-    const targetManager = new SDK.TargetManager.TargetManager(this.context, options.overrideAutoStartModels);
-    this.context.set(SDK.TargetManager.TargetManager, targetManager);
+    const frameManager = new SDK.FrameManager.FrameManager(targetManager);
+    context.set(SDK.FrameManager.FrameManager, frameManager);
 
     const multitargetNetworkManager = new SDK.NetworkManager.MultitargetNetworkManager(targetManager);
-    this.context.set(SDK.NetworkManager.MultitargetNetworkManager, multitargetNetworkManager);
+    context.set(SDK.NetworkManager.MultitargetNetworkManager, multitargetNetworkManager);
 
     const pageResourceLoader =
         new SDK.PageResourceLoader.PageResourceLoader(targetManager, settings, multitargetNetworkManager, null);
-    this.context.set(SDK.PageResourceLoader.PageResourceLoader, pageResourceLoader);
+    context.set(SDK.PageResourceLoader.PageResourceLoader, pageResourceLoader);
 
     const workspace = new Workspace.Workspace.WorkspaceImpl();
-    this.context.set(Workspace.Workspace.WorkspaceImpl, workspace);
+    context.set(Workspace.Workspace.WorkspaceImpl, workspace);
 
     const ignoreListManager = new Workspace.IgnoreListManager.IgnoreListManager(settings, targetManager);
-    this.context.set(Workspace.IgnoreListManager.IgnoreListManager, ignoreListManager);
+    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);
+    context.set(Bindings.CSSWorkspaceBinding.CSSWorkspaceBinding, cssWorkspaceBinding);
 
     const debuggerWorkspaceBinding = new Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding(
         resourceMapping, targetManager, ignoreListManager, workspace);
-    this.context.set(Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding, debuggerWorkspaceBinding);
+    context.set(Bindings.DebuggerWorkspaceBinding.DebuggerWorkspaceBinding, debuggerWorkspaceBinding);
   }
 }

package/front_end/generated/InspectorBackendCommands.ts

@@ -1517,6 +1517,13 @@ inspectorBackend.registerCommand("WebAuthn.setCredentialProperties", [{"name": "
 inspectorBackend.registerType("WebAuthn.VirtualAuthenticatorOptions", [{"name": "protocol", "type": "string", "optional": false, "description": "", "typeRef": "WebAuthn.AuthenticatorProtocol"}, {"name": "ctap2Version", "type": "string", "optional": true, "description": "Defaults to ctap2_0. Ignored if |protocol| == u2f.", "typeRef": "WebAuthn.Ctap2Version"}, {"name": "transport", "type": "string", "optional": false, "description": "", "typeRef": "WebAuthn.AuthenticatorTransport"}, {"name": "hasResidentKey", "type": "boolean", "optional": true, "description": "Defaults to false.", "typeRef": null}, {"name": "hasUserVerification", "type": "boolean", "optional": true, "description": "Defaults to false.", "typeRef": null}, {"name": "hasLargeBlob", "type": "boolean", "optional": true, "description": "If set to true, the authenticator will support the largeBlob extension. https://w3c.github.io/webauthn#largeBlob Defaults to false.", "typeRef": null}, {"name": "hasCredBlob", "type": "boolean", "optional": true, "description": "If set to true, the authenticator will support the credBlob extension. https://fidoalliance.org/specs/fido-v2.1-rd-20201208/fido-client-to-authenticator-protocol-v2.1-rd-20201208.html#sctn-credBlob-extension Defaults to false.", "typeRef": null}, {"name": "hasMinPinLength", "type": "boolean", "optional": true, "description": "If set to true, the authenticator will support the minPinLength extension. https://fidoalliance.org/specs/fido-v2.1-ps-20210615/fido-client-to-authenticator-protocol-v2.1-ps-20210615.html#sctn-minpinlength-extension Defaults to false.", "typeRef": null}, {"name": "hasPrf", "type": "boolean", "optional": true, "description": "If set to true, the authenticator will support the prf extension. https://w3c.github.io/webauthn/#prf-extension Defaults to false.", "typeRef": null}, {"name": "automaticPresenceSimulation", "type": "boolean", "optional": true, "description": "If set to true, tests of user presence will succeed immediately. Otherwise, they will not be resolved. Defaults to true.", "typeRef": null}, {"name": "isUserVerified", "type": "boolean", "optional": true, "description": "Sets whether User Verification succeeds or fails for an authenticator. Defaults to false.", "typeRef": null}, {"name": "defaultBackupEligibility", "type": "boolean", "optional": true, "description": "Credentials created by this authenticator will have the backup eligibility (BE) flag set to this value. Defaults to false. https://w3c.github.io/webauthn/#sctn-credential-backup", "typeRef": null}, {"name": "defaultBackupState", "type": "boolean", "optional": true, "description": "Credentials created by this authenticator will have the backup state (BS) flag set to this value. Defaults to false. https://w3c.github.io/webauthn/#sctn-credential-backup", "typeRef": null}]);
 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.registerEvent("WebMCP.toolsAdded", ["tools"]);
+inspectorBackend.registerEvent("WebMCP.toolsRemoved", ["tools"]);
+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"}]);
+
 // Debugger.
 inspectorBackend.registerEnum("Debugger.ScopeType", {Global: "global", Local: "local", With: "with", Closure: "closure", Catch: "catch", Block: "block", Script: "script", Eval: "eval", Module: "module", WasmExpressionStack: "wasm-expression-stack"});
 inspectorBackend.registerEnum("Debugger.BreakLocationType", {DebuggerStatement: "debuggerStatement", Call: "call", Return: "return"});

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

@@ -930,6 +930,14 @@ export namespace ProtocolMapping {
      * Triggered when a credential is used in a webauthn assertion.
      */
     'WebAuthn.credentialAsserted': [Protocol.WebAuthn.CredentialAssertedEvent];
+    /**
+     * Event fired when new tools are added.
+     */
+    'WebMCP.toolsAdded': [Protocol.WebMCP.ToolsAddedEvent];
+    /**
+     * Event fired when tools are removed.
+     */
+    'WebMCP.toolsRemoved': [Protocol.WebMCP.ToolsRemovedEvent];
     /**
      * Fired when breakpoint is resolved to an actual script and location.
      * Deprecated in favor of `resolvedBreakpoints` in the `scriptParsed` event.
@@ -5372,6 +5380,14 @@ export namespace ProtocolMapping {
       paramsType: [Protocol.WebAuthn.SetCredentialPropertiesRequest];
       returnType: void;
     };
+    /**
+     * Enables the WebMCP domain, allowing events to be sent. Enabling the domain will trigger a toolsAdded event for
+     * all currently registered tools.
+     */
+    'WebMCP.enable': {
+      paramsType: [];
+      returnType: void;
+    };
     /**
      * Continues execution until specific location is reached.
      */

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

@@ -114,6 +114,8 @@ declare namespace ProtocolProxyApi {
 
     WebAuthn: WebAuthnApi;
 
+    WebMCP: WebMCPApi;
+
     Debugger: DebuggerApi;
 
     HeapProfiler: HeapProfilerApi;
@@ -223,6 +225,8 @@ declare namespace ProtocolProxyApi {
 
     WebAuthn: WebAuthnDispatcher;
 
+    WebMCP: WebMCPDispatcher;
+
     Debugger: DebuggerDispatcher;
 
     HeapProfiler: HeapProfilerDispatcher;
@@ -4849,6 +4853,27 @@ declare namespace ProtocolProxyApi {
 
   }
 
+  export interface WebMCPApi {
+    /**
+     * Enables the WebMCP domain, allowing events to be sent. Enabling the domain will trigger a toolsAdded event for
+     * all currently registered tools.
+     */
+    invoke_enable(): Promise<Protocol.ProtocolResponseWithError>;
+
+  }
+  export interface WebMCPDispatcher {
+    /**
+     * Event fired when new tools are added.
+     */
+    toolsAdded(params: Protocol.WebMCP.ToolsAddedEvent): void;
+
+    /**
+     * Event fired when tools are removed.
+     */
+    toolsRemoved(params: Protocol.WebMCP.ToolsRemovedEvent): void;
+
+  }
+
   export interface DebuggerApi {
     /**
      * Continues execution until specific location is reached.

package/front_end/generated/protocol.ts

@@ -20584,6 +20584,77 @@ export namespace WebAuthn {
   }
 }
 
+export namespace WebMCP {
+
+  /**
+   * Tool annotations
+   */
+  export interface Annotation {
+    /**
+     * A hint indicating that the tool does not modify any state.
+     */
+    readOnly?: boolean;
+    /**
+     * If the declarative tool was declared with the autosubmit attribute.
+     */
+    autosubmit?: boolean;
+  }
+
+  /**
+   * Definition of a tool that can be invoked.
+   */
+  export interface Tool {
+    /**
+     * Tool name.
+     */
+    name: string;
+    /**
+     * Tool description.
+     */
+    description: string;
+    /**
+     * Schema for the tool's input parameters.
+     */
+    inputSchema?: any;
+    /**
+     * Optional annotations for the tool.
+     */
+    annotations?: Annotation;
+    /**
+     * Frame identifier associated with the tool registration.
+     */
+    frameId: Page.FrameId;
+    /**
+     * Optional node ID for declarative tools.
+     */
+    backendNodeId?: DOM.BackendNodeId;
+    /**
+     * The stack trace at the time of the registration.
+     */
+    stackTrace?: Runtime.StackTrace;
+  }
+
+  /**
+   * Event fired when new tools are added.
+   */
+  export interface ToolsAddedEvent {
+    /**
+     * Array of tools that were added.
+     */
+    tools: Tool[];
+  }
+
+  /**
+   * Event fired when tools are removed.
+   */
+  export interface ToolsRemovedEvent {
+    /**
+     * Array of tools that were removed.
+     */
+    tools: Tool[];
+  }
+}
+
 /**
  * Debugger domain exposes JavaScript debugging capabilities. It allows setting and removing
  * breakpoints, stepping through execution, exploring stack traces, etc.