playwright-core 1.58.0-alpha-2025-12-15 → 1.58.0-alpha-2025-12-17

package/lib/protocol/validator.js

@@ -612,7 +612,7 @@ import_validatorPrimitives.scheme.BrowserTypeLaunchPersistentContextParams = (0,
     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"])),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "update", "auto"])),
     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)
@@ -713,7 +713,7 @@ import_validatorPrimitives.scheme.BrowserNewContextParams = (0, import_validator
     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"])),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "update", "auto"])),
     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)
@@ -793,7 +793,7 @@ import_validatorPrimitives.scheme.BrowserNewContextForReuseParams = (0, import_v
     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"])),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "update", "auto"])),
     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)
@@ -918,7 +918,7 @@ import_validatorPrimitives.scheme.BrowserContextInitializer = (0, import_validat
       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"])),
+      cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "update", "auto"])),
       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)
@@ -1186,6 +1186,14 @@ import_validatorPrimitives.scheme.PageInitializer = (0, import_validatorPrimitiv
   isClosed: import_validatorPrimitives.tBoolean,
   opener: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tChannel)(["Page"]))
 });
+import_validatorPrimitives.scheme.PageAgentTurnEvent = (0, import_validatorPrimitives.tObject)({
+  role: import_validatorPrimitives.tString,
+  message: import_validatorPrimitives.tString,
+  usage: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tObject)({
+    inputTokens: import_validatorPrimitives.tInt,
+    outputTokens: import_validatorPrimitives.tInt
+  }))
+});
 import_validatorPrimitives.scheme.PageBindingCallEvent = (0, import_validatorPrimitives.tObject)({
   binding: (0, import_validatorPrimitives.tChannel)(["BindingCall"])
 });
@@ -2838,7 +2846,7 @@ import_validatorPrimitives.scheme.AndroidDeviceLaunchBrowserParams = (0, import_
     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"])),
+    cacheMode: (0, import_validatorPrimitives.tOptional)((0, import_validatorPrimitives.tEnum)(["ignore", "force", "update", "auto"])),
     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)

package/lib/server/agent/actionRunner.js

@@ -18,13 +18,25 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var actionRunner_exports = {};
 __export(actionRunner_exports, {
-  runAction: () => runAction,
-  serializeArgument: () => serializeArgument
+  generateActionTimeout: () => generateActionTimeout,
+  performActionTimeout: () => performActionTimeout,
+  runAction: () => runAction
 });
 module.exports = __toCommonJS(actionRunner_exports);
 var import_expectUtils = require("../utils/expectUtils");
-var import_serializers = require("../../protocol/serializers");
-async function runAction(progress, page, action, secrets) {
+var import_time = require("../../utils/isomorphic/time");
+var import_progress = require("../progress");
+async function runAction(parentProgress, mode, page, action, secrets) {
+  const timeout = mode === "generate" ? generateActionTimeout(action) : performActionTimeout(action);
+  const mt = (0, import_time.monotonicTime)();
+  const deadline = mt + timeout;
+  const minDeadline = parentProgress.deadline ? Math.min(parentProgress.deadline, deadline) : deadline;
+  const pc = new import_progress.ProgressController();
+  return await pc.run(async (progress) => {
+    return await innerRunAction(progress, page, action, secrets);
+  }, minDeadline - mt);
+}
+async function innerRunAction(progress, page, action, secrets) {
   const frame = page.mainFrame();
   switch (action.method) {
     case "click":
@@ -63,7 +75,7 @@ async function runAction(progress, page, action, secrets) {
         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);
+      const result = await frame.expect(progress, action.selector, { expression: "to.be.visible", isNot: false });
       if (result.errorMessage)
         throw new Error(result.errorMessage);
       break;
@@ -72,28 +84,56 @@ async function runAction(progress, page, action, secrets) {
       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);
+        result = await frame.expect(progress, action.selector, { expression: "to.have.value", expectedText, isNot: false });
       } 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);
+        const expectedValue = { checked: action.value === "true" };
+        result = await frame.expect(progress, action.selector, { selector: action.selector, expression: "to.be.checked", expectedValue, isNot: false });
       } else {
         throw new Error(`Unsupported element type: ${action.type}`);
       }
