playwright 1.58.0-alpha-2025-12-03 → 1.58.0-alpha-2025-12-05

package/lib/agents/agent.js

@@ -21,10 +21,10 @@ __export(agent_exports, {
   Agent: () => Agent
 });
 module.exports = __toCommonJS(agent_exports);
-var import_bundle = require("../mcp/sdk/bundle");
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
 class Agent {
   constructor(loopName, spec, clients, resultSchema) {
-    this.loop = new import_bundle.Loop(loopName, { model: spec.model });
+    this.loop = new import_mcpBundle.Loop(loopName, { model: spec.model });
     this.spec = spec;
     this.clients = clients;
     this.resultSchema = resultSchema;

package/lib/agents/performTask.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,36 +17,147 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var performTask_exports = {};
 __export(performTask_exports, {
+  performCache: () => performCache,
   performTask: () => performTask
 });
 module.exports = __toCommonJS(performTask_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
 var import_browserContextFactory = require("../mcp/browser/browserContextFactory");
 var import_browserServerBackend = require("../mcp/browser/browserServerBackend");
 var import_config = require("../mcp/browser/config");
-var import_bundle = require("../mcp/sdk/bundle");
 var import_server = require("../mcp/sdk/server");
-async function performTask(context, task) {
+const resultSchema = import_mcpBundle.z.object({
+  code: import_mcpBundle.z.string().optional().describe(`
+Generated code to perform the task using Playwright API.
+Check out the <code> blocks and combine them. Should be presented in the following form:
+
+perform(async ({ page }) => {
+  // generated code here.
+});
+`),
+  error: import_mcpBundle.z.string().optional().describe("The error that occurred if execution failed.").optional()
+});
+async function performTask(testInfo, context, userTask, options) {
+  const cacheStatus = await performTaskFromCache(testInfo, context, userTask);
+  if (cacheStatus === "success")
+    return;
   const backend = new import_browserServerBackend.BrowserServerBackend(import_config.defaultConfig, (0, import_browserContextFactory.identityBrowserContextFactory)(context));
   const client = await (0, import_server.wrapInClient)(backend, { name: "Internal", version: "0.0.0" });
-  const loop = new import_bundle.Loop("github", { model: "claude-sonnet-4.5" });
   const callTool = async (params) => {
     return await client.callTool(params);
   };
+  const loop = new import_mcpBundle.Loop(options.provider ?? "github", {
+    model: options.model ?? "claude-sonnet-4.5",
+    reasoning: options.reasoning,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    summarize: true,
+    debug: import_utilsBundle.debug,
+    callTool,
+    tools: await backend.listTools()
+  });
   try {
-    return await loop.run(task, {
-      tools: await backend.listTools(),
-      callTool,
-      debug: import_utilsBundle.debug
-    });
+    const result = await loop.run(userTask, { resultSchema: (0, import_mcpBundle.zodToJsonSchema)(resultSchema) });
+    if (result.code)
+      await updatePerformFile(testInfo, userTask, result.code, options);
   } finally {
     await client.close();
   }
 }
+async function updatePerformFile(testInfo, userTask, taskCode, options) {
+  const relativeFile = import_path.default.relative(testInfo.project.testDir, testInfo.file);
+  const promptCacheFile = testInfo.file.replace(".spec.ts", ".cache.ts");
+  const testTitle = testInfo.title;
+  const loop = new import_mcpBundle.Loop(options.provider ?? "github", {
+    model: options.model ?? "claude-sonnet-4.5",
+    reasoning: options.reasoning,
+    temperature: options.temperature,
+    maxTokens: options.maxTokens,
+    summarize: true,
+    debug: import_utilsBundle.debug,
+    callTool: async () => ({ content: [] }),
+    tools: []
+  });
+  const resultSchema2 = import_mcpBundle.z.object({
+    code: import_mcpBundle.z.string().optional().describe(`
+Generated code with all the perofrm routines combined or updated into the following format:
+
+import { performCache } from '@playwright/test';
+
+performCache({
+  file: 'tests/page/perform-task.spec.ts',
+  test: 'perform task',
+  task: 'Click the learn more button',
+  code: async ({ page }) => {
+    await page.getByRole('link', { name: 'Learn more' }).click();
+  },
+});
+`)
+  });
+  const existingCode = await import_fs.default.promises.readFile(promptCacheFile, "utf8").catch(() => "");
+  const task = `
+- Create or update a perform file to include performCache block for the given task and code.
+- Dedupe items with the same file, test, and task.
+- Should produce code in the following format
+
+import { performCache } from '@playwright/test';
+
+performCache({
+  file: '<file>',
+  test: '<test>',
+  task: '<task>',
+  code: async ({ page }) => {
+    <code>
+  },
+});
+
+performCache({
+...
+
+## Params for the new or updated performCache block
+<file-content>${existingCode}</file-content>
+<file>${relativeFile}</file>
+<test>${testTitle}</test>
+<task>${userTask}</task>
+<code>${taskCode}</code>
+`;
+  const result = await loop.run(task, { resultSchema: (0, import_mcpBundle.zodToJsonSchema)(resultSchema2) });
+  if (result.code)
+    await import_fs.default.promises.writeFile(promptCacheFile, result.code);
+}
+const performCacheMap = /* @__PURE__ */ new Map();
+function performCache(entry) {
+  performCacheMap.set(JSON.stringify({ ...entry, code: void 0 }), entry);
+}
+async function performTaskFromCache(testInfo, context, userTask) {
+  const relativeFile = import_path.default.relative(testInfo.project.testDir, testInfo.file);
+  const key = JSON.stringify({ file: relativeFile, test: testInfo.title, task: userTask });
+  const entry = performCacheMap.get(key);
+  if (!entry)
+    return "cache-miss";
+  try {
+    await entry.code({ page: context.pages()[0] });
+    return "success";
+  } catch (error) {
+    return error;
+  }
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  performCache,
   performTask
 });

package/lib/index.js

@@ -33,6 +33,7 @@ __export(index_exports, {
   expect: () => import_expect.expect,
   mergeExpects: () => import_expect2.mergeExpects,
   mergeTests: () => import_testType2.mergeTests,
+  performCache: () => import_performTask2.performCache,
   test: () => test
 });
 module.exports = __toCommonJS(index_exports);
@@ -48,6 +49,7 @@ var import_expect = require("./matchers/expect");
 var import_configLoader = require("./common/configLoader");
 var import_testType2 = require("./common/testType");
 var import_expect2 = require("./matchers/expect");
+var import_performTask2 = require("./agents/performTask");
 const _baseTest = import_testType.rootTestType.test;
 (0, import_utils.setBoxedStackPrefixes)([import_path.default.dirname(require.resolve("../package.json"))]);
 if (process["__pw_initiator__"]) {
@@ -417,9 +419,9 @@ const playwrightFixtures = {
       await request.dispose();
     }
   },
-  _perform: async ({ context }, use) => {
-    await use(async (task) => {
-      await (0, import_performTask.performTask)(context, task);
+  _perform: async ({ context }, use, testInfo) => {
+    await use(async (task, options) => {
+      await (0, import_performTask.performTask)(testInfo, context, task, options ?? {});
     });
   }
 };
@@ -684,5 +686,6 @@ const test = _baseTest.extend(playwrightFixtures);
   expect,
   mergeExpects,
   mergeTests,
+  performCache,
   test
 });

package/lib/mcp/browser/browserContextFactory.js

@@ -216,6 +216,8 @@ class PersistentContextFactory {
     });
     await afterClose();
     this._userDataDirs.delete(userDataDir);
+    if (process.env.PWMCP_PROFILES_DIR_FOR_TEST && userDataDir.startsWith(process.env.PWMCP_PROFILES_DIR_FOR_TEST))
+      await import_fs.default.promises.rm(userDataDir, { recursive: true }).catch(import_log.logUnhandledError);
     (0, import_log.testDebug)("close browser context complete (persistent)");
   }
   async _createUserDataDir(clientInfo) {

package/lib/mcp/browser/browserServerBackend.js

@@ -64,7 +64,8 @@ class BrowserServerBackend {
       context.setRunningTool(void 0);
     }
     response.logEnd();
-    return response.serialize();
+    const _meta = rawArguments?._meta;
+    return response.serialize({ _meta });
   }
   serverClosed() {
     void this._context?.dispose().catch(import_log.logUnhandledError);

package/lib/mcp/browser/config.js

@@ -32,6 +32,7 @@ __export(config_exports, {
   configFromCLIOptions: () => configFromCLIOptions,
   defaultConfig: () => defaultConfig,
   dotenvFileLoader: () => dotenvFileLoader,
+  enumParser: () => enumParser,
   headerParser: () => headerParser,
   numberParser: () => numberParser,
   outputDir: () => outputDir,
@@ -61,6 +62,9 @@ const defaultConfig = {
       viewport: null
     }
   },
+  console: {
+    level: "info"
+  },
   network: {
     allowedOrigins: void 0,
     blockedOrigins: void 0
@@ -182,6 +186,9 @@ function configFromCLIOptions(cliOptions) {
       allowedHosts: cliOptions.allowedHosts
     },
     capabilities: cliOptions.caps,
+    console: {
+      level: cliOptions.consoleLevel
+    },
     network: {
       allowedOrigins: cliOptions.allowedOrigins,
       blockedOrigins: cliOptions.blockedOrigins
@@ -213,6 +220,8 @@ function configFromEnv() {
   options.cdpEndpoint = envToString(process.env.PLAYWRIGHT_MCP_CDP_ENDPOINT);
   options.cdpHeader = headerParser(process.env.PLAYWRIGHT_MCP_CDP_HEADERS, {});
   options.config = envToString(process.env.PLAYWRIGHT_MCP_CONFIG);
+  if (process.env.PLAYWRIGHT_MCP_CONSOLE_LEVEL)
+    options.consoleLevel = enumParser("--console-level", ["error", "warning", "info", "debug"], process.env.PLAYWRIGHT_MCP_CONSOLE_LEVEL);
   options.device = envToString(process.env.PLAYWRIGHT_MCP_DEVICE);
   options.executablePath = envToString(process.env.PLAYWRIGHT_MCP_EXECUTABLE_PATH);
   options.grantPermissions = commaSeparatedList(process.env.PLAYWRIGHT_MCP_GRANT_PERMISSIONS);
@@ -226,8 +235,8 @@ function configFromEnv() {
   if (initScript)
     options.initScript = [initScript];
   options.isolated = envToBoolean(process.env.PLAYWRIGHT_MCP_ISOLATED);
-  if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES === "omit")
-    options.imageResponses = "omit";
+  if (process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES)
+    options.imageResponses = enumParser("--image-responses", ["allow", "omit"], process.env.PLAYWRIGHT_MCP_IMAGE_RESPONSES);
   options.sandbox = envToBoolean(process.env.PLAYWRIGHT_MCP_SANDBOX);
   options.outputDir = envToString(process.env.PLAYWRIGHT_MCP_OUTPUT_DIR);
   options.port = numberParser(process.env.PLAYWRIGHT_MCP_PORT);
@@ -306,6 +315,10 @@ function mergeConfig(base, overrides) {
     ...pickDefined(base),
     ...pickDefined(overrides),
     browser,
+    console: {
+      ...pickDefined(base.console),
+      ...pickDefined(overrides.console)
+    },
     network: {
       ...pickDefined(base.network),
       ...pickDefined(overrides.network)
@@ -369,6 +382,11 @@ function headerParser(arg, previous) {
   result[name] = value;
   return result;
 }
+function enumParser(name, options, value) {
+  if (!options.includes(value))
+    throw new Error(`Invalid ${name}: ${value}. Valid values are: ${options.join(", ")}`);
+  return value;
+}
 function envToBoolean(value) {
   if (value === "true" || value === "1")
     return true;
@@ -392,6 +410,7 @@ function sanitizeForFilePath(s) {
   configFromCLIOptions,
   defaultConfig,
   dotenvFileLoader,
+  enumParser,
   headerParser,
   numberParser,
   outputDir,

package/lib/mcp/browser/response.js

@@ -18,6 +18,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var response_exports = {};
 __export(response_exports, {
+  RenderedResponse: () => RenderedResponse,
   Response: () => Response,
   parseResponse: () => parseResponse,
   requestDebug: () => requestDebug
@@ -71,6 +72,9 @@ class Response {
   setIncludeTabs() {
     this._includeTabs = true;
   }
+  setIncludeModalStates(modalStates) {
+    this._includeModalStates = modalStates;
+  }
   async finish() {
     if (this._includeSnapshot !== "none" && this._context.currentTab())
       this._tabSnapshot = await this._context.currentTabOrDie().captureSnapshot();
@@ -89,72 +93,64 @@ class Response {
       requestDebug(this.serialize({ omitSnapshot: true, omitBlobs: true }));
   }
   serialize(options = {}) {
-    const response = [];
-    if (this._result.length) {
-      response.push("### Result");
-      response.push(this._result.join("\n"));
-      response.push("");
-    }
-    if (this._code.length) {
-      response.push(`### Ran Playwright code
-\`\`\`js
-${this._code.join("\n")}
-\`\`\``);
-      response.push("");
+    const renderedResponse = new RenderedResponse();
+    if (this._result.length)
+      renderedResponse.results.push(...this._result);
+    if (this._code.length)
+      renderedResponse.code.push(...this._code);
+    if (this._includeSnapshot !== "none" || this._includeTabs) {
+      const tabsMarkdown = renderTabsMarkdown(this._context.tabs(), this._includeTabs);
+      if (tabsMarkdown.length)
+        renderedResponse.states.tabs = tabsMarkdown.join("\n");
     }
-    if (this._includeSnapshot !== "none" || this._includeTabs)
-      response.push(...renderTabsMarkdown(this._context.tabs(), this._includeTabs));
     if (this._tabSnapshot?.modalStates.length) {
-      response.push(...(0, import_tab.renderModalStates)(this._context, this._tabSnapshot.modalStates));
-      response.push("");
+      const modalStatesMarkdown = (0, import_tab.renderModalStates)(this._tabSnapshot.modalStates);
+      renderedResponse.states.modal = modalStatesMarkdown.join("\n");
     } else if (this._tabSnapshot) {
       const includeSnapshot = options.omitSnapshot ? "none" : this._includeSnapshot;
-      response.push(renderTabSnapshot(this._tabSnapshot, includeSnapshot));
-      response.push("");
+      renderTabSnapshot(this._tabSnapshot, includeSnapshot, renderedResponse);
+    } else if (this._includeModalStates) {
+      const modalStatesMarkdown = (0, import_tab.renderModalStates)(this._includeModalStates);
+      renderedResponse.states.modal = modalStatesMarkdown.join("\n");
     }
+    const redactedResponse = this._context.config.secrets ? renderedResponse.redact(this._context.config.secrets) : renderedResponse;
+    const includeMeta = options._meta && "dev.lowire/history" in options._meta && "dev.lowire/state" in options._meta;
+    const _meta = includeMeta ? redactedResponse.asMeta() : void 0;
     const content = [
-      { type: "text", text: response.join("\n") }
+      { type: "text", text: redactedResponse.asText() }
     ];
     if (this._context.config.imageResponses !== "omit") {
       for (const image of this._images)
         content.push({ type: "image", data: options.omitBlobs ? "<blob>" : image.data.toString("base64"), mimeType: image.contentType });
     }
-    this._redactSecrets(content);
-    return { content, isError: this._isError };
-  }
-  _redactSecrets(content) {
-    if (!this._context.config.secrets)
-      return;
-    for (const item of content) {
-      if (item.type !== "text")
-        continue;
-      for (const [secretName, secretValue] of Object.entries(this._context.config.secrets))
-        item.text = item.text.replaceAll(secretValue, `<secret>${secretName}</secret>`);
-    }
+    return {
+      _meta,
+      content,
+      isError: this._isError
+    };
   }
 }
-function renderTabSnapshot(tabSnapshot, includeSnapshot) {
-  const lines = [];
+function renderTabSnapshot(tabSnapshot, includeSnapshot, response) {
   if (tabSnapshot.consoleMessages.length) {
-    lines.push(`### New console messages`);
+    const lines2 = [];
     for (const message of tabSnapshot.consoleMessages)
-      lines.push(`- ${trim(message.toString(), 100)}`);
-    lines.push("");
+      lines2.push(`- ${trim(message.toString(), 100)}`);
+    response.updates.push({ category: "console", content: lines2.join("\n") });
   }
   if (tabSnapshot.downloads.length) {
-    lines.push(`### Downloads`);
+    const lines2 = [];
     for (const entry of tabSnapshot.downloads) {
       if (entry.finished)
-        lines.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
+        lines2.push(`- Downloaded file ${entry.download.suggestedFilename()} to ${entry.outputFile}`);
       else
-        lines.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
+        lines2.push(`- Downloading file ${entry.download.suggestedFilename()} ...`);
     }
-    lines.push("");
+    response.updates.push({ category: "downloads", content: lines2.join("\n") });
   }
   if (includeSnapshot === "incremental" && tabSnapshot.ariaSnapshotDiff === "") {
-    return lines.join("\n");
+    return;
   }
-  lines.push(`### Page state`);
+  const lines = [];
   lines.push(`- Page URL: ${tabSnapshot.url}`);
   lines.push(`- Page Title: ${tabSnapshot.title}`);
   if (includeSnapshot !== "none") {
@@ -166,25 +162,19 @@ function renderTabSnapshot(tabSnapshot, includeSnapshot) {
       lines.push(tabSnapshot.ariaSnapshot);
     lines.push("```");
   }
-  return lines.join("\n");
+  response.states.page = lines.join("\n");
 }
 function renderTabsMarkdown(tabs, force = false) {
   if (tabs.length === 1 && !force)
     return [];
-  if (!tabs.length) {
-    return [
-      "### Open tabs",
-      'No open tabs. Use the "browser_navigate" tool to navigate to a page first.',
-      ""
-    ];
-  }
-  const lines = ["### Open tabs"];
+  if (!tabs.length)
+    return ['No open tabs. Use the "browser_navigate" tool to navigate to a page first.'];
+  const lines = [];
   for (let i = 0; i < tabs.length; i++) {
     const tab = tabs[i];
     const current = tab.isCurrentTab() ? " (current)" : "";
     lines.push(`- ${i}:${current} [${tab.lastTitle()}] (${tab.page.url()})`);
   }
-  lines.push("");
   return lines;
 }
 function trim(text, maxLength) {
@@ -192,6 +182,90 @@ function trim(text, maxLength) {
     return text;
   return text.slice(0, maxLength) + "...";
 }
+class RenderedResponse {
+  constructor(copy) {
+    this.states = {};
+    this.updates = [];
+    this.results = [];
+    this.code = [];
+    if (copy) {
+      this.states = copy.states;
+      this.updates = copy.updates;
+      this.results = copy.results;
+      this.code = copy.code;
+    }
+  }
+  asText() {
+    const text = [];
+    if (this.results.length)
+      text.push(`### Result
+${this.results.join("\n")}
+`);
+    if (this.code.length)
+      text.push(`### Ran Playwright code
+${this.code.join("\n")}
+`);
+    for (const { category, content } of this.updates) {
+      if (!content.trim())
+        continue;
+      switch (category) {
+        case "console":
+          text.push(`### New console messages
+${content}
+`);
+          break;
+        case "downloads":
+          text.push(`### Downloads
+${content}
+`);
+          break;
+      }
+    }
+    for (const [category, value] of Object.entries(this.states)) {
+      if (!value.trim())
+        continue;
+      switch (category) {
+        case "page":
+          text.push(`### Page state
+${value}
+`);
+          break;
+        case "tabs":
+          text.push(`### Open tabs
+${value}
+`);
+          break;
+        case "modal":
+          text.push(`### Modal state
+${value}
+`);
+          break;
+      }
+    }
+    return text.join("\n");
+  }
+  asMeta() {
+    const codeUpdate = this.code.length ? { category: "code", content: this.code.join("\n") } : void 0;
+    const resultUpdate = this.results.length ? { category: "result", content: this.results.join("\n") } : void 0;
+    const updates = [resultUpdate, codeUpdate, ...this.updates].filter(Boolean);
+    return {
+      "dev.lowire/history": updates,
+      "dev.lowire/state": { ...this.states }
+    };
+  }
+  redact(secrets) {
+    const redactText = (text) => {
+      for (const [secretName, secretValue] of Object.entries(secrets))
+        text = text.replaceAll(secretValue, `<secret>${secretName}</secret>`);
+      return text;
+    };
+    const updates = this.updates.map((update) => ({ ...update, content: redactText(update.content) }));
+    const results = this.results.map((result) => redactText(result));
+    const code = this.code.map((code2) => redactText(code2));
+    const states = Object.fromEntries(Object.entries(this.states).map(([key, value]) => [key, redactText(value)]));
+    return new RenderedResponse({ states, updates, results, code });
+  }
+}
 function parseSections(text) {
   const sections = /* @__PURE__ */ new Map();
   const sectionHeaders = text.split(/^### /m).slice(1);
@@ -229,11 +303,13 @@ function parseResponse(response) {
     modalState,
     downloads,
     isError,
-    attachments
+    attachments,
+    _meta: response._meta
   };
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  RenderedResponse,
   Response,
   parseResponse,
   requestDebug

package/lib/mcp/browser/tab.js

@@ -105,9 +105,6 @@ class Tab extends import_events.EventEmitter {
   clearModalState(modalState) {
     this._modalStates = this._modalStates.filter((state) => state !== modalState);
   }
-  modalStatesMarkdown() {
-    return renderModalStates(this.context, this.modalStates());
-  }
   _dialogShown(dialog) {
     this.setModalState({
       type: "dialog",
@@ -176,9 +173,9 @@ class Tab extends import_events.EventEmitter {
     }
     await this.waitForLoadState("load", { timeout: 5e3 });
   }
-  async consoleMessages(type) {
+  async consoleMessages(level) {
     await this._initializedPromise;
-    return this._consoleMessages.filter((message) => type ? message.type === type : true);
+    return this._consoleMessages.filter((message) => shouldIncludeMessage(level, message.type));
   }
   async requests() {
     await this._initializedPromise;
@@ -200,7 +197,7 @@ class Tab extends import_events.EventEmitter {
       };
     });
     if (tabSnapshot) {
-      tabSnapshot.consoleMessages = this._recentConsoleMessages;
+      tabSnapshot.consoleMessages = this._recentConsoleMessages.filter((message) => shouldIncludeMessage(this.context.config.console.level, message.type));
       this._recentConsoleMessages = [];
     }
     this._needsFullSnapshot = !tabSnapshot;
@@ -282,14 +279,48 @@ function pageErrorToConsoleMessage(errorOrValue) {
     toString: () => String(errorOrValue)
   };
 }
-function renderModalStates(context, modalStates) {
-  const result = ["### Modal state"];
+function renderModalStates(modalStates) {
+  const result = [];
   if (modalStates.length === 0)
     result.push("- There is no modal state present");
   for (const state of modalStates)
     result.push(`- [${state.description}]: can be handled by the "${state.clearedBy}" tool`);
   return result;
 }
+const consoleMessageLevels = ["error", "warning", "info", "debug"];
+function shouldIncludeMessage(thresholdLevel, type) {
+  const messageLevel = consoleLevelForMessageType(type);
+  return consoleMessageLevels.indexOf(messageLevel) <= consoleMessageLevels.indexOf(thresholdLevel);
+}
+function consoleLevelForMessageType(type) {
+  switch (type) {
+    case "assert":
+    case "error":
+      return "error";
+    case "warning":
+      return "warning";
+    case "count":
+    case "dir":
+    case "dirxml":
+    case "info":
+    case "log":
+    case "table":
+    case "time":
+    case "timeEnd":
+      return "info";
+    case "clear":
+    case "debug":
+    case "endGroup":
+    case "profile":
+    case "profileEnd":
+    case "startGroup":
+    case "startGroupCollapsed":
+    case "trace":
+      return "debug";
+    default:
+      return "info";
+  }
+}
 const tabSymbol = Symbol("tabSymbol");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {