playwright 1.55.0 → 1.56.0-alpha-2025-08-21

package/lib/mcp/{transport.js → sdk/http.js}

@@ -26,29 +26,57 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var transport_exports = {};
-__export(transport_exports, {
-  start: () => start
+var http_exports = {};
+__export(http_exports, {
+  httpAddressToString: () => httpAddressToString,
+  installHttpTransport: () => installHttpTransport,
+  startHttpServer: () => startHttpServer
 });
-module.exports = __toCommonJS(transport_exports);
+module.exports = __toCommonJS(http_exports);
 var import_assert = __toESM(require("assert"));
 var import_http = __toESM(require("http"));
 var import_crypto = __toESM(require("crypto"));
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var mcpBundle = __toESM(require("./bundle"));
-var mcpServer = __toESM(require("./server"));
-async function start(serverBackendFactory, options) {
-  if (options.port !== void 0) {
-    const httpServer = await startHttpServer(options);
-    startHttpTransport(httpServer, serverBackendFactory);
-  } else {
-    await startStdioTransport(serverBackendFactory);
-  }
+var mcp = __toESM(require("./bundle"));
+var import_server = require("./server");
+const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
+async function startHttpServer(config, abortSignal) {
+  const { host, port } = config;
+  const httpServer = import_http.default.createServer();
+  await new Promise((resolve, reject) => {
+    httpServer.on("error", reject);
+    abortSignal?.addEventListener("abort", () => {
+      httpServer.close();
+      reject(new Error("Aborted"));
+    });
+    httpServer.listen(port, host, () => {
+      resolve();
+      httpServer.removeListener("error", reject);
+    });
+  });
+  return httpServer;
+}
+function httpAddressToString(address) {
+  (0, import_assert.default)(address, "Could not bind server socket");
+  if (typeof address === "string")
+    return address;
+  const resolvedPort = address.port;
+  let resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
+  if (resolvedHost === "0.0.0.0" || resolvedHost === "[::]")
+    resolvedHost = "localhost";
+  return `http://${resolvedHost}:${resolvedPort}`;
 }
-async function startStdioTransport(serverBackendFactory) {
-  await mcpServer.connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
+async function installHttpTransport(httpServer, serverBackendFactory) {
+  const sseSessions = /* @__PURE__ */ new Map();
+  const streamableSessions = /* @__PURE__ */ new Map();
+  httpServer.on("request", async (req, res) => {
+    const url = new URL(`http://localhost${req.url}`);
+    if (url.pathname.startsWith("/sse"))
+      await handleSSE(serverBackendFactory, req, res, url, sseSessions);
+    else
+      await handleStreamable(serverBackendFactory, req, res, streamableSessions);
+  });
 }
-const testDebug = (0, import_utilsBundle.debug)("pw:mcp:test");
 async function handleSSE(serverBackendFactory, req, res, url, sessions) {
   if (req.method === "POST") {
     const sessionId = url.searchParams.get("sessionId");
@@ -63,10 +91,10 @@ async function handleSSE(serverBackendFactory, req, res, url, sessions) {
     }
     return await transport.handlePostMessage(req, res);
   } else if (req.method === "GET") {
-    const transport = new mcpBundle.SSEServerTransport("/sse", res);
+    const transport = new mcp.SSEServerTransport("/sse", res);
     sessions.set(transport.sessionId, transport);
     testDebug(`create SSE session: ${transport.sessionId}`);
-    await mcpServer.connect(serverBackendFactory, transport, false);
+    await (0, import_server.connect)(serverBackendFactory, transport, false);
     res.on("close", () => {
       testDebug(`delete SSE session: ${transport.sessionId}`);
       sessions.delete(transport.sessionId);
@@ -88,11 +116,11 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
     return await transport.handleRequest(req, res);
   }
   if (req.method === "POST") {
-    const transport = new mcpBundle.StreamableHTTPServerTransport({
+    const transport = new mcp.StreamableHTTPServerTransport({
       sessionIdGenerator: () => import_crypto.default.randomUUID(),
       onsessioninitialized: async (sessionId2) => {
         testDebug(`create http session: ${transport.sessionId}`);
-        await mcpServer.connect(serverBackendFactory, transport, true);
+        await (0, import_server.connect)(serverBackendFactory, transport, true);
         sessions.set(sessionId2, transport);
       }
     });
@@ -108,54 +136,9 @@ async function handleStreamable(serverBackendFactory, req, res, sessions) {
   res.statusCode = 400;
   res.end("Invalid request");
 }
-function startHttpTransport(httpServer, serverBackendFactory) {
-  const sseSessions = /* @__PURE__ */ new Map();
-  const streamableSessions = /* @__PURE__ */ new Map();
-  httpServer.on("request", async (req, res) => {
-    const url2 = new URL(`http://localhost${req.url}`);
-    if (url2.pathname.startsWith("/sse"))
-      await handleSSE(serverBackendFactory, req, res, url2, sseSessions);
-    else
-      await handleStreamable(serverBackendFactory, req, res, streamableSessions);
-  });
-  const url = httpAddressToString(httpServer.address());
-  const message = [
-    `Listening on ${url}`,
-    "Put this in your client config:",
-    JSON.stringify({
-      "mcpServers": {
-        "playwright": {
-          "url": `${url}/mcp`
-        }
-      }
-    }, void 0, 2),
-    "For legacy SSE transport support, you can use the /sse endpoint instead."
-  ].join("\n");
-  console.error(message);
-}
-async function startHttpServer(config) {
-  const { host, port } = config;
-  const httpServer = import_http.default.createServer();
-  await new Promise((resolve, reject) => {
-    httpServer.on("error", reject);
-    httpServer.listen(port, host, () => {
-      resolve();
-      httpServer.removeListener("error", reject);
-    });
-  });
-  return httpServer;
-}
-function httpAddressToString(address) {
-  (0, import_assert.default)(address, "Could not bind server socket");
-  if (typeof address === "string")
-    return address;
-  const resolvedPort = address.port;
-  let resolvedHost = address.family === "IPv4" ? address.address : `[${address.address}]`;
-  if (resolvedHost === "0.0.0.0" || resolvedHost === "[::]")
-    resolvedHost = "localhost";
-  return `http://${resolvedHost}:${resolvedPort}`;
-}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  start
+  httpAddressToString,
+  installHttpTransport,
+  startHttpServer
 });

package/lib/mcp/sdk/mdb.js

@@ -0,0 +1,195 @@
+"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 mdb_exports = {};
+__export(mdb_exports, {
+  MDBBackend: () => MDBBackend,
+  runOnPauseBackendLoop: () => runOnPauseBackendLoop,
+  runToolsBackend: () => runToolsBackend
+});
+module.exports = __toCommonJS(mdb_exports);
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_bundle = require("./bundle.js");
+var import_bundle2 = require("./bundle.js");
+var mcpBundle = __toESM(require("./bundle.js"));
+var import_tool = require("./tool.js");
+var mcpHttp = __toESM(require("./http.js"));
+var import_call = require("./call.js");
+const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
+class MDBBackend {
+  constructor() {
+    this._stack = [];
+  }
+  async initialize(server) {
+    this._server = server;
+  }
+  async listTools() {
+    const response = await this._client().listTools();
+    return response.tools;
+  }
+  async callTool(name, args) {
+    if (name === pushToolsSchema.name)
+      return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
+    this._interruptPromise = new import_utils.ManualPromise();
+    let [entry] = this._stack;
+    while (entry && !entry.toolNames.includes(name)) {
+      this._stack.shift();
+      await entry.client.close();
+      entry = this._stack[0];
+    }
+    const resultPromise = new import_utils.ManualPromise();
+    entry.resultPromise = resultPromise;
+    this._client().callTool({
+      name,
+      arguments: args
+    }).then((result) => {
+      resultPromise.resolve(result);
+    }).catch((e) => {
+      if (this._stack.length < 2)
+        throw e;
+      this._stack.shift();
+      const prevEntry = this._stack[0];
+      void prevEntry.resultPromise.then((result) => resultPromise.resolve(result));
+    });
+    return await Promise.race([this._interruptPromise, resultPromise]);
+  }
+  _client() {
+    const [entry] = this._stack;
+    if (!entry)
+      throw new Error("No debugging backend available");
+    return entry.client;
+  }
+  async _pushTools(params) {
+    const client = new mcpBundle.Client({ name: "Internal client", version: "0.0.0" });
+    client.setRequestHandler(import_bundle.PingRequestSchema, () => ({}));
+    const transport = new import_bundle2.StreamableHTTPClientTransport(new URL(params.mcpUrl));
+    await client.connect(transport);
+    this._interruptPromise?.resolve({
+      content: [{
+        type: "text",
+        text: params.introMessage || ""
+      }]
+    });
+    this._interruptPromise = void 0;
+    const { tools } = await client.listTools();
+    this._stack.unshift({ client, toolNames: tools.map((tool) => tool.name), resultPromise: void 0 });
+    await this._server.notification({
+      method: "notifications/tools/list_changed"
+    });
+    return { content: [{ type: "text", text: "Tools pushed" }] };
+  }
+}
+const pushToolsSchema = (0, import_tool.defineToolSchema)({
+  name: "mdb_push_tools",
+  title: "Push MCP tools to the tools stack",
+  description: "Push MCP tools to the tools stack",
+  inputSchema: import_bundle.z.object({
+    mcpUrl: import_bundle.z.string(),
+    introMessage: import_bundle.z.string().optional()
+  }),
+  type: "readOnly"
+});
+async function runToolsBackend(backendFactory, options) {
+  const mdbBackend = new MDBBackend();
+  const mdbBackendFactory = {
+    name: "Playwright MDB",
+    nameInConfig: "playwright-mdb",
+    version: "0.0.0",
+    create: () => mdbBackend
+  };
+  const mdbUrl = await startAsHttp(mdbBackendFactory, options);
+  const backendUrl = await startAsHttp(backendFactory, { port: 0 });
+  const result = await (0, import_call.callTool)(mdbUrl, pushToolsSchema.name, { mcpUrl: backendUrl });
+  if (result.isError)
+    errorsDebug("Failed to push tools", result.content);
+  return mdbUrl;
+}
+async function runOnPauseBackendLoop(mdbUrl, backend, introMessage) {
+  const wrappedBackend = new OnceTimeServerBackendWrapper(backend);
+  const factory = {
+    name: "on-pause-backend",
+    nameInConfig: "on-pause-backend",
+    version: "0.0.0",
+    create: () => wrappedBackend
+  };
+  const httpServer = await mcpHttp.startHttpServer({ port: 0 });
+  await mcpHttp.installHttpTransport(httpServer, factory);
+  const url = mcpHttp.httpAddressToString(httpServer.address());
+  const client = new mcpBundle.Client({ name: "Internal client", version: "0.0.0" });
+  client.setRequestHandler(import_bundle.PingRequestSchema, () => ({}));
+  const transport = new import_bundle2.StreamableHTTPClientTransport(new URL(mdbUrl));
+  await client.connect(transport);
+  const pushToolsResult = await client.callTool({
+    name: pushToolsSchema.name,
+    arguments: {
+      mcpUrl: url,
+      introMessage
+    }
+  });
+  if (pushToolsResult.isError)
+    errorsDebug("Failed to push tools", pushToolsResult.content);
+  await transport.terminateSession();
+  await client.close();
+  await wrappedBackend.waitForClosed();
+  httpServer.close();
+}
+async function startAsHttp(backendFactory, options) {
+  const httpServer = await mcpHttp.startHttpServer(options);
+  await mcpHttp.installHttpTransport(httpServer, backendFactory);
+  return mcpHttp.httpAddressToString(httpServer.address());
+}
+class OnceTimeServerBackendWrapper {
+  constructor(backend) {
+    this._selfDestructPromise = new import_utils.ManualPromise();
+    this._backend = backend;
+    this._backend.requestSelfDestruct = () => this._selfDestructPromise.resolve();
+  }
+  async initialize(server, clientVersion, roots) {
+    await this._backend.initialize?.(server, clientVersion, roots);
+  }
+  async listTools() {
+    return this._backend.listTools();
+  }
+  async callTool(name, args) {
+    return this._backend.callTool(name, args);
+  }
+  serverClosed() {
+    this._backend.serverClosed?.();
+    this._selfDestructPromise.resolve();
+  }
+  async waitForClosed() {
+    await this._selfDestructPromise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MDBBackend,
+  runOnPauseBackendLoop,
+  runToolsBackend
+});

package/lib/mcp/{proxyBackend.js → sdk/proxyBackend.js}

@@ -32,17 +32,15 @@ __export(proxyBackend_exports, {
 });
 module.exports = __toCommonJS(proxyBackend_exports);
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var mcpBundle = __toESM(require("./bundle"));
+var mcp = __toESM(require("./bundle"));
 const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
 class ProxyBackend {
-  constructor(name, version, mcpProviders) {
+  constructor(mcpProviders) {
     this._roots = [];
-    this.name = name;
-    this.version = version;
     this._mcpProviders = mcpProviders;
     this._contextSwitchTool = this._defineContextSwitchTool();
   }
-  async initialize(clientVersion, roots) {
+  async initialize(server, clientVersion, roots) {
     this._roots = roots;
     await this._setCurrentClient(this._mcpProviders[0]);
   }
@@ -91,8 +89,8 @@ Error: ${error}
         "Connect to a browser using one of the available methods:",
         ...this._mcpProviders.map((factory) => `- "${factory.name}": ${factory.description}`)
       ].join("\n"),
-      inputSchema: mcpBundle.zodToJsonSchema(mcpBundle.z.object({
-        name: mcpBundle.z.enum(this._mcpProviders.map((factory) => factory.name)).default(this._mcpProviders[0].name).describe("The method to use to connect to the browser")
+      inputSchema: mcp.zodToJsonSchema(mcp.z.object({
+        name: mcp.z.enum(this._mcpProviders.map((factory) => factory.name)).default(this._mcpProviders[0].name).describe("The method to use to connect to the browser")
       }), { strictUnions: true }),
       annotations: {
         title: "Connect to a browser context",
@@ -104,14 +102,14 @@ Error: ${error}
   async _setCurrentClient(factory) {
     await this._currentClient?.close();
     this._currentClient = void 0;
-    const client = new mcpBundle.Client({ name: this.name, version: this.version });
+    const client = new mcp.Client({ name: "Playwright MCP Proxy", version: "0.0.0" });
     client.registerCapabilities({
       roots: {
         listRoots: true
       }
     });
-    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._roots }));
-    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    client.setRequestHandler(mcp.ListRootsRequestSchema, () => ({ roots: this._roots }));
+    client.setRequestHandler(mcp.PingRequestSchema, () => ({}));
     const transport = await factory.connect();
     await client.connect(transport);
     this._currentClient = client;

package/lib/mcp/{server.js → sdk/server.js}

@@ -29,35 +29,42 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var server_exports = {};
 __export(server_exports, {
   connect: () => connect,
-  createServer: () => createServer
+  createServer: () => createServer,
+  start: () => start,
+  wrapInProcess: () => wrapInProcess
 });
 module.exports = __toCommonJS(server_exports);
 var import_utilsBundle = require("playwright-core/lib/utilsBundle");
-var mcpBundle = __toESM(require("./bundle"));
+var mcp = __toESM(require("./bundle"));
+var import_inProcessTransport = require("./inProcessTransport");
+var import_http = require("./http");
 const serverDebug = (0, import_utilsBundle.debug)("pw:mcp:server");
 const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
-async function connect(serverBackendFactory, transport, runHeartbeat) {
-  const backend = serverBackendFactory();
-  const server = createServer(backend, runHeartbeat);
+async function connect(factory, transport, runHeartbeat) {
+  const server = createServer(factory.name, factory.version, factory.create(), runHeartbeat);
   await server.connect(transport);
 }
-function createServer(backend, runHeartbeat) {
-  let initializedCallback = () => {
+async function wrapInProcess(backend) {
+  const server = createServer("Internal", "0.0.0", backend, false);
+  return new import_inProcessTransport.InProcessTransport(server);
+}
+function createServer(name, version, backend, runHeartbeat) {
+  let initializedPromiseResolve = () => {
   };
-  const initializedPromise = new Promise((resolve) => initializedCallback = resolve);
-  const server = new mcpBundle.Server({ name: backend.name, version: backend.version }, {
+  const initializedPromise = new Promise((resolve) => initializedPromiseResolve = resolve);
+  const server = new mcp.Server({ name, version }, {
     capabilities: {
       tools: {}
     }
   });
-  server.setRequestHandler(mcpBundle.ListToolsRequestSchema, async () => {
+  server.setRequestHandler(mcp.ListToolsRequestSchema, async () => {
     serverDebug("listTools");
     await initializedPromise;
     const tools = await backend.listTools();
     return { tools };
   });
   let heartbeatRunning = false;
-  server.setRequestHandler(mcpBundle.CallToolRequestSchema, async (request) => {
+  server.setRequestHandler(mcp.CallToolRequestSchema, async (request) => {
     serverDebug("callTool", request);
     await initializedPromise;
     if (runHeartbeat && !heartbeatRunning) {
@@ -82,8 +89,8 @@ function createServer(backend, runHeartbeat) {
         clientRoots = roots;
       }
       const clientVersion = server.getClientVersion() ?? { name: "unknown", version: "unknown" };
-      await backend.initialize?.(clientVersion, clientRoots);
-      initializedCallback();
+      await backend.initialize?.(server, clientVersion, clientRoots);
+      initializedPromiseResolve();
     } catch (e) {
       errorsDebug(e);
     }
@@ -111,8 +118,30 @@ function addServerListener(server, event, listener) {
     listener();
   };
 }
+async function start(serverBackendFactory, options) {
+  if (options.port === void 0) {
+    await connect(serverBackendFactory, new mcp.StdioServerTransport(), false);
+    return;
+  }
+  const httpServer = await (0, import_http.startHttpServer)(options);
+  await (0, import_http.installHttpTransport)(httpServer, serverBackendFactory);
+  const url = (0, import_http.httpAddressToString)(httpServer.address());
+  const mcpConfig = { mcpServers: {} };
+  mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {
+    url: `${url}/mcp`
+  };
+  const message = [
+    `Listening on ${url}`,
+    "Put this in your client config:",
+    JSON.stringify(mcpConfig, void 0, 2),
+    "For legacy SSE transport support, you can use the /sse endpoint instead."
+  ].join("\n");
+  console.error(message);
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   connect,
-  createServer
+  createServer,
+  start,
+  wrapInProcess
 });

package/lib/mcp/{tool.js → sdk/tool.js}

@@ -18,10 +18,11 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var tool_exports = {};
 __export(tool_exports, {
+  defineToolSchema: () => defineToolSchema,
   toMcpTool: () => toMcpTool
 });
 module.exports = __toCommonJS(tool_exports);
-var import_bundle = require("./bundle");
+var import_bundle = require("./bundle.js");
 function toMcpTool(tool) {
   return {
     name: tool.name,
@@ -35,7 +36,11 @@ function toMcpTool(tool) {
     }
   };
 }
+function defineToolSchema(tool) {
+  return tool;
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  defineToolSchema,
   toMcpTool
 });

package/lib/mcp/test/backend.js

@@ -0,0 +1,68 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var backend_exports = {};
+__export(backend_exports, {
+  TestServerBackend: () => TestServerBackend
+});
+module.exports = __toCommonJS(backend_exports);
+var mcp = __toESM(require("../sdk/exports.js"));
+var import_context = require("./context");
+var import_listTests = require("./listTests");
+var import_runTests = require("./runTests");
+var import_tools = require("../browser/tools");
+class TestServerBackend {
+  constructor(resolvedLocation) {
+    this.name = "Playwright";
+    this.version = "0.0.1";
+    this._tools = [import_listTests.listTests, import_runTests.runTests];
+    this._context = new import_context.Context(resolvedLocation);
+  }
+  async listTools() {
+    return [
+      ...this._tools.map((tool) => mcp.toMcpTool(tool.schema)),
+      mcp.toMcpTool(import_tools.snapshot.schema),
+      mcp.toMcpTool(import_tools.pickLocator.schema),
+      mcp.toMcpTool(import_tools.evaluate.schema)
+    ];
+  }
+  async callTool(name, args) {
+    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);
+  }
+  serverClosed() {
+    void this._context.close();
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  TestServerBackend
+});

package/lib/mcp/test/context.js

@@ -0,0 +1,43 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var context_exports = {};
+__export(context_exports, {
+  Context: () => Context
+});
+module.exports = __toCommonJS(context_exports);
+var import_testRunner = require("../../runner/testRunner");
+class Context {
+  constructor(configLocation) {
+    this.configLocation = configLocation;
+  }
+  async createTestRunner() {
+    if (this._testRunner)
+      await this._testRunner.stopTests();
+    const testRunner = new import_testRunner.TestRunner(this.configLocation, {});
+    await testRunner.initialize({});
+    this._testRunner = testRunner;
+    return testRunner;
+  }
+  async close() {
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Context
+});