playwright-core 1.58.0-alpha-2025-12-10 → 1.58.0-alpha-2025-12-12

package/lib/protocol/serializers.js

@@ -19,6 +19,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var serializers_exports = {};
 __export(serializers_exports, {
   parseSerializedValue: () => parseSerializedValue,
+  serializePlainValue: () => serializePlainValue,
   serializeValue: () => serializeValue
 });
 module.exports = __toCommonJS(serializers_exports);
@@ -90,6 +91,9 @@ function innerParseSerializedValue(value, handles, refs, accessChain) {
 function serializeValue(value, handleSerializer) {
   return innerSerializeValue(value, handleSerializer, { lastId: 0, visited: /* @__PURE__ */ new Map() }, []);
 }
+function serializePlainValue(arg) {
+  return serializeValue(arg, (value) => ({ fallThrough: value }));
+}
 function innerSerializeValue(value, handleSerializer, visitorInfo, accessChain) {
   const handle = handleSerializer(value);
   if ("fallThrough" in handle)
@@ -188,5 +192,6 @@ const constructorToTypedArrayKind = new Map(Object.entries(typedArrayKindToConst
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   parseSerializedValue,
+  serializePlainValue,
   serializeValue
 });

package/lib/protocol/validator.js

@@ -613,7 +613,9 @@ import_validatorPrimitives.scheme.BrowserTypeLaunchPersistentContextParams = (0,
     model: import_validatorPrimitives.tString,
     cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
-    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue"))),
+    maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt),
+    maxTokens: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
   })),
   userDataDir: import_validatorPrimitives.tString,
   slowMo: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tFloat)
@@ -712,7 +714,9 @@ import_validatorPrimitives.scheme.BrowserNewContextParams = (0, import_validator
     model: import_validatorPrimitives.tString,
     cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
-    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue"))),
+    maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt),
+    maxTokens: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
   })),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     server: import_validatorPrimitives.tString,
@@ -790,7 +794,9 @@ import_validatorPrimitives.scheme.BrowserNewContextForReuseParams = (0, import_v
     model: import_validatorPrimitives.tString,
     cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
-    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue"))),
+    maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt),
+    maxTokens: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
   })),
   proxy: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
     server: import_validatorPrimitives.tString,
@@ -913,7 +919,9 @@ import_validatorPrimitives.scheme.BrowserContextInitializer = (0, import_validat
       model: import_validatorPrimitives.tString,
       cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
       cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
-      secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
+      secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue"))),
+      maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt),
+      maxTokens: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
     }))
   })
 });
@@ -1519,16 +1527,24 @@ import_validatorPrimitives.scheme.PageUpdateSubscriptionResult = (0, import_vali
 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)
+  maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt),
+  maxTokens: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
+});
+import_validatorPrimitives.scheme.PagePerformResult = (0, import_validatorPrimitives.tObject)({
+  turns: import_validatorPrimitives.tInt,
+  inputTokens: import_validatorPrimitives.tInt,
+  outputTokens: 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
+  result: import_validatorPrimitives.tAny,
+  turns: import_validatorPrimitives.tInt,
+  inputTokens: import_validatorPrimitives.tInt,
+  outputTokens: import_validatorPrimitives.tInt
 });
 import_validatorPrimitives.scheme.FrameInitializer = (0, import_validatorPrimitives.tObject)({
   url: import_validatorPrimitives.tString,
@@ -2823,7 +2839,9 @@ import_validatorPrimitives.scheme.AndroidDeviceLaunchBrowserParams = (0, import_
     model: import_validatorPrimitives.tString,
     cacheFile: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
     cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "auto"])),
-    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue")))
+    secrets: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)((0, import_validatorPrimitives.tType)("NameValue"))),
+    maxTurns: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt),
+    maxTokens: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tInt)
   })),
   pkg: (0, import_validatorPrimitives.tOptional)(import_validatorPrimitives.tString),
   args: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tArray)(import_validatorPrimitives.tString)),

package/lib/server/agent/actionRunner.js

@@ -18,9 +18,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var actionRunner_exports = {};
 __export(actionRunner_exports, {
-  runAction: () => runAction
+  runAction: () => runAction,
+  serializeArgument: () => serializeArgument
 });
 module.exports = __toCommonJS(actionRunner_exports);
