playwright 1.56.0-alpha-2025-09-25 → 1.56.0-alpha-1758839353000

package/lib/agents/generator.md

@@ -51,6 +51,7 @@ Your process is methodical and thorough:
    @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

package/lib/mcp/sdk/bundle.js

@@ -33,6 +33,7 @@ __export(bundle_exports, {
   ListRootsRequestSchema: () => ListRootsRequestSchema,
   ListToolsRequestSchema: () => ListToolsRequestSchema,
   PingRequestSchema: () => PingRequestSchema,
+  ProgressNotificationSchema: () => ProgressNotificationSchema,
   SSEServerTransport: () => SSEServerTransport,
   Server: () => Server,
   StdioClientTransport: () => StdioClientTransport,
@@ -54,6 +55,7 @@ const StreamableHTTPServerTransport = bundle.StreamableHTTPServerTransport;
 const StreamableHTTPClientTransport = bundle.StreamableHTTPClientTransport;
 const CallToolRequestSchema = bundle.CallToolRequestSchema;
 const ListRootsRequestSchema = bundle.ListRootsRequestSchema;
+const ProgressNotificationSchema = bundle.ProgressNotificationSchema;
 const ListToolsRequestSchema = bundle.ListToolsRequestSchema;
 const PingRequestSchema = bundle.PingRequestSchema;
 const z = bundle.z;
@@ -64,6 +66,7 @@ const z = bundle.z;
   ListRootsRequestSchema,
   ListToolsRequestSchema,
   PingRequestSchema,
+  ProgressNotificationSchema,
   SSEServerTransport,
   Server,
   StdioClientTransport,

package/lib/mcp/sdk/mdb.js

@@ -46,6 +46,7 @@ const z = mcpBundle.z;
 class MDBBackend {
   constructor(topLevelBackend) {
     this._stack = [];
+    this._progress = [];
     this._topLevelBackend = topLevelBackend;
   }
   async initialize(server, clientInfo) {
@@ -77,15 +78,22 @@ class MDBBackend {
     entry.resultPromise = resultPromise;
     client.callTool({
       name,
-      arguments: args
+      arguments: args,
+      _meta: {
+        progressToken: name + "@" + (0, import_utils.createGuid)().slice(0, 8)
+      }
     }).then((result2) => {
       resultPromise.resolve(result2);
-    }).catch((e) => resultPromise.reject(e));
+    }).catch((e) => {
+      resultPromise.resolve({ content: [{ type: "text", text: String(e) }], isError: true });
+    });
     const result = await Promise.race([interruptPromise, resultPromise]);
     if (interruptPromise.isDone())
       mdbDebug("client call intercepted", result);
     else
       mdbDebug("client call result", result);
+    result.content.unshift(...this._progress);
+    this._progress.length = 0;
     return result;
   }
   async _client() {
@@ -106,6 +114,13 @@ class MDBBackend {
     const client = new mcpBundle.Client({ name: "Pushing client", version: "0.0.0" }, { capabilities: { roots: {} } });
     client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));
     client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    client.setNotificationHandler(mcpBundle.ProgressNotificationSchema, (notification) => {
+      if (notification.method === "notifications/progress") {
+        const { message } = notification.params;
+        if (message)
+          this._progress.push({ type: "text", text: message });
+      }
+    });
     await client.connect(transport);
     mdbDebug("connected to the new client");
     const { tools } = await client.listTools();
@@ -189,8 +204,8 @@ class ServerBackendWithCloseListener {
   async listTools() {
     return this._backend.listTools();
   }
-  async callTool(name, args) {
-    return this._backend.callTool(name, args);
+  async callTool(name, args, progress) {
+    return this._backend.callTool(name, args, progress);
   }
   serverClosed(server) {
     this._backend.serverClosed?.(server);

package/lib/mcp/sdk/server.js

@@ -61,13 +61,27 @@ function createServer(name, version, backend, runHeartbeat) {
     return { tools };
   });
   let initializePromise;
-  server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request, extra) => {
     serverDebug("callTool", request);
+    const progressToken = request.params._meta?.progressToken;
+    let progressCounter = 0;
+    const progress = progressToken ? (params) => {
+      extra.sendNotification({
+        method: "notifications/progress",
+        params: {
+          progressToken,
+          progress: params.progress ?? ++progressCounter,
+          total: params.total,
+          message: params.message
+        }
+      }).catch(serverDebug);
+    } : () => {
+    };
     try {
       if (!initializePromise)
         initializePromise = initializeServer(server, backend, runHeartbeat);
       await initializePromise;
-      return await backend.callTool(request.params.name, request.params.arguments || {});
+      return mergeTextParts(await backend.callTool(request.params.name, request.params.arguments || {}, progress));
     } catch (error) {
       return {
         content: [{ type: "text", text: "### Result\n" + String(error) }],
@@ -145,6 +159,27 @@ function firstRootPath(clientInfo) {
   const url = firstRootUri ? new URL(firstRootUri) : void 0;
   return url ? (0, import_url.fileURLToPath)(url) : void 0;
 }
+function mergeTextParts(result) {
+  const content = [];
+  const testParts = [];
+  for (const part of result.content) {
+    if (part.type === "text") {
+      testParts.push(part.text);
+      continue;
+    }
+    if (testParts.length > 0) {
+      content.push({ type: "text", text: testParts.join("\n") });
+      testParts.length = 0;
+    }
+    content.push(part);
+  }
+  if (testParts.length > 0)
+    content.push({ type: "text", text: testParts.join("\n") });
+  return {
+    ...result,
+    content
+  };
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   connect,

package/lib/mcp/test/streams.js

@@ -23,17 +23,15 @@ __export(streams_exports, {
 module.exports = __toCommonJS(streams_exports);
 var import_stream = require("stream");
 class StringWriteStream extends import_stream.Writable {
-  constructor() {
-    super(...arguments);
-    this._chunks = [];
+  constructor(progress) {
+    super();
+    this._progress = progress;
   }
   _write(chunk, encoding, callback) {
-    this._chunks.push(chunk.toString());
+    const text = chunk.toString();
+    this._progress({ message: text.endsWith("\n") ? text.slice(0, -1) : text });
     callback();
   }
-  content() {
-    return this._chunks.join("");
-  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {

package/lib/mcp/test/testBackend.js

@@ -45,13 +45,13 @@ class TestServerBackend {
     this._configOption = configOption;
   }
   async initialize(server, clientInfo) {
+    const rootPath = mcp.firstRootPath(clientInfo);
     if (this._configOption) {
-      this._context.setConfigLocation((0, import_configLoader.resolveConfigLocation)(this._configOption));
+      this._context.initialize(rootPath, (0, import_configLoader.resolveConfigLocation)(this._configOption));
       return;
     }
-    const rootPath = mcp.firstRootPath(clientInfo);
     if (rootPath) {
-      this._context.setConfigLocation((0, import_configLoader.resolveConfigLocation)(rootPath));
+      this._context.initialize(rootPath, (0, import_configLoader.resolveConfigLocation)(rootPath));
       return;
     }
     throw new Error("No config option or MCP root path provided");
@@ -62,12 +62,12 @@ class TestServerBackend {
       ...import_tools.browserTools.map((tool) => mcp.toMcpTool(tool.schema))
     ];
   }
-  async callTool(name, args) {
+  async callTool(name, args, progress) {
     const tool = this._tools.find((tool2) => tool2.schema.name === name);
     if (!tool)
       throw new Error(`Tool not found: ${name}. Available tools: ${this._tools.map((tool2) => tool2.schema.name).join(", ")}`);
     const parsedArguments = tool.schema.inputSchema.parse(args || {});
-    return await tool.handle(this._context, parsedArguments);
+    return await tool.handle(this._context, parsedArguments, progress);
   }
   serverClosed() {
     void this._context.close();

package/lib/mcp/test/testContext.js

@@ -26,8 +26,9 @@ class TestContext {
   constructor(options) {
     this.options = options;
   }
-  setConfigLocation(configLocation) {
+  initialize(rootPath, configLocation) {
     this.configLocation = configLocation;
+    this.rootPath = rootPath || configLocation.configDir;
   }
   async createTestRunner() {
     if (this._testRunner)

package/lib/mcp/test/testTools.js

@@ -44,6 +44,7 @@ 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",
@@ -52,14 +53,12 @@ const listTests = (0, import_testTool.defineTestTool)({
     inputSchema: import_bundle.z.object({}),
     type: "readOnly"
   },
-  handle: async (context) => {
-    const { screen, stream } = createScreen();
+  handle: async (context, _, progress) => {
+    const { screen } = createScreen(progress);
     const reporter = new import_listModeReporter.default({ screen, includeTestId: true });
     const testRunner = await context.createTestRunner();
     await testRunner.listTests(reporter, {});
-    return {
-      content: [{ type: "text", text: stream.content() }]
-    };
+    return { content: [] };
   }
 });
 const runTests = (0, import_testTool.defineTestTool)({
@@ -73,22 +72,17 @@ const runTests = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params) => {
-    const { screen, stream } = createScreen();
+  handle: async (context, params, progress) => {
+    const { screen } = createScreen(progress);
     const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen, includeTestId: true });
+    const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
     const testRunner = await context.createTestRunner();
     await testRunner.runTests(reporter, {
       locations: params.locations,
       projects: params.projects,
       disableConfigReporters: true
     });
-    const text = stream.content();
-    return {
-      content: [
-        { type: "text", text }
-      ]
-    };
+    return { content: [] };
   }
 });
 const debugTest = (0, import_testTool.defineTestTool)({
@@ -104,12 +98,12 @@ const debugTest = (0, import_testTool.defineTestTool)({
     }),
     type: "readOnly"
   },
-  handle: async (context, params) => {
-    const { screen, stream } = createScreen();
+  handle: async (context, params, progress) => {
+    const { screen } = createScreen(progress);
     const configDir = context.configLocation.configDir;
-    const reporter = new import_list.default({ configDir, screen });
+    const reporter = new import_list.default({ configDir, screen, includeTestId: true, prefixStdio: "out" });
     const testRunner = await context.createTestRunner();
-    const result = await testRunner.runTests(reporter, {
+    await testRunner.runTests(reporter, {
       headed: !context.options?.headless,
       testIds: [params.test.id],
       // For automatic recovery
@@ -118,64 +112,80 @@ const debugTest = (0, import_testTool.defineTestTool)({
       pauseOnError: true,
       disableConfigReporters: true
     });
-    const text = stream.content();
-    return {
-      content: [
-        { type: "text", text }
-      ],
-      isError: result.status !== "passed"
-    };
+    return { content: [] };
   }
 });
 const setupPage = (0, import_testTool.defineTestTool)({
   schema: {
     name: "test_setup_page",
     title: "Setup page",
-    description: "Setup the page for test",
+    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.'),
-      testLocation: import_bundle.z.string().optional().describe('Location of the seed test to use for setup. For example: "test/seed/default.spec.ts:20".')
+      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) => {
-    const { screen, stream } = createScreen();
+  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();
-    let testLocation = params.testLocation;
-    if (!testLocation) {
-      testLocation = "default.seed.spec.ts";
-      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;
-      const seedFile = import_path.default.join(testDir, testLocation);
-      if (!import_fs.default.existsSync(seedFile)) {
-        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';
+    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('seed', async ({ page }) => {});
+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(process.cwd(), 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: [testLocation],
+      locations: [seedFile],
       projects: params.project ? [params.project] : void 0,
       timeout: 0,
       workers: 1,
       pauseAtEnd: true,
-      disableConfigReporters: true
+      disableConfigReporters: true,
+      failOnLoadErrors: true
     });
-    const text = stream.content();
-    return {
-      content: [{ type: "text", text }],
-      isError: result.status !== "passed"
-    };
+    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() {
-  const stream = new import_streams.StringWriteStream();
+function createScreen(progress) {
+  const stream = new import_streams.StringWriteStream(progress);
   const screen = {
     ...import_base.terminalScreen,
     isTTY: false,