playwright-core 1.58.0-alpha-2025-12-06 → 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

@@ -62,6 +62,7 @@ class Page extends import_channelOwner.ChannelOwner {
     this._closeWasCalled = false;
     this._harRouters = [];
     this._locatorHandlers = /* @__PURE__ */ new Map();
+    this._instrumentation.onPage(this);
     this._browserContext = parent;
     this._timeoutSettings = new import_timeoutSettings.TimeoutSettings(this._platform, this._browserContext._timeoutSettings);
     this.keyboard = new import_input.Keyboard(this);
@@ -673,6 +674,13 @@ class Page extends import_channelOwner.ChannelOwner {
     }
     return result.pdf;
   }
+  async perform(task, options = {}) {
+    await this._channel.perform({ task, ...options });
+  }
+  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

@@ -608,6 +608,12 @@ import_validatorPrimitives.scheme.BrowserTypeLaunchPersistentContextParams = (0,
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
+    provider: import_validatorPrimitives.tString,
+    model: 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,
   slowMo: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tFloat)
 });
@@ -700,6 +706,12 @@ import_validatorPrimitives.scheme.BrowserNewContextParams = (0, import_validator
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
+    provider: import_validatorPrimitives.tString,
+    model: 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)({
     server: import_validatorPrimitives.tString,
     bypass: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
@@ -771,6 +783,12 @@ import_validatorPrimitives.scheme.BrowserNewContextForReuseParams = (0, import_v
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
+    provider: import_validatorPrimitives.tString,
+    model: 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)({
     server: import_validatorPrimitives.tString,
     bypass: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
@@ -886,7 +904,13 @@ import_validatorPrimitives.scheme.BrowserContextInitializer = (0, import_validat
     strictSelectors: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tBoolean),
     serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
     selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
-    testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString)
+    testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+    agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
+      provider: import_validatorPrimitives.tString,
+      model: import_validatorPrimitives.tString,
+      cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+      cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"]))
+    }))
   })
 });
 import_validatorPrimitives.scheme.BrowserContextBindingCallEvent = (0, import_validatorPrimitives.tObject)({
@@ -1488,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,
@@ -2776,6 +2814,12 @@ import_validatorPrimitives.scheme.AndroidDeviceLaunchBrowserParams = (0, import_
   serviceWorkers: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["allow", "block"])),
   selectorEngines: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("SelectorEngine"))),
   testIdAttributeName: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
+  agent: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
+    provider: import_validatorPrimitives.tString,
+    model: 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),
   args: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)(import_validatorPrimitives.tString)),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({

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
+});