-      if (result.errorMessage)
+      if (!result.matches)
         throw new Error(result.errorMessage);
       break;
     }
   }
 }
-function serializeArgument(arg) {
-  return {
-    value: (0, import_serializers.serializePlainValue)(arg),
-    handles: []
-  };
+function generateActionTimeout(action) {
+  switch (action.method) {
+    case "click":
+    case "drag":
+    case "hover":
+    case "selectOption":
+    case "pressKey":
+    case "pressSequentially":
+    case "fill":
+    case "setChecked":
+      return 5e3;
+    case "expectVisible":
+    case "expectValue":
+      return 1;
+  }
+}
+function performActionTimeout(action) {
+  switch (action.method) {
+    case "click":
+    case "drag":
+    case "hover":
+    case "selectOption":
+    case "pressKey":
+    case "pressSequentially":
+    case "fill":
+    case "setChecked":
+      return 0;
+    // no timeout
+    case "expectVisible":
+    case "expectValue":
+      return 5e3;
+  }
 }
 const strictTrue = { strict: true };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  runAction,
-  serializeArgument
+  generateActionTimeout,
+  performActionTimeout,
+  runAction
 });

package/lib/server/agent/agent.js

@@ -38,11 +38,12 @@ var import_utilsBundle = require("../../utilsBundle");
 var import_mcpBundle = require("../../mcpBundle");
 var import_actionRunner = require("./actionRunner");
 var import_context = require("./context");
+var import_page = require("../page");
 async function pagePerform(progress, page, options) {
   const context = new import_context.Context(progress, page);
-  if (await cachedPerform(context, options))
+  if (await cachedPerform(progress, context, options))
     return { turns: 0, inputTokens: 0, outputTokens: 0 };
-  const { usage } = await perform(context, options.task, void 0, options);
+  const { usage } = await perform(progress, context, options.task, void 0, options);
   await updateCache(context, options);
   return usage;
 }
@@ -54,16 +55,17 @@ Extract the following information from the page. Do not perform any actions, jus
 
 ### Query
 ${options.query}`;
-  const { result, usage } = await perform(context, task, options.schema, options);
+  const { result, usage } = await perform(progress, context, task, options.schema, options);
   return { result, usage };
 }
-async function perform(context, userTask, resultSchema, options = {}) {
-  const { progress, page } = context;
+async function perform(progress, context, userTask, resultSchema, options = {}) {
+  const { 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);
+  page.emit(import_page.Page.Events.AgentTurn, { role: "user", message: userTask });
   const limits = context.limits(options);
   let turns = 0;
   const loop = new import_mcpBundle.Loop(browserContext._options.agent.provider, {
@@ -73,14 +75,35 @@ async function perform(context, userTask, resultSchema, options = {}) {
     callTool,
     tools,
     ...limits,
-    beforeTurn: (params) => {
+    onBeforeTurn: ({ conversation }) => {
+      const userMessage = conversation.messages.find((m) => m.role === "user");
+      page.emit(import_page.Page.Events.AgentTurn, { role: "user", message: userMessage?.content ?? "" });
+      return "continue";
+    },
+    onAfterTurn: ({ assistantMessage, totalUsage }) => {
       ++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)
+      const usage2 = { inputTokens: totalUsage.input, outputTokens: totalUsage.output };
+      const intent = assistantMessage.content.filter((c) => c.type === "text").map((c) => c.text).join("\n");
+      page.emit(import_page.Page.Events.AgentTurn, { role: "assistant", message: intent, usage: usage2 });
+      if (!assistantMessage.content.filter((c) => c.type === "tool_call").length)
+        page.emit(import_page.Page.Events.AgentTurn, { role: "assistant", message: `no tool calls`, usage: usage2 });
+      return "continue";
+    },
+    onBeforeToolCall: ({ toolCall }) => {
+      page.emit(import_page.Page.Events.AgentTurn, { role: "assistant", message: `call tool "${toolCall.name}"` });
+      return "continue";
+    },
+    onAfterToolCall: ({ toolCall }) => {
+      const suffix = toolCall.result?.isError ? "failed" : "succeeded";
+      page.emit(import_page.Page.Events.AgentTurn, { role: "user", message: `tool "${toolCall.name}" ${suffix}` });
+      if (toolCall.arguments.thatShouldBeIt)
         return "break";
       return "continue";
     },
+    onToolCallError: ({ toolCall, error }) => {
+      page.emit(import_page.Page.Events.AgentTurn, { role: "user", message: `tool "${toolCall.name}" failed: ${error.message}` });
+      return "continue";
+    },
     ...options
   });
   const task = `${userTask}
