playwright 1.56.0-alpha-2025-09-29 → 1.56.0-alpha-1759271123000

package/lib/agents/generateAgents.js

@@ -183,19 +183,19 @@ async function initClaudeCodeRepo() {
   }, null, 2));
 }
 const vscodeToolMap = /* @__PURE__ */ new Map([
-  ["ls", ["listDirectory", "fileSearch"]],
-  ["grep", ["textSearch"]],
-  ["read", ["readFile"]],
-  ["edit", ["editFiles"]],
-  ["write", ["createFile", "createDirectory"]]
+  ["ls", ["search/listDirectory", "search/fileSearch"]],
+  ["grep", ["search/textSearch"]],
+  ["read", ["search/readFile"]],
+  ["edit", ["edit/editFiles"]],
+  ["write", ["edit/createFile", "edit/createDirectory"]]
 ]);
-const vscodeToolsOrder = ["createFile", "createDirectory", "editFiles", "fileSearch", "textSearch", "listDirectory", "readFile"];
-const vscodeToolPrefix = "test_";
+const vscodeToolsOrder = ["edit/createFile", "edit/createDirectory", "edit/editFiles", "search/fileSearch", "search/textSearch", "search/listDirectory", "search/readFile"];
+const vscodeMcpName = "playwright-test";
 function saveAsVSCodeChatmode(agent) {
   function asVscodeTool(tool) {
     const [first, second] = tool.split("/");
     if (second)
-      return second.startsWith("browser_") ? vscodeToolPrefix + second : second;
+      return `${vscodeMcpName}/${second}`;
     return vscodeToolMap.get(first) || first;
   }
   const tools = agent.header.tools.map(asVscodeTool).flat().sort((a, b) => {
@@ -240,9 +240,7 @@ async function initVSCodeRepo() {
   mcpJson.servers["playwright-test"] = {
     type: "stdio",
     command: commonMcpServers.playwrightTest.command,
-    args: commonMcpServers.playwrightTest.args,
-    cwd: "${workspaceFolder}",
-    env: { "PLAYWRIGHT_MCP_TOOL_PREFIX": vscodeToolPrefix }
+    args: commonMcpServers.playwrightTest.args
   };
   await writeFile(mcpJsonPath, JSON.stringify(mcpJson, null, 2));
 }

package/lib/agents/generator.md

@@ -7,7 +7,6 @@ tools:
   - ls
   - grep
   - read
-  - write
   - playwright-test/browser_click
   - playwright-test/browser_drag
   - playwright-test/browser_evaluate
@@ -24,38 +23,29 @@ tools:
   - playwright-test/browser_verify_text_visible
   - playwright-test/browser_verify_value
   - playwright-test/browser_wait_for
-  - playwright-test/test_setup_page
+  - playwright-test/generator_log_step
+  - playwright-test/generator_read_log
+  - playwright-test/generator_setup_page
+  - playwright-test/generator_write_test
 ---
 
 You are a Playwright Test Generator, an expert in browser automation and end-to-end testing.
 Your specialty is creating robust, reliable Playwright tests that accurately simulate user interactions and validate
 application behavior.
 
-Your process is methodical and thorough:
-
-1. **Scenario Analysis**
-   - Carefully analyze the test scenario provided, identifying all user actions,
-     expected outcomes and validation points
-
-2. **Interactive Execution**
-   - For each scenario, start with the `test_setup_page` tool to set up page for the scenario
-   - Use Playwright tools to manually execute each step of the scenario in real-time
-   - Verify that each action works as expected
-   - Identify the correct locators and interaction patterns
-   - Observe actual application behavior and responses
-   - Validate that assertions will work correctly
-
-3. **Test Code Generation**
-
-   After successfully completing the manual execution, generate clean, maintainable
-   @playwright/test source code that follows following convention:
-
-   - One file per scenario, one test in a file
-   - Use seed test content (copyright, structure) to emit consistent tests.
-   - File name must be fs-friendly scenario name
-   - Test must be placed in a describe matching the top-level test plan item
-   - Test title must match the scenario name
-   - Includes a comment with the step text before each step execution
+# For each test you generate
+- Obtain the test plan with all the steps and verification specification
+- Run the `generator_setup_page` tool to set up page for the scenario
+- For each step and verification in the scenario, do the following:
+  - Use Playwright tool to manually execute it in real-time.
+  - Immediately after each tool execution, log the step via running `generator_log_step` tool.
+- Retrieve generator log via `generator_read_log`
+- Immediately after reading the test log, invoke `generator_write_test` with the generated source code
+  - File should contain single test
+  - File name must be fs-friendly scenario name
+  - Test must be placed in a describe matching the top-level test plan item
+  - Test title must match the scenario name
+  - Includes a comment with the step text before each step execution
 
    <example-generation>
    For following plan:
@@ -89,17 +79,17 @@ Your process is methodical and thorough:
    ```
    </example-generation>
 
-4. **Best practices**:
-   - Each test has clear, descriptive assertions that validate the expected behavior
-   - Includes proper error handling and meaningful failure messages
-   - Uses Playwright best practices (page.waitForLoadState, expect.toBeVisible, etc.)
-   - Do not improvise, do not add directives that were not asked for
-   - Uses reliable locators (preferring data-testid, role-based, or text-based selectors over fragile CSS selectors)
-   - Uses local variables for locators that are used multiple times
-   - Uses explicit waits rather than arbitrary timeouts
-   - Never waits for networkidle or use other discouraged or deprecated apis
-   - Is self-contained and can run independently
-   - Is deterministic and not prone to flaky behavior
+# Best practices
+- Each test has clear, descriptive assertions that validate the expected behavior
+- Includes proper error handling and meaningful failure messages
+- Uses Playwright best practices (page.waitForLoadState, expect.toBeVisible, etc.)
+- Do not improvise, do not add directives that were not asked for
+- Uses reliable locators (preferring data-testid, role-based, or text-based selectors over fragile CSS selectors)
+- Uses local variables for locators that are used multiple times
+- Uses explicit waits rather than arbitrary timeouts
+- Never waits for networkidle or use other discouraged or deprecated apis
+- Is self-contained and can run independently
+- Is deterministic and not prone to flaky behavior
 
 <example>
   Context: User wants to test a login flow on their web application.

package/lib/agents/planner.md

@@ -25,7 +25,7 @@ tools:
   - playwright-test/browser_take_screenshot
   - playwright-test/browser_type
   - playwright-test/browser_wait_for
-  - playwright-test/test_setup_page
+  - playwright-test/planner_setup_page
 ---
 
 You are an expert web test planner with extensive experience in quality assurance, user experience testing, and test
@@ -35,7 +35,7 @@ planning.
 You will:
 
 1. **Navigate and Explore**
-   - Invoke the `test_setup_page` tool once to set up page before using any other tools
+   - Invoke the `planner_setup_page` tool once to set up page before using any other tools
    - Explore the browser snapshot
    - Do not take screenshots unless absolutely necessary
    - Use browser_* tools to navigate and discover interface

package/lib/mcp/browser/tab.js

@@ -164,9 +164,9 @@ class Tab extends import_events.EventEmitter {
     }
     await this.waitForLoadState("load", { timeout: 5e3 });
   }
-  async consoleMessages() {
+  async consoleMessages(type) {
     await this._initializedPromise;
-    return this._consoleMessages;
+    return this._consoleMessages.filter((message) => type ? message.type === type : true);
   }
   async requests() {
     await this._initializedPromise;
@@ -249,13 +249,13 @@ function messageToConsoleMessage(message) {
 function pageErrorToConsoleMessage(errorOrValue) {
   if (errorOrValue instanceof Error) {
     return {
-      type: void 0,
+      type: "error",
       text: errorOrValue.message,
       toString: () => errorOrValue.stack || errorOrValue.message
     };
   }
   return {
-    type: void 0,
+    type: "error",
     text: String(errorOrValue),
     toString: () => String(errorOrValue)
   };

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

@@ -29,11 +29,13 @@ const console = (0, import_tool.defineTabTool)({
     name: "browser_console_messages",
     title: "Get console messages",
     description: "Returns all console messages",
-    inputSchema: import_bundle.z.object({}),
+    inputSchema: import_bundle.z.object({
+      onlyErrors: import_bundle.z.boolean().optional().describe("Only return error messages")
+    }),
     type: "readOnly"
   },
   handle: async (tab, params, response) => {
-    const messages = await tab.consoleMessages();
+    const messages = await tab.consoleMessages(params.onlyErrors ? "error" : void 0);
     messages.map((message) => response.addResult(message.toString()));
   }
 });

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

@@ -33,12 +33,16 @@ async function waitForCompletion(tab, callback) {
   const waitBarrier = new Promise((f) => {
     waitCallback = f;
   });
-  const requestListener = (request) => requests.add(request);
-  const requestFinishedListener = (request) => {
+  const responseListener = (request) => {
     requests.delete(request);
     if (!requests.size)
       waitCallback();
   };
+  const requestListener = (request) => {
+    requests.add(request);
+    void request.response().then(() => responseListener(request)).catch(() => {
+    });
+  };
   const frameNavigateListener = (frame) => {
     if (frame.parentFrame())
       return;
@@ -52,12 +56,12 @@ async function waitForCompletion(tab, callback) {
     waitCallback();
   };
   tab.page.on("request", requestListener);
-  tab.page.on("requestfinished", requestFinishedListener);
+  tab.page.on("requestfailed", responseListener);
   tab.page.on("framenavigated", frameNavigateListener);
   const timeout = setTimeout(onTimeout, 1e4);
   const dispose = () => {
     tab.page.off("request", requestListener);
-    tab.page.off("requestfinished", requestFinishedListener);
+    tab.page.off("requestfailed", responseListener);
     tab.page.off("framenavigated", frameNavigateListener);
     clearTimeout(timeout);
   };

package/lib/mcp/browser/tools.js

@@ -70,11 +70,6 @@ const browserTools = [
   ...import_wait.default,
   ...import_verify.default
 ];
-const customPrefix = process.env.PLAYWRIGHT_MCP_TOOL_PREFIX;
-if (customPrefix) {
-  for (const tool of browserTools)
-    tool.schema.name = customPrefix + tool.schema.name;
-}
 function filteredTools(config) {
   return browserTools.filter((tool) => tool.capability.startsWith("core") || config.capabilities?.includes(tool.capability));
 }

package/lib/mcp/sdk/mdb.js

@@ -44,10 +44,11 @@ const mdbDebug = (0, import_utilsBundle.debug)("pw:mcp:mdb");
 const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
 const z = mcpBundle.z;
 class MDBBackend {
-  constructor(topLevelBackend) {
+  constructor(topLevelBackend, allowedOnPause) {
     this._stack = [];
     this._progress = [];
     this._topLevelBackend = topLevelBackend;
+    this._allowedOnPause = allowedOnPause;
   }
   async initialize(server, clientInfo) {
     if (!this._clientInfo)
@@ -64,16 +65,25 @@ class MDBBackend {
       return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
     const interruptPromise = new import_utils.ManualPromise();
     this._interruptPromise = interruptPromise;
-    let [entry] = this._stack;
-    while (entry && !entry.toolNames.includes(name)) {
+    if (!this._allowedOnPause.includes(name)) {
+      for (let i = 0; i < this._stack.length - 1; i++) {
+        if (this._stack[i].toolNames.includes(name))
+          break;
+        await this._stack[i].client.close().catch(errorsDebug);
+        this._stack.shift();
+      }
+    }
+    let entry;
+    for (let i = 0; i < this._stack.length; i++) {
+      if (this._stack[i].toolNames.includes(name)) {
+        entry = this._stack[i];
+        break;
+      }
       mdbDebug("popping client from stack for ", name);
-      this._stack.shift();
-      await entry.client.close().catch(errorsDebug);
-      entry = this._stack[0];
     }
     if (!entry)
       throw new Error(`Tool ${name} not found in the tool stack`);
-    const client = await this._client();
+    const client = entry.client;
     const resultPromise = new import_utils.ManualPromise();
     entry.resultPromise = resultPromise;
     client.callTool({
@@ -111,7 +121,7 @@ class MDBBackend {
   }
   async _pushClient(transport, introMessage) {
     mdbDebug("pushing client to the stack");
-    const client = new mcpBundle.Client({ name: "Pushing client", version: "0.0.0" }, { capabilities: { roots: {} } });
+    const client = new mcpBundle.Client({ name: "Interrupting client", version: "0.0.0" }, { capabilities: { roots: {} } });
     client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));
     client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
     client.setNotificationHandler(mcpBundle.ProgressNotificationSchema, (notification) => {
@@ -147,8 +157,8 @@ const pushToolsSchema = (0, import_tool.defineToolSchema)({
   }),
   type: "readOnly"
 });
-async function runMainBackend(backendFactory, options) {
-  const mdbBackend = new MDBBackend(backendFactory.create());
+async function runMainBackend(backendFactory, allowedOnPause, options) {
+  const mdbBackend = new MDBBackend(backendFactory.create(), allowedOnPause);
   const factory = {
     ...backendFactory,
     create: () => mdbBackend
@@ -170,7 +180,7 @@ async function runOnPauseBackendLoop(backend, introMessage) {
   const httpServer = await mcpHttp.startHttpServer({ port: 0 });
   await mcpHttp.installHttpTransport(httpServer, factory);
   const url = mcpHttp.httpAddressToString(httpServer.address());
-  const client = new mcpBundle.Client({ name: "On-pause client", version: "0.0.0" });
+  const client = new mcpBundle.Client({ name: "Pushing client", version: "0.0.0" });
   client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
   const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(process.env.PLAYWRIGHT_DEBUGGER_MCP));
   await client.connect(transport);

package/lib/mcp/test/generatorTools.js

@@ -0,0 +1,140 @@
+"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 generatorTools_exports = {};
+__export(generatorTools_exports, {
+  generatorLogStep: () => generatorLogStep,
+  generatorReadLog: () => generatorReadLog,
+  generatorWriteTest: () => generatorWriteTest,
+  setupPage: () => setupPage
+});
+module.exports = __toCommonJS(generatorTools_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_bundle = require("../sdk/bundle");
+var import_testTool = require("./testTool");
+var import_testContext = require("./testContext");
+const setupPage = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "generator_setup_page",
+    title: "Setup generator page",
+    description: "Setup the page for test.",
+    inputSchema: import_bundle.z.object({
+      plan: import_bundle.z.string().describe("The plan for the test. This should be the actual test plan with all the steps."),
+      project: import_bundle.z.string().optional().describe('Project to use for setup. For example: "chromium", if no project is provided uses the first project in the config.'),
+      seedFile: import_bundle.z.string().optional().describe('A seed file contains a single test that is used to setup the page for testing, for example: "tests/seed.spec.ts". If no seed file is provided, a default seed file is created.')
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, progress) => {
+    const seed = await context.getOrCreateSeedFile(params);
+    context.generatorJournal = new import_testContext.GeneratorJournal(context.rootPath, params.plan, seed);
+    await context.runSeedTest(seed.file, params.project, progress);
+    return { content: [] };
+  }
+});
+const generatorLogStep = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "generator_log_step",
+    title: "Log a test step",
+    description: "Log a successful test step.",
+    inputSchema: import_bundle.z.object({
+      title: import_bundle.z.string().describe("Title of the test step"),
+      code: import_bundle.z.string().describe("The code for the last step only, as a markdown code block")
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params) => {
+    if (!context.generatorJournal)
+      throw new Error(`Please setup page using "${setupPage.schema.name}" first.`);
+    context.generatorJournal.logStep(params.title, params.code);
+    return { content: [] };
+  }
+});
+const generatorReadLog = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "generator_read_log",
+    title: "Retrieve test log",
+    description: "Retrieve the performed test log",
+    inputSchema: import_bundle.z.object({}),
+    type: "readOnly"
+  },
+  handle: async (context) => {
+    if (!context.generatorJournal)
+      throw new Error(`Please setup page using "${setupPage.schema.name}" first.`);
+    const result = context.generatorJournal.journal();
+    return { content: [{
+      type: "text",
+      text: result
+    }] };
+  }
+});
+const generatorWriteTest = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "generator_write_test",
+    title: "Write test",
+    description: "Write the generated test to the test file",
+    inputSchema: import_bundle.z.object({
+      fileName: import_bundle.z.string().describe("The file to write the test to"),
+      code: import_bundle.z.string().describe("The generated test code")
+    }),
+    type: "destructive"
+  },
+  handle: async (context, params) => {
+    if (!context.generatorJournal)
+      throw new Error(`Please setup page using "${setupPage.schema.name}" first.`);
+    const testRunner = context.existingTestRunner();
+    if (!testRunner)
+      throw new Error("No test runner found, please setup page and perform actions first.");
+    const config = await testRunner.loadConfig();
+    const dirs = [];
+    for (const project of config.projects) {
+      const testDir = import_path.default.relative(context.rootPath, project.project.testDir).replace(/\\/g, "/");
+      const fileName = params.fileName.replace(/\\/g, "/");
+      if (fileName.startsWith(testDir)) {
+        await import_fs.default.promises.writeFile(import_path.default.resolve(context.rootPath, fileName), params.code);
+        return {
+          content: [{
+            type: "text",
+            text: `### Result
+Test written to ${params.fileName}`
+          }]
+        };
+      }
+      dirs.push(testDir);
+    }
+    throw new Error(`Test file did not match any of the test dirs: ${dirs.join(", ")}`);
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  generatorLogStep,
+  generatorReadLog,
+  generatorWriteTest,
+  setupPage
+});

package/lib/mcp/test/plannerTools.js

@@ -0,0 +1,46 @@
+"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 plannerTools_exports = {};
+__export(plannerTools_exports, {
+  setupPage: () => setupPage
+});
+module.exports = __toCommonJS(plannerTools_exports);
+var import_bundle = require("../sdk/bundle");
+var import_testTool = require("./testTool");
+const setupPage = (0, import_testTool.defineTestTool)({
+  schema: {
+    name: "planner_setup_page",
+    title: "Setup planner page",
+    description: "Setup the page for test planning",
+    inputSchema: import_bundle.z.object({
+      project: import_bundle.z.string().optional().describe('Project to use for setup. For example: "chromium", if no project is provided uses the first project in the config.'),
+      seedFile: import_bundle.z.string().optional().describe('A seed file contains a single test that is used to setup the page for testing, for example: "tests/seed.spec.ts". If no seed file is provided, a default seed file is created.')
+    }),
+    type: "readOnly"
+  },
+  handle: async (context, params, progress) => {
+    const seed = await context.getOrCreateSeedFile(params);
+    await context.runSeedTest(seed.file, params.project, progress);
+    return { content: [] };
+  }
+});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  setupPage
+});

package/lib/mcp/test/seed.js

@@ -0,0 +1,73 @@
+"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 seed_exports = {};
+__export(seed_exports, {
+  ensureSeedTest: () => ensureSeedTest,
+  seedProject: () => seedProject
+});
+module.exports = __toCommonJS(seed_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("playwright-core/lib/utils");
+var import_projectUtils = require("../../runner/projectUtils");
+function seedProject(config, projectName) {
+  if (!projectName)
+    return (0, import_projectUtils.findTopLevelProjects)(config)[0];
+  const project = config.projects.find((p) => p.project.name === projectName);
+  if (!project)
+    throw new Error(`Project ${projectName} not found`);
+  return project;
+}
+async function ensureSeedTest(config, projectName, logNew) {
+  const project = seedProject(config, projectName);
+  const files = await (0, import_projectUtils.collectFilesForProject)(project);
+  const seed = files.find((file) => import_path.default.basename(file).includes("seed"));
+  if (seed)
+    return seed;
+  const testDir = project.project.testDir;
+  const seedFile = import_path.default.resolve(testDir, "seed.spec.ts");
+  if (logNew) {
+    console.log(`Writing file: ${import_path.default.relative(process.cwd(), seedFile)}`);
+  }
+  await (0, import_utils.mkdirIfNeeded)(seedFile);
+  await import_fs.default.promises.writeFile(seedFile, `import { test, expect } from '@playwright/test';
+
+test.describe('Test group', () => {
+  test('seed', async ({ page }) => {
+    // generate code here.
+  });
+});
+`);
+  return seedFile;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureSeedTest,
+  seedProject
+});

package/lib/mcp/test/testBackend.js

@@ -33,17 +33,33 @@ __export(testBackend_exports, {
 module.exports = __toCommonJS(testBackend_exports);
 var mcp = __toESM(require("../sdk/exports"));
 var import_testContext = require("./testContext");
-var import_testTools = require("./testTools.js");
+var testTools = __toESM(require("./testTools.js"));
+var generatorTools = __toESM(require("./generatorTools.js"));
+var plannerTools = __toESM(require("./plannerTools.js"));
 var import_tools = require("../browser/tools");
 var import_configLoader = require("../../common/configLoader");
 class TestServerBackend {
   constructor(configOption, options) {
     this.name = "Playwright";
     this.version = "0.0.1";
-    this._tools = [import_testTools.listTests, import_testTools.runTests, import_testTools.debugTest, import_testTools.setupPage];
+    this._tools = [
+      plannerTools.setupPage,
+      generatorTools.setupPage,
+      generatorTools.generatorLogStep,
+      generatorTools.generatorReadLog,
+      generatorTools.generatorWriteTest,
+      testTools.listTests,
+      testTools.runTests,
+      testTools.debugTest
+    ];
     this._context = new import_testContext.TestContext(options);
     this._configOption = configOption;
   }
+  static {
+    this.allowedOnPause = [
+      generatorTools.generatorLogStep.schema.name
+    ];
+  }
   async initialize(server, clientInfo) {
     const rootPath = mcp.firstRootPath(clientInfo);
     if (this._configOption) {

package/lib/mcp/test/testContext.js

@@ -1,7 +1,9 @@
 "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)
@@ -15,13 +17,54 @@ var __copyProps = (to, from, except, desc) => {
   }
   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 testContext_exports = {};
 __export(testContext_exports, {
+  GeneratorJournal: () => GeneratorJournal,
   TestContext: () => TestContext
 });
 module.exports = __toCommonJS(testContext_exports);
+var import_fs = __toESM(require("fs"));
+var import_path = __toESM(require("path"));
+var import_utils = require("playwright-core/lib/utils");
+var import_base = require("../../reporters/base");
+var import_list = __toESM(require("../../reporters/list"));
+var import_streams = require("./streams");
+var import_util = require("../../util");
 var import_testRunner = require("../../runner/testRunner");
+var import_seed = require("./seed");
+class GeneratorJournal {
+  constructor(rootPath, plan, seed) {
+    this._rootPath = rootPath;
+    this._plan = plan;
+    this._seed = seed;
+    this._steps = [];
+  }
+  logStep(title, code) {
+    this._steps.push({ title, code });
+  }
+  journal() {
+    const result = [];
+    result.push(`# Plan`);
+    result.push(this._plan);
+    result.push(`# Seed file: ${import_path.default.relative(this._rootPath, this._seed.file)}`);
+    result.push("```ts");
+    result.push(this._seed.content);
+    result.push("```");
+    result.push(`# Steps`);
+    result.push(this._steps.map((step) => `### ${step.title}
+${step.code}`).join("\n\n"));
+    return result.join("\n\n");
+  }
+}
 class TestContext {
   constructor(options) {
     this.options = options;
@@ -30,6 +73,9 @@ class TestContext {
     this.configLocation = configLocation;
     this.rootPath = rootPath || configLocation.configDir;
   }
+  existingTestRunner() {
+    return this._testRunner;
+  }
   async createTestRunner() {
     if (this._testRunner)
       await this._testRunner.stopTests();
@@ -42,10 +88,67 @@ class TestContext {
     this._testRunner = testRunner;
     return testRunner;
   }
+  async getOrCreateSeedFile(params) {
+    const configDir = this.configLocation.configDir;
+    const testRunner = await this.createTestRunner();
+    const config = await testRunner.loadConfig();
+    let seedFile;
+    if (!params.seedFile) {
+      seedFile = await (0, import_seed.ensureSeedTest)(config, params.project, false);
+    } else {
+      const candidateFiles = [];
+      const testDir = (0, import_seed.seedProject)(config, params.project).project.testDir;
+      candidateFiles.push(import_path.default.resolve(testDir, params.seedFile));
+      candidateFiles.push(import_path.default.resolve(configDir, params.seedFile));
+      candidateFiles.push(import_path.default.resolve(this.rootPath, params.seedFile));
+      for (const candidateFile of candidateFiles) {
+        if (await (0, import_util.fileExistsAsync)(candidateFile)) {
+          seedFile = candidateFile;
+          break;
+        }
+      }
+      if (!seedFile)
+        throw new Error("seed test not found.");
+    }
+    const seedFileContent = await import_fs.default.promises.readFile(seedFile, "utf8");
+    return { file: seedFile, content: seedFileContent };
+  }
+  async runSeedTest(seedFile, projectName, progress) {
+    const { screen } = this.createScreen(progress);
+    const configDir = this.configLocation.configDir;
+    const reporter = new import_list.default({ configDir, screen });
+    const testRunner = await this.createTestRunner();
+    const result = await testRunner.runTests(reporter, {
+      headed: !this.options?.headless,
+      locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
+      projects: projectName ? [projectName] : void 0,
+      timeout: 0,
+      workers: 1,
+      pauseAtEnd: true,
+      disableConfigReporters: true,
+      failOnLoadErrors: true
+    });
+    if (result.status === "passed" && !reporter.suite?.allTests().length)
+      throw new Error("seed test not found.");
+    if (result.status !== "passed")
+      throw new Error("Errors while running the seed test.");
+  }
+  createScreen(progress) {
+    const stream = new import_streams.StringWriteStream(progress);
+    const screen = {
+      ...import_base.terminalScreen,
+      isTTY: false,
+      colors: import_utils.noColors,
+      stdout: stream,
+      stderr: stream
+    };
+    return { screen, stream };
+  }
   async close() {
   }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  GeneratorJournal,
   TestContext
 });

package/lib/mcp/test/testTools.js

@@ -30,21 +30,13 @@ var testTools_exports = {};
 __export(testTools_exports, {
   debugTest: () => debugTest,
   listTests: () => listTests,
-  runTests: () => runTests,
-  setupPage: () => setupPage
+  runTests: () => runTests
 });
 module.exports = __toCommonJS(testTools_exports);
-var import_fs = __toESM(require("fs"));
-var import_path = __toESM(require("path"));
-var import_utils = require("playwright-core/lib/utils");
 var import_bundle = require("../sdk/bundle");
-var import_base = require("../../reporters/base");
 var import_list = __toESM(require("../../reporters/list"));
 var import_listModeReporter = __toESM(require("../../reporters/listModeReporter"));
-var import_projectUtils = require("../../runner/projectUtils");
 var import_testTool = require("./testTool");
-var import_streams = require("./streams");
-var import_util = require("../../util");
 const listTests = (0, import_testTool.defineTestTool)({
   schema: {
     name: "test_list",
@@ -54,7 +46,7 @@ const listTests = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, _, progress) => {
-    const { screen } = createScreen(progress);
+    const { screen } = context.createScreen(progress);
     const reporter = new import_listModeReporter.default({ screen, includeTestId: true });
     const testRunner = await context.createTestRunner();
     await testRunner.listTests(reporter, {});
@@ -73,7 +65,7 @@ const runTests = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, params, progress) => {
-    const { screen } = createScreen(progress);
+    const { screen } = context.createScreen(progress);
     const configDir = context.configLocation.configDir;
     const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
     const testRunner = await context.createTestRunner();
@@ -99,7 +91,7 @@ const debugTest = (0, import_testTool.defineTestTool)({
     type: "readOnly"
   },
   handle: async (context, params, progress) => {
-    const { screen } = createScreen(progress);
+    const { screen } = context.createScreen(progress);
     const configDir = context.configLocation.configDir;
     const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
     const testRunner = await context.createTestRunner();
@@ -115,90 +107,9 @@ const debugTest = (0, import_testTool.defineTestTool)({
     return { content: [] };
   }
 });
-const setupPage = (0, import_testTool.defineTestTool)({
-  schema: {
-    name: "test_setup_page",
-    title: "Setup page",
-    description: "Setup the page for test.",
-    inputSchema: import_bundle.z.object({
-      project: import_bundle.z.string().optional().describe('Project to use for setup. For example: "chromium", if no project is provided uses the first project in the config.'),
-      seedFile: import_bundle.z.string().optional().describe('A seed file contains a single test that is used to setup the page for testing, for example: "tests/seed.spec.ts". If no seed file is provided, a default seed file is created.')
-    }),
-    type: "readOnly"
-  },
-  handle: async (context, params, progress) => {
-    const { screen } = createScreen(progress);
-    const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen });
-    const testRunner = await context.createTestRunner();
-    const config = await testRunner.loadConfig();
-    const project = params.project ? config.projects.find((p) => p.project.name === params.project) : (0, import_projectUtils.findTopLevelProjects)(config)[0];
-    const testDir = project?.project.testDir || configDir;
-    let seedFile;
-    if (!params.seedFile) {
-      seedFile = import_path.default.resolve(testDir, "seed.spec.ts");
-      await import_fs.default.promises.mkdir(import_path.default.dirname(seedFile), { recursive: true });
-      await import_fs.default.promises.writeFile(seedFile, `import { test, expect } from '@playwright/test';
-
-test.describe('Test group', () => {
-  test('seed', async ({ page }) => {
-    // generate code here.
-  });
-});
-`);
-    } else {
-      const candidateFiles = [];
-      candidateFiles.push(import_path.default.resolve(testDir, params.seedFile));
-      candidateFiles.push(import_path.default.resolve(configDir, params.seedFile));
-      candidateFiles.push(import_path.default.resolve(context.rootPath, params.seedFile));
-      for (const candidateFile of candidateFiles) {
-        if (await (0, import_util.fileExistsAsync)(candidateFile)) {
-          seedFile = candidateFile;
-          break;
-        }
-      }
-      if (!seedFile)
-        throw new Error("seed test not found.");
-    }
-    const seedFileContent = await import_fs.default.promises.readFile(seedFile, "utf8");
-    progress({ message: `### Seed test
-File: ${import_path.default.relative(context.rootPath, seedFile)}
-\`\`\`ts
-${seedFileContent}
-\`\`\`
-` });
-    const result = await testRunner.runTests(reporter, {
-      headed: !context.options?.headless,
-      locations: ["/" + (0, import_utils.escapeRegExp)(seedFile) + "/"],
-      projects: params.project ? [params.project] : void 0,
-      timeout: 0,
-      workers: 1,
-      pauseAtEnd: true,
-      disableConfigReporters: true,
-      failOnLoadErrors: true
-    });
-    if (result.status === "passed" && !reporter.suite?.allTests().length)
-      throw new Error("seed test not found.");
-    if (result.status !== "passed")
-      throw new Error("Errors while running the seed test.");
-    return { content: [] };
-  }
-});
-function createScreen(progress) {
-  const stream = new import_streams.StringWriteStream(progress);
-  const screen = {
-    ...import_base.terminalScreen,
-    isTTY: false,
-    colors: import_utils.noColors,
-    stdout: stream,
-    stderr: stream
-  };
-  return { screen, stream };
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   debugTest,
   listTests,
-  runTests,
-  setupPage
+  runTests
 });

package/lib/program.js

@@ -48,6 +48,7 @@ var import_testRunner = require("./runner/testRunner");
 var import_reporters = require("./runner/reporters");
 var import_exports = require("./mcp/sdk/exports");
 var import_testBackend = require("./mcp/test/testBackend");
+var import_seed = require("./mcp/test/seed");
 var import_program3 = require("./mcp/program");
 var import_watchdog = require("./mcp/browser/watchdog");
 var import_generateAgents = require("./agents/generateAgents");
@@ -165,7 +166,13 @@ function addTestMCPServerCommand(program3) {
       version: packageJSON.version,
       create: () => new import_testBackend.TestServerBackend(options.config, { muteConsole: options.port === void 0, headless: options.headless })
     };
-    const mdbUrl = await (0, import_exports.runMainBackend)(backendFactory, { port: options.port === void 0 ? void 0 : +options.port });
+    const mdbUrl = await (0, import_exports.runMainBackend)(
+      backendFactory,
+      import_testBackend.TestServerBackend.allowedOnPause,
+      {
+        port: options.port === void 0 ? void 0 : +options.port
+      }
+    );
     if (mdbUrl)
       console.error("MCP Listening on: ", mdbUrl);
   });
@@ -176,15 +183,21 @@ function addInitAgentsCommand(program3) {
   const option = command.createOption("--loop <loop>", "Agentic loop provider");
   option.choices(["vscode", "claude", "opencode"]);
   command.addOption(option);
+  command.option("-c, --config <file>", `Configuration file to find a project to use for seed test`);
+  command.option("--project <project>", "Project to use for seed test");
   command.action(async (opts) => {
-    if (opts.loop === "opencode")
+    if (opts.loop === "opencode") {
       await (0, import_generateAgents.initOpencodeRepo)();
-    else if (opts.loop === "vscode")
+    } else if (opts.loop === "vscode") {
       await (0, import_generateAgents.initVSCodeRepo)();
-    else if (opts.loop === "claude")
+    } else if (opts.loop === "claude") {
       await (0, import_generateAgents.initClaudeCodeRepo)();
-    else
+    } else {
       command.help();
+      return;
+    }
+    const config = await (0, import_configLoader.loadConfigFromFile)(opts.config);
+    await (0, import_seed.ensureSeedTest)(config, opts.project, true);
   });
 }
 async function runTests(args, opts) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "playwright",
-  "version": "1.56.0-alpha-2025-09-29",
+  "version": "1.56.0-alpha-1759271123000",
   "description": "A high-level API to automate web browsers",
   "repository": {
     "type": "git",
@@ -64,7 +64,7 @@
   },
   "license": "Apache-2.0",
   "dependencies": {
-    "playwright-core": "1.56.0-alpha-2025-09-29"
+    "playwright-core": "1.56.0-alpha-1759271123000"
   },
   "optionalDependencies": {
     "fsevents": "2.3.2"

package/types/testReporter.d.ts

@@ -773,7 +773,7 @@ export interface TestStep {
    * - `hook` for hooks initialization and teardown
    * - `pw:api` for Playwright API calls.
    * - `test.step` for test.step API calls.
-   * - `test.attach` for test attachmen calls.
+   * - `test.attach` for testInfo.attach API calls.
    */
   category: string;