+var import_expectUtils = require("../utils/expectUtils");
+var import_serializers = require("../../protocol/serializers");
 async function runAction(progress, page, action, secrets) {
   const frame = page.mainFrame();
   switch (action.method) {
@@ -59,10 +62,38 @@ async function runAction(progress, page, action, secrets) {
       else
         await frame.uncheck(progress, action.selector, { ...strictTrue });
       break;
+    case "expectVisible": {
+      const result = await frame.expect(progress, action.selector, { expression: "to.be.visible", isNot: false }, 5e3);
+      if (result.errorMessage)
+        throw new Error(result.errorMessage);
+      break;
+    }
+    case "expectValue": {
+      let result;
+      if (action.type === "textbox" || action.type === "combobox" || action.type === "slider") {
+        const expectedText = (0, import_expectUtils.serializeExpectedTextValues)([action.value]);
+        result = await frame.expect(progress, action.selector, { expression: "to.have.value", expectedText, isNot: false }, 5e3);
+      } else if (action.type === "checkbox" || action.type === "radio") {
+        const expectedValue = serializeArgument({ checked: true });
+        result = await frame.expect(progress, action.selector, { expression: "to.be.checked", expectedValue, isNot: false }, 5e3);
+      } else {
+        throw new Error(`Unsupported element type: ${action.type}`);
+      }
+      if (result.errorMessage)
+        throw new Error(result.errorMessage);
+      break;
+    }
   }
 }
+function serializeArgument(arg) {
+  return {
+    value: (0, import_serializers.serializePlainValue)(arg),
+    handles: []
+  };
+}
 const strictTrue = { strict: true };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  runAction
+  runAction,
+  serializeArgument
 });

package/lib/server/agent/agent.js

@@ -41,11 +41,10 @@ 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);
+    return { turns: 0, inputTokens: 0, outputTokens: 0 };
+  const { usage } = await perform(context, options.task, void 0, options);
   await updateCache(context, options);
