playwright-core 1.58.0-alpha-2025-12-07 → 1.58.0-alpha-2025-12-08

package/browsers.json

@@ -45,7 +45,7 @@
     },
     {
       "name": "webkit",
-      "revision": "2232",
+      "revision": "2235",
       "installByDefault": true,
       "revisionOverrides": {
         "debian11-x64": "2105",

package/lib/client/page.js

@@ -675,10 +675,11 @@ class Page extends import_channelOwner.ChannelOwner {
     return result.pdf;
   }
   async perform(task, options = {}) {
-    throw new Error("Not implemented in playwright-core");
+    await this._channel.perform({ task, ...options });
   }
-  extract(query, schema, options = {}) {
-    throw new Error("Not implemented in playwright-core");
+  async extract(query, schema, options = {}) {
+    const { result } = await this._channel.extract({ query, schema: this._platform.zodToJsonSchema(schema), ...options });
+    return result;
   }
   async _snapshotForAI(options = {}) {
     return await this._channel.snapshotForAI({ timeout: this._timeoutSettings.timeout(options), track: options.track });

package/lib/client/platform.js

@@ -66,6 +66,9 @@ const emptyPlatform = {
   streamWritable: (channel) => {
     throw new Error("Streams are not available");
   },
+  zodToJsonSchema: (schema) => {
+    throw new Error("Zod is not available");
+  },
   zones: { empty: noopZone, current: () => noopZone }
 };
 // Annotate the CommonJS export names for ESM import in node:

package/lib/protocol/validator.js

@@ -611,7 +611,7 @@ import_validatorPrimitives.scheme.BrowserTypeLaunchPersistentContextParams = (0,
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
   })),
   userDataDir: import_validatorPrimitives.tString,
@@ -709,7 +709,7 @@ import_validatorPrimitives.scheme.BrowserNewContextParams = (0, import_validator
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
   })),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
@@ -786,7 +786,7 @@ import_validatorPrimitives.scheme.BrowserNewContextForReuseParams = (0, import_v
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
   })),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
@@ -908,7 +908,7 @@ import_validatorPrimitives.scheme.BrowserContextInitializer = (0, import_validat
     agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
       provider: import_validatorPrimitives.tString,
       model: import_validatorPrimitives.tString,
-      cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+      cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
       cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
     }))
   })
@@ -1512,6 +1512,20 @@ import_validatorPrimitives.scheme.PageUpdateSubscriptionParams = (0, import_vali
   enabled: import_validatorPrimitives.tBoolean
 });
 import_validatorPrimitives.scheme.PageUpdateSubscriptionResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
+import_validatorPrimitives.scheme.PagePerformParams = (0, import_validatorPrimitives.tObject)({
+  task: import_validatorPrimitives.tString,
+  key: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
+});
+import_validatorPrimitives.scheme.PagePerformResult = (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({}));
+import_validatorPrimitives.scheme.PageExtractParams = (0, import_validatorPrimitives.tObject)({
+  query: import_validatorPrimitives.tString,
+  schema: import_validatorPrimitives.tAny,
+  maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
+});
+import_validatorPrimitives.scheme.PageExtractResult = (0, import_validatorPrimitives.tObject)({
+  result: import_validatorPrimitives.tAny
+});
 import_validatorPrimitives.scheme.FrameInitializer = (0, import_validatorPrimitives.tObject)({
   url: import_validatorPrimitives.tString,
   name: import_validatorPrimitives.tString,
@@ -2803,7 +2817,7 @@ import_validatorPrimitives.scheme.AndroidDeviceLaunchBrowserParams = (0, import_
   agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     provider: import_validatorPrimitives.tString,
     model: import_validatorPrimitives.tString,
-    cacheDir: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
   })),
   pkg: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),

package/lib/server/agent/actionRunner.js

