@pedropaulovc/playwright 1.59.0-alpha-1769214875000

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

@@ -0,0 +1,49 @@
+"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 pdf_exports = {};
+__export(pdf_exports, {
+  default: () => pdf_default
+});
+module.exports = __toCommonJS(pdf_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_tool = require("./tool");
+var import_utils2 = require("./utils");
+const pdfSchema = import_mcpBundle.z.object({
+  filename: import_mcpBundle.z.string().optional().describe("File name to save the pdf to. Defaults to `page-{timestamp}.pdf` if not specified. Prefer relative file names to stay within the output directory.")
+});
+const pdf = (0, import_tool.defineTabTool)({
+  capability: "pdf",
+  schema: {
+    name: "browser_pdf_save",
+    title: "Save as PDF",
+    description: "Save page as PDF",
+    inputSchema: pdfSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const data = await tab.page.pdf();
+    const suggestedFilename = params.filename ?? (0, import_utils2.dateAsFileName)("page", "pdf");
+    await response.addResult("Page as pdf", data, { prefix: "page", ext: "pdf", suggestedFilename });
+    response.addCode(`await page.pdf(${(0, import_utils.formatObject)({ path: suggestedFilename })});`);
+  }
+});
+var pdf_default = [
+  pdf
+];

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

@@ -0,0 +1,76 @@
+"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)
+    __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 __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 runCode_exports = {};
+__export(runCode_exports, {
+  default: () => runCode_default
+});
+module.exports = __toCommonJS(runCode_exports);
+var import_vm = __toESM(require("vm"));
+var import_utils = require("playwright-core/lib/utils");
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("./tool");
+const codeSchema = import_mcpBundle.z.object({
+  code: import_mcpBundle.z.string().describe(`A JavaScript function containing Playwright code to execute. It will be invoked with a single argument, page, which you can use for any page interaction. For example: \`async (page) => { await page.getByRole('button', { name: 'Submit' }).click(); return await page.title(); }\``)
+});
+const runCode = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_run_code",
+    title: "Run Playwright code",
+    description: "Run Playwright code snippet",
+    inputSchema: codeSchema,
+    type: "action"
+  },
+  handle: async (tab, params, response) => {
+    response.addCode(`await (${params.code})(page);`);
+    const __end__ = new import_utils.ManualPromise();
+    const context = {
+      page: tab.page,
+      __end__
+    };
+    import_vm.default.createContext(context);
+    await tab.waitForCompletion(async () => {
+      const snippet = `(async () => {
+        try {
+          const result = await (${params.code})(page);
+          __end__.resolve(JSON.stringify(result));
+        } catch (e) {
+          __end__.reject(e);
+        }
+      })()`;
+      await import_vm.default.runInContext(snippet, context);
+      const result = await __end__;
+      if (typeof result === "string")
+        response.addTextResult(result);
+    });
+  }
+});
+var runCode_default = [
+  runCode
+];

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