+  return usage;
 }
 async function pageExtract(progress, page, options) {
   const context = new import_context.Context(progress, page);
@@ -55,7 +54,8 @@ Extract the following information from the page. Do not perform any actions, jus
 
 ### Query
 ${options.query}`;
-  return await perform(context, task, options.schema, options);
+  const { result, usage } = await perform(context, task, options.schema, options);
+  return { result, usage };
 }
 async function perform(context, userTask, resultSchema, options = {}) {
   const { progress, page } = context;
@@ -64,12 +64,23 @@ async function perform(context, userTask, resultSchema, options = {}) {
     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 limits = context.limits(options);
+  let turns = 0;
   const loop = new import_mcpBundle.Loop(browserContext._options.agent.provider, {
     model: browserContext._options.agent.model,
     summarize: true,
     debug: import_utilsBundle.debug,
     callTool,
     tools,
+    ...limits,
+    beforeTurn: (params) => {
+      ++turns;
+      const lastReply = params.conversation.messages.findLast((m) => m.role === "assistant");
+      const toolCall = lastReply?.content.find((c) => c.type === "tool_call");
+      if (!resultSchema && toolCall && toolCall.arguments.thatShouldBeIt)
+        return "break";
+      return "continue";
+    },
     ...options
   });
   const task = `${userTask}
@@ -77,16 +88,22 @@ async function perform(context, userTask, resultSchema, options = {}) {
 ### Page snapshot
 ${full}
 `;
-  return await loop.run(task, {
-    resultSchema
-  });
+  const { result, usage } = await loop.run(task, { resultSchema });
+  return {
+    result,
+    usage: {
+      turns,
+      inputTokens: usage.input,
+      outputTokens: usage.output
+    }
+  };
 }
 const allCaches = /* @__PURE__ */ new Map();
 async function cachedPerform(context, options) {
   if (!context.options?.cacheFile || context.options.cacheMode === "ignore")
     return false;
   const cache = await cachedActions(context.options.cacheFile);
-  const cacheKey = options.key ?? options.task;
+  const cacheKey = (options.key ?? options.task).trim();
   const entry = cache[cacheKey];
   if (!entry) {
     if (context.options.cacheMode === "force")
@@ -102,7 +119,7 @@ async function updateCache(context, options) {
   if (!cacheFile)
     return;
   const cache = await cachedActions(cacheFile);
-  const cacheKey = options.key ?? options.task;
+  const cacheKey = (options.key ?? options.task).trim();
   cache[cacheKey] = {
     timestamp: Date.now(),
     actions: context.actions
@@ -112,8 +129,7 @@ async function updateCache(context, options) {
 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);
+    cache = await import_fs.default.promises.readFile(cacheFile, "utf-8").then((text) => JSON.parse(text)).catch(() => ({}));
     allCaches.set(cacheFile, cache);
   }
   return cache;

package/lib/server/agent/backend.js

@@ -32,7 +32,6 @@ __export(backend_exports, {
 });
 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) => {
@@ -44,6 +43,7 @@ function toolsForLoop(context) {
     return result;
   });
   const callTool = async (params) => {
+    const intent = params.arguments._meta?.["dev.lowire/intent"];
     const tool = import_tools.default.find((t) => t.schema.name === params.name);
     if (!tool) {
       return {
@@ -54,11 +54,8 @@ function toolsForLoop(context) {
         isError: true
       };
     }
-    const progressController = new import_progress.ProgressController();
     try {
-      return await progressController.run(async (progress) => {
-        return await tool.handle(context, params.arguments);
-      });
+      return await context.callTool(tool, params.arguments, { intent });
     } catch (error) {
       return {
         content: [{ type: "text", text: error.message }],

package/lib/server/agent/codegen.js

@@ -0,0 +1,83 @@
+"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 codegen_exports = {};
+__export(codegen_exports, {
+  generateCode: () => generateCode
+});
+module.exports = __toCommonJS(codegen_exports);
+var import_locatorGenerators = require("../../utils/isomorphic/locatorGenerators");
+var import_stringUtils = require("../../utils/isomorphic/stringUtils");
+async function generateCode(sdkLanguage, action) {
+  switch (action.method) {
+    case "click": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      return `await page.${locator}.click(${(0, import_stringUtils.formatObjectOrVoid)(action.options)});`;
+    }
+    case "drag": {
+      const sourceLocator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.sourceSelector);
+      const targetLocator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.targetSelector);
+      return `await page.${sourceLocator}.dragAndDrop(${targetLocator});`;
+    }
+    case "hover": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      return `await page.${locator}.hover(${(0, import_stringUtils.formatObjectOrVoid)(action.options)});`;
+    }
+    case "pressKey": {
+      return `await page.keyboard.press(${(0, import_stringUtils.escapeWithQuotes)(action.key, "'")});`;
+    }
+    case "selectOption": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      return `await page.${locator}.selectOption(${action.labels.length === 1 ? (0, import_stringUtils.escapeWithQuotes)(action.labels[0]) : "[" + action.labels.map((label) => (0, import_stringUtils.escapeWithQuotes)(label)).join(", ") + "]"});`;
+    }
+    case "pressSequentially": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      const code = [`await page.${locator}.pressSequentially(${(0, import_stringUtils.escapeWithQuotes)(action.text)});`];
+      if (action.submit)
+        code.push(`await page.keyboard.press('Enter');`);
+      return code.join("\n");
+    }
+    case "fill": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      const code = [`await page.${locator}.fill(${(0, import_stringUtils.escapeWithQuotes)(action.text)});`];
+      if (action.submit)
+        code.push(`await page.keyboard.press('Enter');`);
+      return code.join("\n");
+    }
+    case "setChecked": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      if (action.checked)
+        return `await page.${locator}.check();`;
+      else
+        return `await page.${locator}.uncheck();`;
+    }
+    case "expectVisible": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      return `await expect(page.${locator}).toBeVisible();`;
+    }
+    case "expectValue": {
+      const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      return `await expect(page.${locator}).toHaveValue(${(0, import_stringUtils.escapeWithQuotes)(action.value)});`;
+    }
+  }
+  throw new Error("Unknown action " + action.method);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generateCode
+});

package/lib/server/agent/context.js

@@ -23,24 +23,39 @@ __export(context_exports, {
 module.exports = __toCommonJS(context_exports);
 var import_browserContext = require("../browserContext");
 var import_actionRunner = require("./actionRunner");
+var import_codegen = require("./codegen");
 class Context {
   constructor(progress, page) {
     this.actions = [];
     this.progress = progress;
     this.page = page;
     this.options = page.browserContext._options.agent;
+    this.sdkLanguage = page.browserContext._browser.sdkLanguage();
+  }
+  async callTool(tool, params, options) {
+    this._callIntent = options.intent;
+    try {
+      return await tool.handle(this, params);
+    } finally {
+      this._callIntent = void 0;
+    }
   }
   async runActionAndWait(action) {
     return await this.runActionsAndWait([action]);
   }
   async runActionsAndWait(action) {
-    await this.waitForCompletion(async () => {
-      for (const a of action) {
-        await (0, import_actionRunner.runAction)(this.progress, this.page, a, this.options?.secrets ?? []);
-        this.actions.push(a);
-      }
-    });
-    return await this.snapshotResult();
+    try {
+      await this.waitForCompletion(async () => {
+        for (const a of action) {
+          await (0, import_actionRunner.runAction)(this.progress, this.page, a, this.options?.secrets ?? []);
+          const code = await (0, import_codegen.generateCode)(this.sdkLanguage, a);
+          this.actions.push({ ...a, code, intent: this._callIntent });
+        }
+      });
+      return await this.snapshotResult();
+    } catch (e) {
+      return await this.snapshotResult(e);
+    }
   }
   async waitForCompletion(callback) {
     const requests = [];
@@ -73,17 +88,28 @@ class Context {
       await this.progress.wait(500);
     return result;
   }
-  async snapshotResult() {
+  async snapshotResult(error) {
     let { full } = await this.page.snapshotForAI(this.progress);
     full = this._redactText(full);
-    const text = [`# Page snapshot
-${full}`];
+    const text = [];
+    if (error)
+      text.push(`# Error
+${error.message}`);
+    else
+      text.push(`# Success`);
+    text.push(`# Page snapshot
+${full}`);
     return {
       _meta: {
         "dev.lowire/state": {
           "Page snapshot": full
-        }
+        },
+        "dev.lowire/history": error ? [{
+          category: "error",
+          content: error.message
+        }] : []
       },
+      isError: !!error,
       content: [{ type: "text", text: text.join("\n\n") }]
     };
   }
