@cotestdev/mcp_playwright 0.0.50 → 0.0.52

package/lib/mcp/browser/response.js

@@ -32,43 +32,66 @@ __export(response_exports, {
   parseResponse: () => parseResponse,
   renderTabMarkdown: () => renderTabMarkdown,
   renderTabsMarkdown: () => renderTabsMarkdown,
-  requestDebug: () => requestDebug,
-  serializeResponse: () => serializeResponse
+  requestDebug: () => requestDebug
 });
 module.exports = __toCommonJS(response_exports);
 var import_fs = __toESM(require("fs"));
 var import_path = __toESM(require("path"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
 var import_tab = require("./tab");
-var import_utils = require("./tools/utils");
 var import_screenshot = require("./tools/screenshot");
 const requestDebug = (0, import_utilsBundle.debug)("pw:mcp:request");
 class Response {
-  constructor(ordinal, context, toolName, toolArgs) {
+  constructor(context, toolName, toolArgs, relativeTo) {
     this._results = [];
     this._errors = [];
     this._code = [];
     this._includeSnapshot = "none";
+    this._imageResults = [];
     this._context = context;
     this.toolName = toolName;
     this.toolArgs = toolArgs;
+    this._clientWorkspace = relativeTo ?? context.firstRootPath();
   }
-  static {
-    this._ordinal = 0;
+  _computRelativeTo(fileName) {
+    if (this._clientWorkspace)
+      return import_path.default.relative(this._clientWorkspace, fileName);
+    return fileName;
   }
-  static create(context, toolName, toolArgs) {
-    return new Response(++Response._ordinal, context, toolName, toolArgs);
+  async resolveClientFile(template, title) {
+    let fileName;
+    if (template.suggestedFilename)
+      fileName = await this._context.workspaceFile(template.suggestedFilename, this._clientWorkspace);
+    else
+      fileName = await this._context.outputFile(template, { origin: "llm" });
+    const relativeName = this._computRelativeTo(fileName);
+    const printableLink = `- [${title}](${relativeName})`;
+    return { fileName, relativeName, printableLink };
   }
   addTextResult(text) {
-    this._results.push({ title: "", text });
+    this._results.push(text);
   }
-  addResult(title, data, file) {
-    this._results.push({
-      text: typeof data === "string" ? data : void 0,
-      data: typeof data === "string" ? void 0 : data,
-      title,
-      file
-    });
+  async addResult(title, data, file) {
+    if (this._context.config.outputMode === "file" || file.suggestedFilename || typeof data !== "string") {
+      const resolvedFile = await this.resolveClientFile(file, title);
+      await this.addFileResult(resolvedFile, data);
+    } else {
+      this.addTextResult(data);
+    }
+  }
+  async addFileResult(resolvedFile, data) {
+    if (typeof data === "string")
+      await import_fs.default.promises.writeFile(resolvedFile.fileName, data, "utf-8");
+    else if (data)
+      await import_fs.default.promises.writeFile(resolvedFile.fileName, data);
+    this.addTextResult(resolvedFile.printableLink);
+  }
+  addFileLink(title, fileName) {
+    const relativeName = this._computRelativeTo(fileName);
+    this.addTextResult(`- [${title}](${relativeName})`);
+  }
+  async registerImageResult(data, imageType) {
+    this._imageResults.push({ data, imageType });
   }
   addError(error) {
     this._errors.push(error);
@@ -83,61 +106,90 @@ class Response {
     this._includeSnapshot = "full";
     this._includeSnapshotFileName = includeSnapshotFileName;
   }
-  async build() {
-    const rootPath = this._context.firstRootPath();
-    const sections = [];
-    const addSection = (title, codeframe) => {
-      const section = { title, content: [], isError: title === "Error", codeframe };
-      sections.push(section);
-      return section.content;
+  async serialize() {
+    const redactText = (text2) => {
+      for (const [secretName, secretValue] of Object.entries(this._context.config.secrets ?? {}))
+        text2 = text2.replaceAll(secretValue, `<secret>${secretName}</secret>`);
+      return text2;
     };
-    if (this._errors.length) {
-      const content = addSection("Error");
-      content.push({ text: this._errors.join("\n"), title: "error" });
-    }
-    if (this._results.length) {
-      const content = addSection("Result");
-      content.push(...this._results);
+    const sections = await this._build();
+    const text = [];
+    for (const section of sections) {
+      if (!section.content.length)
+        continue;
+      text.push(`### ${section.title}`);
+      if (section.codeframe)
+        text.push(`\`\`\`${section.codeframe}`);
+      text.push(...section.content);
+      if (section.codeframe)
+        text.push("```");
     }
-    if (this._context.config.codegen !== "none" && this._code.length) {
-      const content = addSection("Ran Playwright code", "js");
-      for (const code of this._code)
-        content.push({ text: code, title: "code" });
+    const content = [
+      {
+        type: "text",
+        text: redactText(text.join("\n"))
+      }
+    ];
+    if (this._context.config.imageResponses !== "omit") {
+      for (const imageResult of this._imageResults) {
+        const scaledData = (0, import_screenshot.scaleImageToFitMessage)(imageResult.data, imageResult.imageType);
+        content.push({ type: "image", data: scaledData.toString("base64"), mimeType: imageResult.imageType === "png" ? "image/png" : "image/jpeg" });
+      }
     }
-    const tabSnapshot = this._context.currentTab() ? await this._context.currentTabOrDie().captureSnapshot() : void 0;
+    return {
+      content,
+      ...sections.some((section) => section.isError) ? { isError: true } : {}
+    };
+  }
+  async _build() {
+    const sections = [];
+    const addSection = (title, content, codeframe) => {
+      const section = { title, content, isError: title === "Error", codeframe };
+      sections.push(section);
+      return content;
+    };
+    if (this._errors.length)
+      addSection("Error", this._errors);
+    if (this._results.length)
+      addSection("Result", this._results);
+    if (this._context.config.codegen !== "none" && this._code.length)
+      addSection("Ran Playwright code", this._code, "js");
+    const tabSnapshot = this._context.currentTab() ? await this._context.currentTabOrDie().captureSnapshot(this._clientWorkspace) : void 0;
     const tabHeaders = await Promise.all(this._context.tabs().map((tab) => tab.headerSnapshot()));
     if (this._includeSnapshot !== "none" || tabHeaders.some((header) => header.changed)) {
-      if (tabHeaders.length !== 1) {
-        const content2 = addSection("Open tabs");
-        content2.push({ text: renderTabsMarkdown(tabHeaders).join("\n"), title: "Open tabs" });
-      }
-      const content = addSection("Page");
-      content.push({ text: renderTabMarkdown(tabHeaders[0]).join("\n"), title: "Page" });
-    }
-    if (tabSnapshot?.modalStates.length) {
-      const content = addSection("Modal state");
-      content.push({ text: (0, import_tab.renderModalStates)(this._context.config, tabSnapshot.modalStates).join("\n"), title: "Modal state" });
+      if (tabHeaders.length !== 1)
+        addSection("Open tabs", renderTabsMarkdown(tabHeaders));
+      addSection("Page", renderTabMarkdown(tabHeaders[0]));
     }
+    if (tabSnapshot?.modalStates.length)
+      addSection("Modal state", (0, import_tab.renderModalStates)(this._context.config, tabSnapshot.modalStates));
     if (tabSnapshot && this._includeSnapshot !== "none") {
-      const content = addSection("Snapshot", "yaml");
       const snapshot = this._includeSnapshot === "full" ? tabSnapshot.ariaSnapshot : tabSnapshot.ariaSnapshotDiff ?? tabSnapshot.ariaSnapshot;
-      content.push({ text: snapshot, title: "snapshot", file: { prefix: "page", ext: "yml", suggestedFilename: this._includeSnapshotFileName } });
+      if (this._context.config.outputMode === "file" || this._includeSnapshotFileName) {
+        const resolvedFile = await this.resolveClientFile({ prefix: "page", ext: "yml", suggestedFilename: this._includeSnapshotFileName }, "Snapshot");
+        await import_fs.default.promises.writeFile(resolvedFile.fileName, snapshot, "utf-8");
+        addSection("Snapshot", [resolvedFile.printableLink]);
+      } else {
+        addSection("Snapshot", [snapshot], "yaml");
+      }
     }
+    const text = [];
+    if (tabSnapshot?.consoleLink)
+      text.push(`- New console entries: ${tabSnapshot.consoleLink}`);
     if (tabSnapshot?.events.filter((event) => event.type !== "request").length) {
-      const content = addSection("Events");
-      const text = [];
       for (const event of tabSnapshot.events) {
-        if (event.type === "console") {
+        if (event.type === "console" && this._context.config.outputMode !== "file") {
           if ((0, import_tab.shouldIncludeMessage)(this._context.config.console.level, event.message.type))
             text.push(`- ${trimMiddle(event.message.toString(), 100)}`);
         } else if (event.type === "download-start") {
           text.push(`- Downloading file ${event.download.download.suggestedFilename()} ...`);
         } else if (event.type === "download-finish") {
-          text.push(`- Downloaded file ${event.download.download.suggestedFilename()} to "${rootPath ? import_path.default.relative(rootPath, event.download.outputFile) : event.download.outputFile}"`);
+          text.push(`- Downloaded file ${event.download.download.suggestedFilename()} to "${this._computRelativeTo(event.download.outputFile)}"`);
         }
       }
-      content.push({ text: text.join("\n"), title: "events" });
     }
+    if (text.length)
+      addSection("Events", text);
     return sections;
   }
 }
@@ -145,6 +197,8 @@ function renderTabMarkdown(tab) {
   const lines = [`- Page URL: ${tab.url}`];
   if (tab.title)
     lines.push(`- Page Title: ${tab.title}`);
+  if (tab.console.errors || tab.console.warnings)
+    lines.push(`- Console: ${tab.console.errors} errors, ${tab.console.warnings} warnings`);
   return lines;
 }
 function renderTabsMarkdown(tabs) {
@@ -176,56 +230,6 @@ function parseSections(text) {
   }
   return sections;
 }
-async function serializeResponse(context, sections, relativeTo) {
-  const redactText = (text2) => {
-    for (const [secretName, secretValue] of Object.entries(context.config.secrets ?? {}))
-      text2 = text2.replaceAll(secretValue, `<secret>${secretName}</secret>`);
-    return text2;
-  };
-  const text = [];
-  for (const section of sections) {
-    text.push(`### ${section.title}`);
-    const codeframe = [];
-    for (const result of section.content) {
-      if (result.file && (result.file.suggestedFilename || context.config.outputMode === "file" || result.data)) {
-        const generatedFileName = await context.outputFile((0, import_utils.dateAsFileName)(result.file.prefix, result.file.ext), { origin: "code", title: section.title });
-        const fileName = result.file.suggestedFilename ? await context.outputFile(result.file.suggestedFilename, { origin: "llm", title: section.title }) : generatedFileName;
-        text.push(`- [${result.title}](${relativeTo ? import_path.default.relative(relativeTo, fileName) : fileName})`);
-        if (result.data)
-          await import_fs.default.promises.writeFile(fileName, result.data, "utf-8");
-        else
-          await import_fs.default.promises.writeFile(fileName, result.text);
-      } else {
-        if (result.text !== void 0)
-          codeframe.push(result.text);
-      }
-    }
-    if (codeframe?.length) {
-      if (section.codeframe)
-        text.push(`\`\`\`${section.codeframe}
-${codeframe.join("\n")}
-\`\`\``);
-      else
-        text.push(codeframe.join("\n"));
-    }
-  }
-  const content = [
-    {
-      type: "text",
-      text: redactText(text.join("\n"))
-    }
-  ];
-  if (context.config.imageResponses !== "omit") {
-    for (const result of sections.flatMap((section) => section.content).filter((result2) => result2.file?.contentType)) {
-      const scaledData = (0, import_screenshot.scaleImageToFitMessage)(result.data, result.file.contentType === "image/png" ? "png" : "jpeg");
-      content.push({ type: "image", data: scaledData.toString("base64"), mimeType: result.file.contentType });
-    }
-  }
-  return {
-    content,
-    ...sections.some((section) => section.isError) ? { isError: true } : {}
-  };
-}
 function parseResponse(response) {
   if (response.content?.[0].type !== "text")
     return void 0;
@@ -262,6 +266,5 @@ function parseResponse(response) {
   parseResponse,
   renderTabMarkdown,
   renderTabsMarkdown,
-  requestDebug,
-  serializeResponse
+  requestDebug
 });

package/lib/mcp/browser/sessionLog.js

@@ -42,7 +42,7 @@ class SessionLog {
     this._file = import_path.default.join(this._folder, "session.md");
   }
   static async create(config, clientInfo) {
-    const sessionFolder = await (0, import_config.outputFile)(config, clientInfo, `session-${Date.now()}`, { origin: "code", title: "Saving session" });
+    const sessionFolder = await (0, import_config.outputFile)(config, clientInfo, `session-${Date.now()}`, { origin: "code" });
     await import_fs.default.promises.mkdir(sessionFolder, { recursive: true });
     console.error(`Session: ${sessionFolder}`);
     return new SessionLog(sessionFolder);

package/lib/mcp/browser/tab.js

@@ -19,7 +19,6 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var tab_exports = {};
 __export(tab_exports, {
   Tab: () => Tab,
-  TabEvents: () => TabEvents,
   renderModalStates: () => renderModalStates,
   shouldIncludeMessage: () => shouldIncludeMessage
 });
@@ -28,6 +27,7 @@ var import_events = require("events");
 var import_utils = require("playwright-core/lib/utils");
 var import_utils2 = require("./tools/utils");
 var import_log = require("../log");
+var import_logFile = require("./logFile");
 var import_dialogs = require("./tools/dialogs");
 var import_files = require("./tools/files");
 var import_transform = require("../../transform/transform");
@@ -37,13 +37,12 @@ const TabEvents = {
 class Tab extends import_events.EventEmitter {
   constructor(context, page, onPageClose) {
     super();
-    this._lastHeader = { title: "about:blank", url: "about:blank", current: false };
+    this._lastHeader = { title: "about:blank", url: "about:blank", current: false, console: { total: 0, warnings: 0, errors: 0 } };
     this._consoleMessages = [];
     this._downloads = [];
-    this._requests = /* @__PURE__ */ new Set();
+    this._requests = [];
     this._modalStates = [];
     this._needsFullSnapshot = false;
-    this._eventEntries = [];
     this._recentEventEntries = [];
     this.context = context;
     this.page = page;
@@ -51,6 +50,8 @@ class Tab extends import_events.EventEmitter {
     page.on("console", (event) => this._handleConsoleMessage(messageToConsoleMessage(event)));
     page.on("pageerror", (error) => this._handleConsoleMessage(pageErrorToConsoleMessage(error)));
     page.on("request", (request) => this._handleRequest(request));
+    page.on("response", (response) => this._handleResponse(response));
+    page.on("requestfailed", (request) => this._handleRequestFailed(request));
     page.on("close", () => this._onClose());
     page.on("filechooser", (chooser) => {
       this.setModalState({
@@ -67,6 +68,8 @@ class Tab extends import_events.EventEmitter {
     page.setDefaultNavigationTimeout(this.context.config.timeouts.navigation);
     page.setDefaultTimeout(this.context.config.timeouts.action);
     page[tabSymbol] = this;
+    const wallTime = Date.now();
+    this._consoleLog = new import_logFile.LogFile(this.context, wallTime, "console", "Console");
     this._initializedPromise = this._initialize();
   }
   static forPage(page) {
@@ -86,8 +89,8 @@ class Tab extends import_events.EventEmitter {
     for (const message of await Tab.collectConsoleMessages(this.page))
       this._handleConsoleMessage(message);
     const requests = await this.page.requests().catch(() => []);
-    for (const request of requests)
-      this._requests.add(request);
+    for (const request of requests.filter((r) => r.existingResponse() || r.failure()))
+      this._requests.push(request);
     for (const initPage of this.context.config.browser.initPage || []) {
       try {
         const { default: func } = await (0, import_transform.requireOrImport)(initPage);
@@ -116,10 +119,11 @@ class Tab extends import_events.EventEmitter {
     });
   }
   async _downloadStarted(download) {
+    const outputFile = await this.context.outputFile({ suggestedFilename: sanitizeForFilePath(download.suggestedFilename()), prefix: "download", ext: "bin" }, { origin: "code" });
     const entry = {
       download,
       finished: false,
-      outputFile: await this.context.outputFile(download.suggestedFilename(), { origin: "web", title: "Saving download" })
+      outputFile
     };
     this._downloads.push(entry);
     this._addLogEntry({ type: "download-start", wallTime: Date.now(), download: entry });
@@ -130,20 +134,40 @@ class Tab extends import_events.EventEmitter {
   _clearCollectedArtifacts() {
     this._consoleMessages.length = 0;
     this._downloads.length = 0;
-    this._requests.clear();
-    this._eventEntries.length = 0;
+    this._requests.length = 0;
     this._recentEventEntries.length = 0;
+    this._resetLogs();
+  }
+  _resetLogs() {
+    const wallTime = Date.now();
+    this._consoleLog.stop();
+    this._consoleLog = new import_logFile.LogFile(this.context, wallTime, "console", "Console");
   }
   _handleRequest(request) {
-    this._requests.add(request);
-    this._addLogEntry({ type: "request", wallTime: Date.now(), request });
+    this._requests.push(request);
+    const wallTime = request.timing().startTime || Date.now();
+    this._addLogEntry({ type: "request", wallTime, request });
+  }
+  _handleResponse(response) {
+    const timing = response.request().timing();
+    const wallTime = timing.responseStart + timing.startTime;
+    this._addLogEntry({ type: "request", wallTime, request: response.request() });
+  }
+  _handleRequestFailed(request) {
+    this._requests.push(request);
+    const timing = request.timing();
+    const wallTime = timing.responseEnd + timing.startTime;
+    this._addLogEntry({ type: "request", wallTime, request });
   }
   _handleConsoleMessage(message) {
     this._consoleMessages.push(message);
-    this._addLogEntry({ type: "console", wallTime: Date.now(), message });
+    const wallTime = message.timestamp;
+    this._addLogEntry({ type: "console", wallTime, message });
+    const level = consoleLevelForMessageType(message.type);
+    if (level === "error" || level === "warning")
+      this._consoleLog.appendLine(wallTime, () => message.toString());
   }
   _addLogEntry(entry) {
-    this._eventEntries.push(entry);
     this._recentEventEntries.push(entry);
   }
   _onClose() {
@@ -155,8 +179,14 @@ class Tab extends import_events.EventEmitter {
     await this._raceAgainstModalStates(async () => {
       title = await (0, import_utils2.callOnPageNoTrace)(this.page, (page) => page.title());
     });
-    if (this._lastHeader.title !== title || this._lastHeader.url !== this.page.url() || this._lastHeader.current !== this.isCurrentTab()) {
-      this._lastHeader = { title: title ?? "", url: this.page.url(), current: this.isCurrentTab() };
+    const newHeader = {
+      title: title ?? "",
+      url: this.page.url(),
+      current: this.isCurrentTab(),
+      console: await this.consoleMessageCount()
+    };
+    if (!tabHeaderEquals(this._lastHeader, newHeader)) {
+      this._lastHeader = newHeader;
       return { ...this._lastHeader, changed: true };
     }
     return { ...this._lastHeader, changed: false };
@@ -188,6 +218,18 @@ class Tab extends import_events.EventEmitter {
     }
     await this.waitForLoadState("load", { timeout: 5e3 });
   }
+  async consoleMessageCount() {
+    await this._initializedPromise;
+    let errors = 0;
+    let warnings = 0;
+    for (const message of this._consoleMessages) {
+      if (message.type === "error")
+        errors++;
+      else if (message.type === "warning")
+        warnings++;
+    }
+    return { total: this._consoleMessages.length, errors, warnings };
+  }
   async consoleMessages(level) {
     await this._initializedPromise;
     return this._consoleMessages.filter((message) => shouldIncludeMessage(level, message.type));
@@ -202,9 +244,9 @@ class Tab extends import_events.EventEmitter {
   }
   async clearRequests() {
     await this._initializedPromise;
-    this._requests.clear();
+    this._requests.length = 0;
   }
-  async captureSnapshot() {
+  async captureSnapshot(relativeTo) {
     await this._initializedPromise;
     let tabSnapshot;
     const modalStates = await this._raceAgainstModalStates(async () => {
@@ -217,6 +259,7 @@ class Tab extends import_events.EventEmitter {
       };
     });
     if (tabSnapshot) {
+      tabSnapshot.consoleLink = await this._consoleLog.take(relativeTo);
       tabSnapshot.events = this._recentEventEntries;
       this._recentEventEntries = [];
     }
@@ -281,6 +324,7 @@ class Tab extends import_events.EventEmitter {
 function messageToConsoleMessage(message) {
   return {
     type: message.type(),
+    timestamp: message.timestamp(),
     text: message.text(),
     toString: () => `[${message.type().toUpperCase()}] ${message.text()} @ ${message.location().url}:${message.location().lineNumber}`
   };
@@ -289,12 +333,14 @@ function pageErrorToConsoleMessage(errorOrValue) {
   if (errorOrValue instanceof Error) {
     return {
       type: "error",
+      timestamp: Date.now(),
       text: errorOrValue.message,
       toString: () => errorOrValue.stack || errorOrValue.message
     };
   }
   return {
     type: "error",
+    timestamp: Date.now(),
     text: String(errorOrValue),
     toString: () => String(errorOrValue)
   };
@@ -342,10 +388,19 @@ function consoleLevelForMessageType(type) {
   }
 }
 const tabSymbol = Symbol("tabSymbol");
+function sanitizeForFilePath(s) {
+  const sanitize = (s2) => s2.replace(/[\x00-\x2C\x2E-\x2F\x3A-\x40\x5B-\x60\x7B-\x7F]+/g, "-");
+  const separator = s.lastIndexOf(".");
+  if (separator === -1)
+    return sanitize(s);
+  return sanitize(s.substring(0, separator)) + "." + sanitize(s.substring(separator + 1));
+}
+function tabHeaderEquals(a, b) {
+  return a.title === b.title && a.url === b.url && a.current === b.current && a.console.errors === b.console.errors && a.console.warnings === b.console.warnings && a.console.total === b.console.total;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Tab,
-  TabEvents,
   renderModalStates,
   shouldIncludeMessage
 });

package/lib/mcp/browser/tools/config.js

@@ -0,0 +1,41 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  default: () => config_default
+});
+module.exports = __toCommonJS(config_exports);
+var import_mcpBundle = require("../../../mcpBundle");
+var import_tool = require("./tool");
+const configShow = (0, import_tool.defineTool)({
+  capability: "config",
+  schema: {
+    name: "browser_get_config",
+    title: "Get config",
+    description: "Get the final resolved config after merging CLI options, environment variables and config file.",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    response.addTextResult(JSON.stringify(context.config, null, 2));
+  }
+});
+var config_default = [
+  configShow
+];

package/lib/mcp/browser/tools/console.js

@@ -36,9 +36,13 @@ const console = (0, import_tool.defineTabTool)({
     type: "readOnly"
   },
   handle: async (tab, params, response) => {
+    const count = await tab.consoleMessageCount();
+    const header = [`Total messages: ${count.total} (Errors: ${count.errors}, Warnings: ${count.warnings})`];
     const messages = await tab.consoleMessages(params.level);
-    const text = messages.map((message) => message.toString()).join("\n");
-    response.addResult("Console", text, { prefix: "console", ext: "log", suggestedFilename: params.filename });
+    if (messages.length !== count.total)
+      header.push(`Returning ${messages.length} messages for level "${params.level}"`);
+    const text = [...header, "", ...messages.map((message) => message.toString())].join("\n");
+    await response.addResult("Console", text, { prefix: "console", ext: "log", suggestedFilename: params.filename });
   }
 });
 const consoleClear = (0, import_tool.defineTabTool)({