@@ -0,0 +1,87 @@
+"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 screenshot_exports = {};
+__export(screenshot_exports, {
+  default: () => screenshot_default,
+  scaleImageToFitMessage: () => scaleImageToFitMessage
+});
+module.exports = __toCommonJS(screenshot_exports);
+var import_utils = require("playwright-core/lib/utils");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils2 = require("playwright-core/lib/utils");
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("./tool");
+var import_utils3 = require("./utils");
+const screenshotSchema = import_mcpBundle.z.object({
+  type: import_mcpBundle.z.enum(["png", "jpeg"]).default("png").describe("Image format for the screenshot. Default is png."),
+  filename: import_mcpBundle.z.string().optional().describe("File name to save the screenshot to. Defaults to `page-{timestamp}.{png|jpeg}` if not specified. Prefer relative file names to stay within the output directory."),
+  element: import_mcpBundle.z.string().optional().describe("Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too."),
+  ref: import_mcpBundle.z.string().optional().describe("Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too."),
+  fullPage: import_mcpBundle.z.boolean().optional().describe("When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.")
+});
+const screenshot = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_take_screenshot",
+    title: "Take a screenshot",
+    description: `Take a screenshot of the current page. You can't perform actions based on the screenshot, use browser_snapshot for actions.`,
+    inputSchema: screenshotSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    if (params.fullPage && params.ref)
+      throw new Error("fullPage cannot be used with element screenshots.");
+    const fileType = params.type || "png";
+    const options = {
+      type: fileType,
+      quality: fileType === "png" ? void 0 : 90,
+      scale: "css",
+      ...params.fullPage !== void 0 && { fullPage: params.fullPage }
+    };
+    const screenshotTarget = params.ref ? params.element || "element" : params.fullPage ? "full page" : "viewport";
+    const ref = params.ref ? await tab.refLocator({ element: params.element || "", ref: params.ref }) : null;
+    const data = ref ? await ref.locator.screenshot(options) : await tab.page.screenshot(options);
+    const suggestedFilename = params.filename || (0, import_utils3.dateAsFileName)(ref ? "element" : "page", fileType);
+    response.addCode(`// Screenshot ${screenshotTarget} and save it as ${suggestedFilename}`);
+    if (ref)
+      response.addCode(`await page.${ref.resolved}.screenshot(${(0, import_utils2.formatObject)({ ...options, path: suggestedFilename })});`);
+    else
+      response.addCode(`await page.screenshot(${(0, import_utils2.formatObject)({ ...options, path: suggestedFilename })});`);
+    const contentType = fileType === "png" ? "image/png" : "image/jpeg";
+    await response.addResult(`Screenshot of ${screenshotTarget}`, data, { prefix: ref ? "element" : "page", ext: fileType, suggestedFilename, contentType });
+  }
+});
+function scaleImageToFitMessage(buffer, imageType) {
+  const image = imageType === "png" ? import_utilsBundle.PNG.sync.read(buffer) : import_utilsBundle.jpegjs.decode(buffer, { maxMemoryUsageInMB: 512 });
+  const pixels = image.width * image.height;
+  const shrink = Math.min(1568 / image.width, 1568 / image.height, Math.sqrt(1.15 * 1024 * 1024 / pixels));
+  if (shrink > 1)
+    return buffer;
+  const width = image.width * shrink | 0;
+  const height = image.height * shrink | 0;
+  const scaledImage = (0, import_utils.scaleImageToSize)(image, { width, height });
+  return imageType === "png" ? import_utilsBundle.PNG.sync.write(scaledImage) : import_utilsBundle.jpegjs.encode(scaledImage, 80).data;
+}
+var screenshot_default = [
+  screenshot
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  scaleImageToFitMessage
+});

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