@@ -0,0 +1,58 @@
+"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 actionRunner_exports = {};
+__export(actionRunner_exports, {
+  runAction: () => runAction
+});
+module.exports = __toCommonJS(actionRunner_exports);
+async function runAction(progress, page, action) {
+  const frame = page.mainFrame();
+  switch (action.method) {
+    case "click":
+      await frame.click(progress, action.selector, { ...action.options, ...strictTrue });
+      break;
+    case "drag":
+      await frame.dragAndDrop(progress, action.sourceSelector, action.targetSelector, { ...strictTrue });
+      break;
+    case "hover":
+      await frame.hover(progress, action.selector, { ...action.options, ...strictTrue });
+      break;
+    case "selectOption":
+      await frame.selectOption(progress, action.selector, [], action.values.map((a) => ({ value: a })), { ...strictTrue });
+      break;
+    case "pressKey":
+      await page.keyboard.press(progress, action.key);
+      break;
+    case "pressSequentially":
+      await frame.type(progress, action.selector, action.text, { ...strictTrue });
+      if (action.submit)
+        await page.keyboard.press(progress, "Enter");
+      break;
+    case "fill":
+      await frame.fill(progress, action.selector, action.text, { ...strictTrue });
+      if (action.submit)
+        await page.keyboard.press(progress, "Enter");
+      break;
+  }
+}
+const strictTrue = { strict: true };
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  runAction
+});

package/lib/server/agent/actions.js

@@ -0,0 +1,16 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 actions_exports = {};
+module.exports = __toCommonJS(actions_exports);

package/lib/server/agent/agent.js

@@ -0,0 +1,123 @@
+"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 agent_exports = {};
+__export(agent_exports, {
+  pageExtract: () => pageExtract,
+  pagePerform: () => pagePerform
+});
+module.exports = __toCommonJS(agent_exports);
+var import_fs = __toESM(require("fs"));
+var import_backend = require("./backend");
+var import_utilsBundle = require("../../utilsBundle");
+var import_mcpBundle = require("../../mcpBundle");
+var import_actionRunner = require("./actionRunner");
+var import_context = require("./context");
+async function pagePerform(progress, page, options) {
+  const context = new import_context.Context(progress, page);
+  if (await cachedPerform(context, options))
+    return;
+  await perform(context, options.task, (0, import_mcpBundle.zodToJsonSchema)(import_mcpBundle.z.object({
+    error: import_mcpBundle.z.string().optional().describe("An error message if the task could not be completed successfully")
+  })), options);
+  await updateCache(context, options);
+}
+async function pageExtract(progress, page, options) {
+  const context = new import_context.Context(progress, page);
+  const task = `
+### Instructions
+Extract the following information from the page. Do not perform any actions, just extract the information.
+
+### Query
+${options.query}`;
+  return await perform(context, task, options.schema, options);
+}
+async function perform(context, userTask, resultSchema, options = {}) {
+  const { progress, page } = context;
+  const browserContext = page.browserContext;
+  if (!browserContext._options.agent)
+    throw new Error(`page.perform() and page.extract() require the agent to be set on the browser context`);
+  const { full } = await page.snapshotForAI(progress);
+  const { tools, callTool } = (0, import_backend.toolsForLoop)(context);
+  const loop = new import_mcpBundle.Loop(browserContext._options.agent.provider, {
+    model: browserContext._options.agent.model,
+    summarize: true,
+    debug: import_utilsBundle.debug,
+    callTool,
+    tools,
+    ...options
+  });
+  const task = `${userTask}
+
+### Page snapshot
+${full}
+`;
+  return await loop.run(task, {
+    resultSchema
+  });
+}
+const allCaches = /* @__PURE__ */ new Map();
+async function cachedPerform(context, options) {
+  const agentSettings = context.page.browserContext._options.agent;
+  if (!agentSettings?.cacheFile || agentSettings.cacheMode === "ignore")
+    return false;
+  const cache = await cachedActions(agentSettings.cacheFile);
+  const cacheKey = options.key ?? options.task;
+  const actions = cache[cacheKey];
+  if (!actions) {
+    if (agentSettings.cacheMode === "force")
+      throw new Error(`No cached actions for key "${cacheKey}", but cache mode is set to "force"`);
+    return false;
+  }
+  for (const action of actions)
+    await (0, import_actionRunner.runAction)(context.progress, context.page, action);
+  return true;
+}
+async function updateCache(context, options) {
+  const cacheFile = context.page.browserContext._options.agent?.cacheFile;
+  if (!cacheFile)
+    return;
+  const cache = await cachedActions(cacheFile);
+  const cacheKey = options.key ?? options.task;
+  cache[cacheKey] = context.actions;
+  await import_fs.default.promises.writeFile(cacheFile, JSON.stringify(cache, void 0, 2));
+}
+async function cachedActions(cacheFile) {
+  let cache = allCaches.get(cacheFile);
+  if (!cache) {
+    const text = await import_fs.default.promises.readFile(cacheFile, "utf-8").catch(() => "{}");
+    cache = JSON.parse(text);
+    allCaches.set(cacheFile, cache);
+  }
+  return cache;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  pageExtract,
+  pagePerform
+});