@@ -97,6 +123,12 @@ ${full}`];
       }
     }));
   }
+  limits(options = {}) {
+    return {
+      maxTurns: options.maxTurns ?? this.options?.maxTurns ?? 10,
+      maxTokens: options.maxTokens ?? this.options?.maxTokens ?? void 0
+    };
+  }
   _redactText(text) {
     const secrets = this.options?.secrets;
     if (!secrets)

package/lib/server/agent/tools.js

@@ -22,21 +22,25 @@ __export(tools_exports, {
 });
 module.exports = __toCommonJS(tools_exports);
 var import_mcpBundle = require("../../mcpBundle");
+var import_locatorUtils = require("../../utils/isomorphic/locatorUtils");
 function defineTool(tool) {
   return tool;
 }
+const baseSchema = import_mcpBundle.z.object({
+  thatShouldBeIt: import_mcpBundle.z.boolean().describe("Indicates that this tool call is sufficient to complete the task. If false, the task will continue with the next tool call")
+});
 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({})
+    inputSchema: baseSchema
   },
   handle: async (context, params) => {
     return await context.snapshotResult();
   }
 });
-const elementSchema = import_mcpBundle.z.object({
+const elementSchema = baseSchema.extend({
   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")
 });
@@ -70,7 +74,7 @@ const drag = defineTool({
     name: "browser_drag",
     title: "Drag mouse",
     description: "Perform drag and drop between two elements",
-    inputSchema: import_mcpBundle.z.object({
+    inputSchema: baseSchema.extend({
       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"),
@@ -181,7 +185,7 @@ const fillForm = defineTool({
     name: "browser_fill_form",
     title: "Fill form",
     description: "Fill multiple form fields",
-    inputSchema: import_mcpBundle.z.object({
+    inputSchema: baseSchema.extend({
       fields: import_mcpBundle.z.array(import_mcpBundle.z.object({
         name: import_mcpBundle.z.string().describe("Human-readable field name"),
         type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the field"),
@@ -217,6 +221,61 @@ const fillForm = defineTool({
     return await context.runActionsAndWait(actions);
   }
 });
+const expectVisible = defineTool({
+  schema: {
+    name: "browser_expect_visible",
+    title: "Expect element visible",
+    description: "Expect element is visible on the page",
+    inputSchema: baseSchema.extend({
+      role: import_mcpBundle.z.string().describe('ROLE of the element. Can be found in the snapshot like this: `- {ROLE} "Accessible Name":`'),
+      accessibleName: import_mcpBundle.z.string().describe('ACCESSIBLE_NAME of the element. Can be found in the snapshot like this: `- role "{ACCESSIBLE_NAME}"`')
+    })
+  },
+  handle: async (context, params) => {
+    return await context.runActionAndWait({
+      method: "expectVisible",
+      selector: (0, import_locatorUtils.getByRoleSelector)(params.role, { name: params.accessibleName })
+    });
+  }
+});
+const expectVisibleText = defineTool({
+  schema: {
+    name: "browser_expect_visible_text",
+    title: "Expect text visible",
+    description: `Expect text is visible on the page. Prefer ${expectVisible.schema.name} if possible.`,
+    inputSchema: baseSchema.extend({
+      text: import_mcpBundle.z.string().describe('TEXT to expect. Can be found in the snapshot like this: `- role "Accessible Name": {TEXT}` or like this: `- text: {TEXT}`')
+    })
+  },
+  handle: async (context, params) => {
+    return await context.runActionAndWait({
+      method: "expectVisible",
+      selector: (0, import_locatorUtils.getByTextSelector)(params.text)
+    });
+  }
+});
+const expectValue = defineTool({
+  schema: {
+    name: "browser_expect_value",
+    title: "Expect value",
+    description: "Expect element value",
+    inputSchema: baseSchema.extend({
+      type: import_mcpBundle.z.enum(["textbox", "checkbox", "radio", "combobox", "slider"]).describe("Type of the element"),
+      element: import_mcpBundle.z.string().describe("Human-readable element description"),
+      ref: import_mcpBundle.z.string().describe("Exact target element reference from the page snapshot"),
+      value: import_mcpBundle.z.string().describe('Value to expect. For checkbox, use "true" or "false".')
+    })
+  },
+  handle: async (context, params) => {
+    const [selector] = await context.refSelectors([{ ref: params.ref, element: params.element }]);
+    return await context.runActionAndWait({
+      method: "expectValue",
+      selector,
+      type: params.type,
+      value: params.value
+    });
+  }
+});
 var tools_default = [
   snapshot,
   click,
@@ -225,5 +284,8 @@ var tools_default = [
   selectOption,
   pressKey,
   type,
-  fillForm
+  fillForm,
+  expectVisible,
+  expectVisibleText,
+  expectValue
 ];

package/lib/server/artifact.js

@@ -103,7 +103,7 @@ class Artifact extends import_instrumentation.SdkObject {
     if (!this._unaccessibleErrorMessage)
       await import_fs.default.promises.unlink(this._localPath).catch((e) => {
       });
-    await this.reportFinished(new import_errors.TargetClosedError());
+    await this.reportFinished(new import_errors.TargetClosedError(this.closeReason()));
   }
   async reportFinished(error) {
     if (this._finished)

package/lib/server/chromium/crPage.js

@@ -357,9 +357,9 @@ class FrameSession {
       const { windowId } = await this._client.send("Browser.getWindowForTarget");
       this._windowId = windowId;
     }
-    let screencastOptions;
+    let videoOptions;
     if (!this._page.isStorageStatePage && this._isMainFrame() && hasUIWindow)
-      screencastOptions = await this._crPage._page.screencast.initializeVideoRecorder();
+      videoOptions = this._crPage._page.screencast.launchVideoRecorder();
     let lifecycleEventsEnabled;
     if (!this._isMainFrame())
       this._addRendererListeners();
@@ -439,15 +439,15 @@ class FrameSession {
           true
           /* runImmediately */
         ));
-      if (screencastOptions)
-        promises.push(this._crPage._page.screencast.startVideoRecording(screencastOptions));
+      if (videoOptions)
+        promises.push(this._crPage._page.screencast.startVideoRecording(videoOptions));
     }
     promises.push(this._client.send("Runtime.runIfWaitingForDebugger"));
     promises.push(this._firstNonInitialNavigationCommittedPromise);
     await Promise.all(promises);
   }
   dispose() {
-    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError());
+    this._firstNonInitialNavigationCommittedReject(new import_errors.TargetClosedError(this._page.closeReason()));
     for (const childSession of this._childSessions)
       childSession.dispose();
     if (this._parentSession)