@@ -0,0 +1,207 @@
+"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 snapshot_exports = {};
+__export(snapshot_exports, {
+  default: () => snapshot_default,
+  elementSchema: () => elementSchema
+});
+module.exports = __toCommonJS(snapshot_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_tool = require("./tool");
+const snapshot = (0, import_tool.defineTool)({
+  capability: "core",
+  schema: {
+    name: "browser_snapshot",
+    title: "Page snapshot",
+    description: "Capture accessibility snapshot of the current page, this is better than screenshot",
+    inputSchema: import_mcpBundle.z.object({
+      filename: import_mcpBundle.z.string().optional().describe("Save snapshot to markdown file instead of returning it in the response.")
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    await context.ensureTab();
+    response.setIncludeFullSnapshot(params.filename);
+  }
+});
+const elementSchema = import_mcpBundle.z.object({
+  element: import_mcpBundle.z.string().optional().describe("Human-readable element description used to obtain permission to interact with the element"),
+  ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
+});
+const clickSchema = elementSchema.extend({
+  doubleClick: import_mcpBundle.z.boolean().optional().describe("Whether to perform a double click instead of a single click"),
+  button: import_mcpBundle.z.enum(["left", "right", "middle"]).optional().describe("Button to click, defaults to left"),
+  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const click = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_click",
+    title: "Click",
+    description: "Perform click on a web page",
+    inputSchema: clickSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const { locator, resolved } = await tab.refLocator(params);
+    const options = {
+      button: params.button,
+      modifiers: params.modifiers
+    };
+    const formatted = (0, import_utils.formatObject)(options, " ", "oneline");
+    const optionsAttr = formatted !== "{}" ? formatted : "";
+    if (params.doubleClick)
+      response.addCode(`await page.${resolved}.dblclick(${optionsAttr});`);
+    else
+      response.addCode(`await page.${resolved}.click(${optionsAttr});`);
+    await tab.waitForCompletion(async () => {
+      if (params.doubleClick)
+        await locator.dblclick(options);
+      else
+        await locator.click(options);
+    });
+  }
+});
+const drag = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_drag",
+    title: "Drag mouse",
+    description: "Perform drag and drop between two elements",
+    inputSchema: import_mcpBundle.z.object({
+      startElement: import_mcpBundle.z.string().describe("Human-readable source element description used to obtain the permission to interact with the element"),
+      startRef: import_mcpBundle.z.string().describe("Exact source element reference from the page snapshot"),
+      endElement: import_mcpBundle.z.string().describe("Human-readable target element description used to obtain the permission to interact with the element"),
+      endRef: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot")
+    }),
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const [start, end] = await tab.refLocators([
+      { ref: params.startRef, element: params.startElement },
+      { ref: params.endRef, element: params.endElement }
+    ]);
+    await tab.waitForCompletion(async () => {
+      await start.locator.dragTo(end.locator);
+    });
+    response.addCode(`await page.${start.resolved}.dragTo(page.${end.resolved});`);
+  }
+});
+const hover = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_hover",
+    title: "Hover mouse",
+    description: "Hover over element on page",
+    inputSchema: elementSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const { locator, resolved } = await tab.refLocator(params);
+    response.addCode(`await page.${resolved}.hover();`);
+    await tab.waitForCompletion(async () => {
+      await locator.hover();
+    });
+  }
+});
+const selectOptionSchema = elementSchema.extend({
+  values: import_mcpBundle.z.array(import_mcpBundle.z.string()).describe("Array of values to select in the dropdown. This can be a single value or multiple values.")
+});
+const selectOption = (0, import_tool.defineTabTool)({
+  capability: "core",
+  schema: {
+    name: "browser_select_option",
+    title: "Select option",
+    description: "Select an option in a dropdown",
+    inputSchema: selectOptionSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    response.setIncludeSnapshot();
+    const { locator, resolved } = await tab.refLocator(params);
+    response.addCode(`await page.${resolved}.selectOption(${(0, import_utils.formatObject)(params.values)});`);
+    await tab.waitForCompletion(async () => {
+      await locator.selectOption(params.values);
+    });
+  }
+});
+const pickLocator = (0, import_tool.defineTabTool)({
+  capability: "testing",
+  schema: {
+    name: "browser_generate_locator",
+    title: "Create locator for element",
+    description: "Generate locator for the given element to use in tests",
+    inputSchema: elementSchema,
+    type: "readOnly"
+  },
+  handle: async (tab, params, response) => {
+    const { resolved } = await tab.refLocator(params);
+    response.addTextResult(resolved);
+  }
+});
+const check = (0, import_tool.defineTabTool)({
+  capability: "core-input",
+  skillOnly: true,
+  schema: {
+    name: "browser_check",
+    title: "Check",
+    description: "Check a checkbox or radio button",
+    inputSchema: elementSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    const { locator, resolved } = await tab.refLocator(params);
+    response.addCode(`await page.${resolved}.check();`);
+    await locator.check();
+  }
+});
+const uncheck = (0, import_tool.defineTabTool)({
+  capability: "core-input",
+  skillOnly: true,
+  schema: {
+    name: "browser_uncheck",
+    title: "Uncheck",
+    description: "Uncheck a checkbox or radio button",
+    inputSchema: elementSchema,
+    type: "input"
+  },
+  handle: async (tab, params, response) => {
+    const { locator, resolved } = await tab.refLocator(params);
+    response.addCode(`await page.${resolved}.uncheck();`);
+    await locator.uncheck();
+  }
+});
+var snapshot_default = [
+  snapshot,
+  click,
+  drag,
+  hover,
+  selectOption,
+  pickLocator,
+  check,
+  uncheck
+];
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  elementSchema
+});

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