@@ -99,8 +122,8 @@ ${full}
   };
 }
 const allCaches = /* @__PURE__ */ new Map();
-async function cachedPerform(context, options) {
-  if (!context.options?.cacheFile || context.options.cacheMode === "ignore")
+async function cachedPerform(progress, context, options) {
+  if (!context.options?.cacheFile || context.options.cacheMode === "ignore" || context.options.cacheMode === "update")
     return false;
   const cache = await cachedActions(context.options.cacheFile);
   const cacheKey = (options.key ?? options.task).trim();
@@ -111,7 +134,7 @@ async function cachedPerform(context, options) {
     return false;
   }
   for (const action of entry.actions)
-    await (0, import_actionRunner.runAction)(context.progress, context.page, action, context.options.secrets ?? []);
+    await (0, import_actionRunner.runAction)(progress, "run", context.page, action, context.options.secrets ?? []);
   return true;
 }
 async function updateCache(context, options) {
@@ -124,7 +147,9 @@ async function updateCache(context, options) {
     timestamp: Date.now(),
     actions: context.actions
   };
-  await import_fs.default.promises.writeFile(cacheFile, JSON.stringify(cache, void 0, 2));
+  const entries = Object.entries(cache);
+  entries.sort((e1, e2) => e1[0].localeCompare(e2[0]));
+  await import_fs.default.promises.writeFile(cacheFile, JSON.stringify(Object.fromEntries(entries), void 0, 2));
 }
 async function cachedActions(cacheFile) {
   let cache = allCaches.get(cacheFile);

package/lib/server/agent/codegen.js

@@ -72,6 +72,8 @@ async function generateCode(sdkLanguage, action) {
     }
     case "expectValue": {
       const locator = (0, import_locatorGenerators.asLocator)(sdkLanguage, action.selector);
+      if (action.type === "checkbox" || action.type === "radio")
+        return `await expect(page.${locator}).toBeChecked({ checked: ${action.value === "true"} });`;
       return `await expect(page.${locator}).toHaveValue(${(0, import_stringUtils.escapeWithQuotes)(action.value)});`;
     }
   }

package/lib/server/agent/context.js

@@ -25,9 +25,9 @@ var import_browserContext = require("../browserContext");
 var import_actionRunner = require("./actionRunner");
 var import_codegen = require("./codegen");
 class Context {
-  constructor(progress, page) {
+  constructor(apiCallProgress, page) {
     this.actions = [];
-    this.progress = progress;
+    this._progress = apiCallProgress;
     this.page = page;
     this.options = page.browserContext._options.agent;
     this.sdkLanguage = page.browserContext._browser.sdkLanguage();
@@ -44,18 +44,15 @@ class Context {
     return await this.runActionsAndWait([action]);
   }
   async runActionsAndWait(action) {
-    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);
-    }
+    const error = await this.waitForCompletion(async () => {
+      for (const a of action) {
+        await (0, import_actionRunner.runAction)(this._progress, "generate", 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 void 0;
+    }).catch((error2) => error2);
+    return await this.snapshotResult(error);
   }
   async waitForCompletion(callback) {
     const requests = [];
@@ -67,13 +64,13 @@ class Context {
     let result;
     try {
       result = await callback();
-      await this.progress.wait(500);
+      await this._progress.wait(500);
     } finally {
       disposeListeners();
     }
     const requestedNavigation = requests.some((request) => request.isNavigationRequest());
     if (requestedNavigation) {
-      await this.page.mainFrame().waitForLoadState(this.progress, "load");
+      await this.page.mainFrame().waitForLoadState(this._progress, "load");
       return result;
     }
     const promises = [];
@@ -83,13 +80,13 @@ class Context {
       else
         promises.push(request.response());
     }
-    await this.progress.race(promises, { timeout: 5e3 });
+    await this._progress.race(promises, { timeout: 5e3 });
     if (requests.length)
-      await this.progress.wait(500);
+      await this._progress.wait(500);
     return result;
   }
   async snapshotResult(error) {
-    let { full } = await this.page.snapshotForAI(this.progress);
+    let { full } = await this.page.snapshotForAI(this._progress);
     full = this._redactText(full);
     const text = [];
     if (error)
@@ -116,7 +113,7 @@ ${full}`);
   async refSelectors(params) {
     return Promise.all(params.map(async (param) => {
       try {
-        const { resolvedSelector } = await this.page.mainFrame().resolveSelector(this.progress, `aria-ref=${param.ref}`);
+        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.`);

package/lib/server/agent/tools.js

@@ -184,7 +184,7 @@ const fillForm = defineTool({
   schema: {
     name: "browser_fill_form",
     title: "Fill form",
-    description: "Fill multiple form fields",
+    description: "Fill multiple form fields. Always use this tool when you can fill more than one field at a time.",
     inputSchema: baseSchema.extend({
       fields: import_mcpBundle.z.array(import_mcpBundle.z.object({
         name: import_mcpBundle.z.string().describe("Human-readable field name"),

package/lib/server/bidi/bidiExecutionContext.js

@@ -123,7 +123,10 @@ class BidiExecutionContext {
       }
       return names2;
     });
-    const values = await Promise.all(names.map((name) => handle.evaluateHandle((object, name2) => object[name2], name)));
+    const values = await Promise.all(names.map(async (name) => {
+      const value = await this._rawCallFunction("(object, name) => object[name]", [{ handle: handle._objectId }, { type: "string", value: name }], true, false);
+      return createHandle(handle._context, value);
+    }));
     const map = /* @__PURE__ */ new Map();
     for (let i = 0; i < names.length; i++)
       map.set(names[i], values[i]);
@@ -152,7 +155,7 @@ class BidiExecutionContext {
     return createHandle(context, result);
   }
   async contentFrameIdForFrame(handle) {
-    const contentWindow = await this._rawCallFunction("e => e.contentWindow", { handle: handle._objectId });
+    const contentWindow = await this._rawCallFunction("e => e.contentWindow", [{ handle: handle._objectId }]);
     if (contentWindow?.type === "window")
       return contentWindow.value.context;
     return null;
@@ -166,17 +169,17 @@ class BidiExecutionContext {
     return null;
   }
   async _remoteValueForReference(reference, createHandle2) {
-    return await this._rawCallFunction("e => e", reference, createHandle2);
+    return await this._rawCallFunction("e => e", [reference], createHandle2);
   }
-  async _rawCallFunction(functionDeclaration, arg, createHandle2) {
+  async _rawCallFunction(functionDeclaration, args, createHandle2, awaitPromise = true) {
     const response = await this._session.send("script.callFunction", {
       functionDeclaration,
       target: this._target,
-      arguments: [arg],
+      arguments: args,
       // "Root" is necessary for the handle to be returned.
       resultOwnership: createHandle2 ? bidi.Script.ResultOwnership.Root : bidi.Script.ResultOwnership.None,
       serializationOptions: { maxObjectDepth: 0, maxDomDepth: 0 },
-      awaitPromise: true,
+      awaitPromise,
       userActivation: true
     });
     if (response.type === "exception")
@@ -186,14 +189,65 @@ class BidiExecutionContext {
     throw new js.JavaScriptErrorInEvaluate("Unexpected response type: " + JSON.stringify(response));
   }
 }
-function renderPreview(remoteObject) {
-  if (remoteObject.type === "undefined")
-    return "undefined";
-  if (remoteObject.type === "null")
-    return "null";
-  if ("value" in remoteObject)
-    return String(remoteObject.value);
-  return `<${remoteObject.type}>`;
+function renderPreview(remoteObject, nested = false) {
+  switch (remoteObject.type) {
+    case "undefined":
+    case "null":
+      return remoteObject.type;
+    case "number":
+    case "boolean":
+    case "string":
+      return String(remoteObject.value);
+    case "bigint":
+      return `${remoteObject.value}n`;
+    case "date":
+      return String(new Date(remoteObject.value));
+    case "regexp":
+      return String(new RegExp(remoteObject.value.pattern, remoteObject.value.flags));
+    case "node":
+      return remoteObject.value?.localName || "Node";
+    case "object":
+      if (nested)
+        return "Object";
+      const tokens = [];
+      for (const [name, value] of remoteObject.value || []) {
+        if (typeof name === "string")
+          tokens.push(`${name}: ${renderPreview(value, true)}`);
+      }
+      return `{${tokens.join(", ")}}`;
+    case "array":
+    case "htmlcollection":
+    case "nodelist":
+      if (nested || !remoteObject.value)
+        return remoteObject.value ? `Array(${remoteObject.value.length})` : "Array";
+      return `[${remoteObject.value.map((v) => renderPreview(v, true)).join(", ")}]`;
+    case "map":
+      return remoteObject.value ? `Map(${remoteObject.value.length})` : "Map";
+    case "set":
+      return remoteObject.value ? `Set(${remoteObject.value.length})` : "Set";
+    case "arraybuffer":
+      return "ArrayBuffer";
+    case "error":
+      return "Error";
+    case "function":
+      return "Function";
+    case "generator":
+      return "Generator";
+    case "promise":
+      return "Promise";
+    case "proxy":
+      return "Proxy";
+    case "symbol":
+      return "Symbol()";
+    case "typedarray":
+      return "TypedArray";
+    case "weakmap":
+      return "WeakMap";
+    case "weakset":
+      return "WeakSet";
+    case "window":
+      return "Window";
+  }
 }
 function remoteObjectValue(remoteObject) {
   if (remoteObject.type === "undefined")
@@ -212,7 +266,10 @@ function createHandle(context, remoteObject) {
     return new dom.ElementHandle(context, remoteObject.handle);
   }
   const objectId = "handle" in remoteObject ? remoteObject.handle : void 0;
-  return new js.JSHandle(context, remoteObject.type, renderPreview(remoteObject), objectId, remoteObjectValue(remoteObject));
+  const preview = renderPreview(remoteObject);
+  const handle = new js.JSHandle(context, remoteObject.type, preview, objectId, remoteObjectValue(remoteObject));
+  handle._setPreview(preview);
+  return handle;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/server/bidi/bidiPage.js

@@ -263,7 +263,7 @@ ${params.stackTrace?.callFrames.map((f) => {
       return;
     const callFrame = params.stackTrace?.callFrames[0];
     const location = callFrame ?? { url: "", lineNumber: 1, columnNumber: 1 };
-    this._page.addConsoleMessage(null, entry.method, entry.args.map((arg) => (0, import_bidiExecutionContext.createHandle)(context, arg)), location, params.text || void 0);
+    this._page.addConsoleMessage(null, entry.method, entry.args.map((arg) => (0, import_bidiExecutionContext.createHandle)(context, arg)), location);
   }
   async _onFileDialogOpened(params) {
     if (!params.element)

package/lib/server/dispatchers/pageDispatcher.js

@@ -67,6 +67,7 @@ class PageDispatcher extends import_dispatcher.Dispatcher {
       }
       this._dispatchEvent("route", { route: new import_networkDispatchers3.RouteDispatcher(import_networkDispatchers.RequestDispatcher.from(this.parentScope(), request), route) });
     };
+    this.addObjectListener(import_page.Page.Events.AgentTurn, (params) => this._dispatchEvent("agentTurn", params));
     this.addObjectListener(import_page.Page.Events.Close, () => {
       this._dispatchEvent("close");
       this._dispose();

package/lib/server/page.js

@@ -56,6 +56,7 @@ var import_callLog = require("./callLog");
 var rawBindingsControllerSource = __toESM(require("../generated/bindingsControllerSource"));
 var import_screencast = require("./screencast");
 const PageEvent = {
+  AgentTurn: "agentturn",
   Close: "close",
   Crash: "crash",
   Download: "download",

package/lib/server/progress.js

@@ -44,9 +44,11 @@ class ProgressController {
     await this._donePromise;
   }
   async run(task, timeout) {
+    const deadline = timeout ? (0, import_utils.monotonicTime)() + timeout : 0;
     (0, import_utils.assert)(this._state === "before");
     this._state = "running";
     const progress = {
+      deadline,
       log: (message) => {
         if (this._state === "running")
           this.metadata.log.push(message);
@@ -55,7 +57,9 @@ class ProgressController {
       metadata: this.metadata,
       race: (promise, options) => {
         const promises = Array.isArray(promise) ? promise : [promise];
-        const timerPromise = options?.timeout ? new Promise((f) => setTimeout(f, options.timeout)) : null;
+        const mt = (0, import_utils.monotonicTime)();
+        const dl = options?.timeout ? mt + options.timeout : 0;
+        const timerPromise = dl && (!deadline || dl < deadline) ? new Promise((f) => setTimeout(f, dl - mt)) : null;
         return Promise.race([...promises, ...timerPromise ? [timerPromise] : [], this._forceAbortPromise]);
       },
       wait: async (timeout2) => {
@@ -65,7 +69,7 @@ class ProgressController {
       }
     };
     let timer;
-    if (timeout) {
+    if (deadline) {
       const timeoutError = new import_errors.TimeoutError(`Timeout ${timeout}ms exceeded.`);
       timer = setTimeout(() => {
         if (this.metadata.pauseStartTime && !this.metadata.pauseEndTime)
@@ -75,7 +79,7 @@ class ProgressController {
           this._state = { error: timeoutError };
           this._forceAbortPromise.reject(timeoutError);
         }
-      }, timeout);
+      }, deadline - (0, import_utils.monotonicTime)());
     }
     try {
       const result = await task(progress);

package/lib/server/trace/viewer/traceViewer.js

@@ -47,20 +47,21 @@ var import_launchApp2 = require("../../launchApp");
 var import_playwright = require("../../playwright");
 var import_progress = require("../../progress");
 const tracesDirMarker = "traces.dir";
-function validateTraceUrl(traceUrl) {
-  if (!traceUrl)
-    return traceUrl;
-  if (traceUrl.startsWith("http://") || traceUrl.startsWith("https://"))
-    return traceUrl;
-  if (traceUrl.endsWith(".json"))
-    return traceUrl;
+function validateTraceUrl(traceFileOrUrl) {
+  if (!traceFileOrUrl)
+    return traceFileOrUrl;
+  if (traceFileOrUrl.startsWith("http://") || traceFileOrUrl.startsWith("https://"))
+    return traceFileOrUrl;
+  let traceFile = traceFileOrUrl;
+  if (traceFile.endsWith(".json"))
+    return toFilePathUrl(traceFile);
   try {
-    const stat = import_fs.default.statSync(traceUrl);
+    const stat = import_fs.default.statSync(traceFile);
     if (stat.isDirectory())
-      return import_path.default.join(traceUrl, tracesDirMarker);
-    return traceUrl;
+      traceFile = import_path.default.join(traceFile, tracesDirMarker);
+    return toFilePathUrl(traceFile);
   } catch {
-    throw new Error(`Trace file ${traceUrl} does not exist!`);
+    throw new Error(`Trace file ${traceFileOrUrl} does not exist!`);
   }
 }
 async function startTraceViewerServer(options) {
@@ -221,15 +222,18 @@ function traceDescriptor(traceDir, tracePrefix) {
   };
   for (const name of import_fs.default.readdirSync(traceDir)) {
     if (!tracePrefix || name.startsWith(tracePrefix))
-      result.entries.push({ name, path: import_path.default.join(traceDir, name) });
+      result.entries.push({ name, path: toFilePathUrl(import_path.default.join(traceDir, name)) });
   }
   const resourcesDir = import_path.default.join(traceDir, "resources");
   if (import_fs.default.existsSync(resourcesDir)) {
     for (const name of import_fs.default.readdirSync(resourcesDir))
-      result.entries.push({ name: "resources/" + name, path: import_path.default.join(resourcesDir, name) });
+      result.entries.push({ name: "resources/" + name, path: toFilePathUrl(import_path.default.join(resourcesDir, name)) });
   }
   return result;
 }
+function toFilePathUrl(filePath) {
+  return `file?path=${encodeURIComponent(filePath)}`;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   installRootRedirect,