chore(mcp): use page.consoleMessages() API instead of local array

docs/src/api/class-page.md

@@ -2727,6 +2727,11 @@ Returns whether the element is [visible](../actionability.md#visible). [`param:
 
 Clears all stored console messages from this page. Subsequent calls to [`method: Page.consoleMessages`] will only return messages logged after the clear.
 
+## async method: Page.clearPageErrors
+* since: v1.59
+
+Clears all stored page errors from this page. Subsequent calls to [`method: Page.pageErrors`] will only return errors thrown after the clear.
+
 ## async method: Page.consoleMessages
 * since: v1.56
 - returns: <[Array]<[ConsoleMessage]>>

packages/playwright-client/types/types.d.ts

@@ -2263,6 +2263,13 @@ export interface Page {
    */
   clearConsoleMessages(): Promise<void>;
 
+  /**
+   * Clears all stored page errors from this page. Subsequent calls to
+   * [page.pageErrors()](https://playwright.dev/docs/api/class-page#page-page-errors) will only return errors thrown
+   * after the clear.
+   */
+  clearPageErrors(): Promise<void>;
+
   /**
    * **NOTE** Use locator-based [locator.click([options])](https://playwright.dev/docs/api/class-locator#locator-click) instead.
    * Read more about [locators](https://playwright.dev/docs/locators).

packages/playwright-core/src/client/page.ts

@@ -664,6 +664,10 @@ export class Page extends ChannelOwner<channels.PageChannel> implements api.Page
     return messages.map(message => new ConsoleMessage(this._platform, message, this, null));
   }
 
+  async clearPageErrors(): Promise<void> {
+    await this._channel.clearPageErrors();
+  }
+
   async pageErrors(): Promise<Error[]> {
     const { errors } = await this._channel.pageErrors();
     return errors.map(error => parseError(error));

packages/playwright-core/src/protocol/validator.ts

@@ -1427,6 +1427,8 @@ scheme.PageTouchscreenTapParams = tObject({
   y: tFloat,
 });
 scheme.PageTouchscreenTapResult = tOptional(tObject({}));
+scheme.PageClearPageErrorsParams = tOptional(tObject({}));
+scheme.PageClearPageErrorsResult = tOptional(tObject({}));
 scheme.PagePageErrorsParams = tOptional(tObject({}));
 scheme.PagePageErrorsResult = tObject({
   errors: tArray(tType('SerializedError')),

packages/playwright-core/src/server/dispatchers/pageDispatcher.ts

@@ -284,6 +284,10 @@ export class PageDispatcher extends Dispatcher<Page, channels.PageChannel, Brows
     return { messages: this._page.consoleMessages().map(message => this.parentScope().serializeConsoleMessage(message, this)) };
   }
 
+  async clearPageErrors(params: channels.PageClearPageErrorsParams, progress: Progress): Promise<channels.PageClearPageErrorsResult> {
+    this._page.clearPageErrors();
+  }
+
   async pageErrors(params: channels.PagePageErrorsParams, progress: Progress): Promise<channels.PagePageErrorsResult> {
     return { errors: this._page.pageErrors().map(error => serializeError(error)) };
   }

packages/playwright-core/src/server/page.ts

@@ -419,6 +419,10 @@ export class Page extends SdkObject<PageEventMap> {
       this.emitOnContext(BrowserContext.Events.PageError, pageError, this);
   }
 
+  clearPageErrors() {
+    this._pageErrors.length = 0;
+  }
+
   pageErrors() {
     return this._pageErrors;
   }

packages/playwright-core/src/utils/isomorphic/protocolMetainfo.ts

@@ -133,6 +133,7 @@ export const methodMetainfo = new Map<string, { internal?: boolean, title?: stri
   ['Page.mouseClick', { title: 'Click', slowMo: true, snapshot: true, pausesBeforeAction: true, }],
   ['Page.mouseWheel', { title: 'Mouse wheel', slowMo: true, snapshot: true, pausesBeforeAction: true, }],
   ['Page.touchscreenTap', { title: 'Tap', slowMo: true, snapshot: true, pausesBeforeAction: true, }],
+  ['Page.clearPageErrors', { title: 'Clear page errors', }],
   ['Page.pageErrors', { title: 'Get page errors', group: 'getter', }],
   ['Page.pdf', { title: 'PDF', }],
   ['Page.requests', { title: 'Get network requests', group: 'getter', }],

packages/playwright-core/types/types.d.ts

@@ -2263,6 +2263,13 @@ export interface Page {
    */
   clearConsoleMessages(): Promise<void>;
 
+  /**
+   * Clears all stored page errors from this page. Subsequent calls to
+   * [page.pageErrors()](https://playwright.dev/docs/api/class-page#page-page-errors) will only return errors thrown
+   * after the clear.
+   */
+  clearPageErrors(): Promise<void>;
+
   /**
    * **NOTE** Use locator-based [locator.click([options])](https://playwright.dev/docs/api/class-locator#locator-click) instead.
    * Read more about [locators](https://playwright.dev/docs/locators).

packages/playwright/src/mcp/browser/tab.ts

@@ -91,7 +91,6 @@ export class Tab extends EventEmitter<TabEventsInterface> {
   readonly context: Context;
   readonly page: Page;
   private _lastHeader: TabHeader = { title: 'about:blank', url: 'about:blank', current: false, console: { total: 0, warnings: 0, errors: 0 } };
-  private _consoleMessages: ConsoleMessage[] = [];
   private _downloads: Download[] = [];
   private _requests: playwright.Request[] = [];
   private _onPageClose: (tab: Tab) => void;
@@ -201,7 +200,6 @@ export class Tab extends EventEmitter<TabEventsInterface> {
   }
 
   private _clearCollectedArtifacts() {
-    this._consoleMessages.length = 0;
     this._downloads.length = 0;
     this._requests.length = 0;
     this._recentEventEntries.length = 0;
@@ -236,7 +234,6 @@ export class Tab extends EventEmitter<TabEventsInterface> {
   }
 
   private _handleConsoleMessage(message: ConsoleMessage) {
-    this._consoleMessages.push(message);
     const wallTime = message.timestamp;
     this._addLogEntry({ type: 'console', wallTime, message });
     const level = consoleLevelForMessageType(message.type);
@@ -283,6 +280,8 @@ export class Tab extends EventEmitter<TabEventsInterface> {
 
   async navigate(url: string) {
     await this._initializedPromise;
+
+    await this.clearConsoleMessages();
     this._clearCollectedArtifacts();
 
     const { promise: downloadEvent, abort: abortDownloadEvent } = eventWaiter<playwright.Download>(this.page, 'download', 3000);
@@ -311,25 +310,42 @@ export class Tab extends EventEmitter<TabEventsInterface> {
 
   async consoleMessageCount(): Promise<{ total: number, errors: number, warnings: number }> {
     await this._initializedPromise;
-    let errors = 0;
+    const messages = await this.page.consoleMessages();
+    const pageErrors = await this.page.pageErrors();
+    let errors = pageErrors.length;
     let warnings = 0;
-    for (const message of this._consoleMessages) {
-      if (message.type === 'error')
+    for (const message of messages) {
+      if (message.type() === 'error')
         errors++;
-      else if (message.type === 'warning')
+      else if (message.type() === 'warning')
         warnings++;
     }
-    return { total: this._consoleMessages.length, errors, warnings };
+    return { total: messages.length + pageErrors.length, errors, warnings };
   }
 
   async consoleMessages(level: ConsoleMessageLevel): Promise<ConsoleMessage[]> {
     await this._initializedPromise;
-    return this._consoleMessages.filter(message => shouldIncludeMessage(level, message.type));
+    const result: ConsoleMessage[] = [];
+    const messages = await this.page.consoleMessages();
+    for (const message of messages) {
+      const cm = messageToConsoleMessage(message);
+      if (shouldIncludeMessage(level, cm.type))
+        result.push(cm);
+    }
+    if (shouldIncludeMessage(level, 'error')) {
+      const errors = await this.page.pageErrors();
+      for (const error of errors)
+        result.push(pageErrorToConsoleMessage(error));
+    }
+    return result;
   }
 
   async clearConsoleMessages() {
     await this._initializedPromise;
-    this._consoleMessages.length = 0;
+    await Promise.all([
+      this.page.clearConsoleMessages(),
+      this.page.clearPageErrors()
+    ]);
   }
 
   async requests(): Promise<playwright.Request[]> {

packages/protocol/src/channels.d.ts

@@ -2098,6 +2098,7 @@ export interface PageChannel extends PageEventTarget, EventTargetChannel {
   mouseClick(params: PageMouseClickParams, progress?: Progress): Promise<PageMouseClickResult>;
   mouseWheel(params: PageMouseWheelParams, progress?: Progress): Promise<PageMouseWheelResult>;
   touchscreenTap(params: PageTouchscreenTapParams, progress?: Progress): Promise<PageTouchscreenTapResult>;
+  clearPageErrors(params?: PageClearPageErrorsParams, progress?: Progress): Promise<PageClearPageErrorsResult>;
   pageErrors(params?: PagePageErrorsParams, progress?: Progress): Promise<PagePageErrorsResult>;
   pdf(params: PagePdfParams, progress?: Progress): Promise<PagePdfResult>;
   requests(params?: PageRequestsParams, progress?: Progress): Promise<PageRequestsResult>;
@@ -2495,6 +2496,9 @@ export type PageTouchscreenTapOptions = {
 
 };
 export type PageTouchscreenTapResult = void;
+export type PageClearPageErrorsParams = {};
+export type PageClearPageErrorsOptions = {};
+export type PageClearPageErrorsResult = void;
 export type PagePageErrorsParams = {};
 export type PagePageErrorsOptions = {};
 export type PagePageErrorsResult = {

packages/protocol/src/protocol.yml

@@ -1920,6 +1920,9 @@ Page:
         snapshot: true
         pausesBeforeAction: true
 
+    clearPageErrors:
+      title: Clear page errors
+
     pageErrors:
       title: Get page errors
       group: getter

tests/page/page-event-pageerror.spec.ts

@@ -169,6 +169,32 @@ it('pageErrors should work', async ({ page }) => {
   expect(messages.slice(messages.length - expected.length), 'should return last errors').toEqual(expected);
 });
 
+it('clearPageErrors should work', async ({ page }) => {
+  await page.evaluate(() => {
+    window.builtins.setTimeout(() => { throw new Error('error1'); }, 0);
+    window.builtins.setTimeout(() => { throw new Error('error2'); }, 0);
+  });
+  await page.waitForTimeout(1000);
+
+  let errors = await page.pageErrors();
+  expect(errors.map(e => e.message)).toContain('error1');
+  expect(errors.map(e => e.message)).toContain('error2');
+
+  await page.clearPageErrors();
+
+  errors = await page.pageErrors();
+  expect(errors).toEqual([]);
+
+  await page.evaluate(() => {
+    window.builtins.setTimeout(() => { throw new Error('error3'); }, 0);
+  });
+  await page.waitForTimeout(1000);
+
+  errors = await page.pageErrors();
+  expect(errors.length).toBe(1);
+  expect(errors[0].message).toContain('error3');
+});
+
 it('should fire illegal character error', {
   annotation: { type: 'issue', description: 'https://github.com/microsoft/playwright/issues/38388' },
 }, async ({ page, server, browserName, isWindows }) => {