@@ -0,0 +1,67 @@
+"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 tabs_exports = {};
+__export(tabs_exports, {
+  default: () => tabs_default
+});
+module.exports = __toCommonJS(tabs_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("./tool");
+var import_response = require("../response");
+const browserTabs = (0, import_tool.defineTool)({
+  capability: "core-tabs",
+  schema: {
+    name: "browser_tabs",
+    title: "Manage tabs",
+    description: "List, create, close, or select a browser tab.",
+    inputSchema: import_mcpBundle.z.object({
+      action: import_mcpBundle.z.enum(["list", "new", "close", "select"]).describe("Operation to perform"),
+      index: import_mcpBundle.z.number().optional().describe("Tab index, used for close/select. If omitted for close, current tab is closed.")
+    }),
+    type: "action"
+  },
+  handle: async (context, params, response) => {
+    switch (params.action) {
+      case "list": {
+        await context.ensureTab();
+        break;
+      }
+      case "new": {
+        await context.newTab();
+        break;
+      }
+      case "close": {
+        await context.closeTab(params.index);
+        break;
+      }
+      case "select": {
+        if (params.index === void 0)
+          throw new Error("Tab index is required");
+        await context.selectTab(params.index);
+        break;
+      }
+    }
+    const tabHeaders = await Promise.all(context.tabs().map((tab) => tab.headerSnapshot()));
+    const result = (0, import_response.renderTabsMarkdown)(tabHeaders);
+    response.addTextResult(result.join("\n"));
+  }
+});
+var tabs_default = [
+  browserTabs
+];

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

@@ -0,0 +1,47 @@
+"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 tool_exports = {};
+__export(tool_exports, {
+  defineTabTool: () => defineTabTool,
+  defineTool: () => defineTool
+});
+module.exports = __toCommonJS(tool_exports);
+function defineTool(tool) {
+  return tool;
+}
+function defineTabTool(tool) {
+  return {
+    ...tool,
+    handle: async (context, params, response) => {
+      const tab = await context.ensureTab();
+      const modalStates = tab.modalStates().map((state) => state.type);
+      if (tool.clearsModalState && !modalStates.includes(tool.clearsModalState))
+        response.addError(`Error: The tool "${tool.schema.name}" can only be used when there is related modal state present.`);
+      else if (!tool.clearsModalState && modalStates.length)
+        response.addError(`Error: Tool "${tool.schema.name}" does not handle the modal state.`);
+      else
+        return tool.handle(tab, params, response);
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineTabTool,
+  defineTool
+});

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

@@ -0,0 +1,74 @@
+"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 tracing_exports = {};
+__export(tracing_exports, {
+  default: () => tracing_default
+});
+module.exports = __toCommonJS(tracing_exports);
+var import_mcpBundle = require("playwright-core/lib/mcpBundle");
+var import_tool = require("./tool");
+const tracingStart = (0, import_tool.defineTool)({
+  capability: "tracing",
+  schema: {
+    name: "browser_start_tracing",
+    title: "Start tracing",
+    description: "Start trace recording",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    const tracesDir = await context.outputFile(`traces`, { origin: "code", title: "Collecting trace" });
+    const name = "trace-" + Date.now();
+    await browserContext.tracing.start({
+      name,
+      screenshots: true,
+      snapshots: true,
+      _live: true
+    });
+    const traceLegend = `- Action log: ${tracesDir}/${name}.trace
+- Network log: ${tracesDir}/${name}.network
+- Resources with content by sha1: ${tracesDir}/resources`;
+    response.addTextResult(`Tracing started, saving to ${tracesDir}.
+${traceLegend}`);
+    browserContext.tracing[traceLegendSymbol] = traceLegend;
+  }
+});
+const tracingStop = (0, import_tool.defineTool)({
+  capability: "tracing",
+  schema: {
+    name: "browser_stop_tracing",
+    title: "Stop tracing",
+    description: "Stop trace recording",
+    inputSchema: import_mcpBundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context, params, response) => {
+    const browserContext = await context.ensureBrowserContext();
+    await browserContext.tracing.stop();
+    const traceLegend = browserContext.tracing[traceLegendSymbol];
+    response.addTextResult(`Tracing stopped.
+${traceLegend}`);
+  }
+});
+var tracing_default = [
+  tracingStart,
+  tracingStop
+];
+const traceLegendSymbol = Symbol("tracesDir");