package/lib/server/agent/backend.js

@@ -0,0 +1,77 @@
+"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 backend_exports = {};
+__export(backend_exports, {
+  toolsForLoop: () => toolsForLoop
+});
+module.exports = __toCommonJS(backend_exports);
+var import_tools = __toESM(require("./tools"));
+var import_progress = require("../progress");
+var import_mcpBundle = require("../../mcpBundle");
+function toolsForLoop(context) {
+  const tools = import_tools.default.map((tool) => {
+    const result = {
+      name: tool.schema.name,
+      description: tool.schema.description,
+      inputSchema: (0, import_mcpBundle.zodToJsonSchema)(tool.schema.inputSchema)
+    };
+    return result;
+  });
+  const callTool = async (params) => {
+    const tool = import_tools.default.find((t) => t.schema.name === params.name);
+    if (!tool) {
+      return {
+        content: [{
+          type: "text",
+          text: `Tool ${params.name} not found. Available tools: ${import_tools.default.map((t) => t.schema.name)}`
+        }],
+        isError: true
+      };
+    }
+    const progressController = new import_progress.ProgressController();
+    try {
+      return await progressController.run(async (progress) => {
+        return await tool.handle(context, params.arguments);
+      });
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: error.message }],
+        isError: true
+      };
+    }
+  };
+  return {
+    tools,
+    callTool
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  toolsForLoop
+});

package/lib/server/agent/context.js

@@ -0,0 +1,91 @@
+"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 context_exports = {};
+__export(context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(context_exports);
+var import_browserContext = require("../browserContext");
+var import_actionRunner = require("./actionRunner");
+class Context {
+  constructor(progress, page) {
+    this.actions = [];
+    this.progress = progress;
+    this.page = page;
+  }
+  async runAction(action) {
+    await this.waitForCompletion(() => (0, import_actionRunner.runAction)(this.progress, this.page, action));
+    this.actions.push(action);
+    return await this.snapshotResult();
+  }
+  async waitForCompletion(callback) {
+    const requests = [];
+    const requestListener = (request) => requests.push(request);
+    const disposeListeners = () => {
+      this.page.browserContext.off(import_browserContext.BrowserContext.Events.Request, requestListener);
+    };
+    let result;
+    try {
+      result = await callback();
+      await this.progress.wait(500);
+    } finally {
+      disposeListeners();
+    }
+    const requestedNavigation = requests.some((request) => request.isNavigationRequest());
+    if (requestedNavigation) {
+      await this.page.performActionPreChecks(this.progress);
+      return result;
+    }
+    const fiveSeconds = new Promise((resolve) => setTimeout(resolve, 1e3));
+    for (const request of requests) {
+      if (request.failure())
+        continue;
+      const response = Promise.race([request.response(), fiveSeconds]);
+      await this.progress.race(response);
+    }
+    return result;
+  }
+  async snapshotResult() {
+    const { full } = await this.page.snapshotForAI(this.progress);
+    const text = [`# Page snapshot
+${full}`];
+    return {
+      _meta: {
+        "dev.lowire/state": {
+          "Page snapshot": full
+        }
+      },
+      content: [{ type: "text", text: text.join("\n\n") }]
+    };
+  }
+  async refSelectors(params) {
+    return Promise.all(params.map(async (param) => {
+      try {
+        const { resolvedSelector } = await this.page.mainFrame().resolveSelector(this.progress, `aria-ref=${param.ref}`);
+        return resolvedSelector;
+      } catch (e) {
+        throw new Error(`Ref ${param.ref} not found in the current page snapshot. Try capturing new snapshot.`);
+      }
+    }));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});

package/lib/server/agent/tools.js

@@ -0,0 +1,187 @@
+"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 tools_exports = {};
+__export(tools_exports, {
+  default: () => tools_default
+});
+module.exports = __toCommonJS(tools_exports);
+var import_mcpBundle = require("../../mcpBundle");
+function defineTool(tool) {
+  return tool;
+}
+const snapshot = defineTool({
+  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({})
+  },
+  handle: async (context, params) => {
+    return await context.snapshotResult();
+  }
+});
+const elementSchema = import_mcpBundle.z.object({
+  element: import_mcpBundle.z.string().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 = defineTool({
+  schema: {
+    name: "browser_click",
+    title: "Click",
+    description: "Perform click on a web page",
+    inputSchema: clickSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    return await context.runAction({
+      method: "click",
+      selector,
+      options: {
+        button: params.button,
+        modifiers: params.modifiers,
+        clickCount: params.doubleClick ? 2 : void 0
+      }
+    });
+  }
+});
+const drag = defineTool({
+  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")
+    })
+  },
+  handle: async (context, params) => {
+    const [sourceSelector, targetSelector] = await context.refSelectors([
+      { ref: params.startRef, element: params.startElement },
+      { ref: params.endRef, element: params.endElement }
+    ]);
+    return await context.runAction({
+      method: "drag",
+      sourceSelector,
+      targetSelector
+    });
+  }
+});
+const hoverSchema = elementSchema.extend({
+  modifiers: import_mcpBundle.z.array(import_mcpBundle.z.enum(["Alt", "Control", "ControlOrMeta", "Meta", "Shift"])).optional().describe("Modifier keys to press")
+});
+const hover = defineTool({
+  schema: {
+    name: "browser_hover",
+    title: "Hover mouse",
+    description: "Hover over element on page",
+    inputSchema: hoverSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    return await context.runAction({
+      method: "hover",
+      selector,
+      options: {
+        modifiers: params.modifiers
+      }
+    });
+  }
+});
+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 = defineTool({
+  schema: {
+    name: "browser_select_option",
+    title: "Select option",
+    description: "Select an option in a dropdown",
+    inputSchema: selectOptionSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    return await context.runAction({
+      method: "selectOption",
+      selector,
+      values: params.values
+    });
+  }
+});
+const pressKey = defineTool({
+  schema: {
+    name: "browser_press_key",
+    title: "Press a key",
+    description: "Press a key on the keyboard",
+    inputSchema: import_mcpBundle.z.object({
+      key: import_mcpBundle.z.string().describe("Name of the key to press or a character to generate, such as `ArrowLeft` or `a`")
+    })
+  },
+  handle: async (context, params) => {
+    return await context.runAction({
+      method: "pressKey",
+      key: params.key
+    });
+  }
+});
+const typeSchema = elementSchema.extend({
+  text: import_mcpBundle.z.string().describe("Text to type into the element"),
+  submit: import_mcpBundle.z.boolean().optional().describe("Whether to submit entered text (press Enter after)"),
+  slowly: import_mcpBundle.z.boolean().optional().describe("Whether to type one character at a time. Useful for triggering key handlers in the page. By default entire text is filled in at once.")
+});
+const type = defineTool({
+  schema: {
+    name: "browser_type",
+    title: "Type text",
+    description: "Type text into editable element",
+    inputSchema: typeSchema
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([params]);
+    if (params.slowly) {
+      return await context.runAction({
+        method: "pressSequentially",
+        selector,
+        text: params.text,
+        submit: params.submit
+      });
+    } else {
+      return await context.runAction({
+        method: "fill",
+        selector,
+        text: params.text,
+        submit: params.submit
+      });
+    }
+  }
+});
+var tools_default = [
+  snapshot,
+  click,
+  drag,
+  hover,
+  selectOption,
+  pressKey,
+  type
+];

package/lib/server/browserContext.js

@@ -145,7 +145,7 @@ if (navigator.serviceWorker) navigator.serviceWorker.register = async () => { co
     return true;
   }
   static reusableContextHash(params) {
-    const paramsCopy = { ...params, agent: void 0 };
+    const paramsCopy = { ...params };
     if (paramsCopy.selectorEngines?.length === 0)
       delete paramsCopy.selectorEngines;
     for (const k of Object.keys(paramsCopy)) {

package/lib/server/chromium/chromium.js

@@ -279,9 +279,7 @@ class Chromium extends import_browserType.BrowserType {
     if (args.find((arg) => !arg.startsWith("-")))
       throw new Error("Arguments can not specify page to be opened");
     const chromeArguments = [...(0, import_chromiumSwitches.chromiumSwitches)(options.assistantMode, options.channel)];
-    if (import_os.default.platform() === "darwin") {
-      chromeArguments.push("--enable-unsafe-swiftshader");
-    }
+    chromeArguments.push("--enable-unsafe-swiftshader");
     if (options.headless) {
       chromeArguments.push("--headless");
       chromeArguments.push(