@stablyai/internal-playwright 0.1.0

package/lib/mcp/sdk/mdb.js

@@ -0,0 +1,206 @@
+"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,
+  runMainBackend: () => runMainBackend,
+  runOnPauseBackendLoop: () => runOnPauseBackendLoop
+});
+module.exports = __toCommonJS(mdb_exports);
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var import_utils = require("playwright-core/lib/utils");
+var import_tool = require("./tool");
+var mcpBundle = __toESM(require("./bundle"));
+var mcpServer = __toESM(require("./server"));
+var mcpHttp = __toESM(require("./http"));
+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(mainBackend) {
+    this._progress = [];
+    this._mainBackend = mainBackend;
+    this._progressCallback = (params) => {
+      if (params.message)
+        this._progress.push({ type: "text", text: params.message });
+    };
+  }
+  async initialize(server, clientInfo) {
+    if (!this._clientInfo) {
+      this._clientInfo = clientInfo;
+      await this._mainBackend.initialize?.(server, clientInfo);
+    }
+  }
+  async listTools() {
+    return await this._mainBackend.listTools();
+  }
+  async callTool(name, args) {
+    if (name === pushToolsSchema.name) {
+      await this._createOnPauseClient(pushToolsSchema.inputSchema.parse(args || {}));
+      return { content: [{ type: "text", text: "Tools pushed" }] };
+    }
+    if (this._onPauseClient?.tools.find((tool) => tool.name === name)) {
+      const result2 = await this._onPauseClient.client.callTool({
+        name,
+        arguments: args
+      });
+      await this._mainBackend.afterCallTool?.(name, args, result2);
+      return result2;
+    }
+    await this._onPauseClient?.transport.terminateSession().catch(errorsDebug);
+    await this._onPauseClient?.client.close().catch(errorsDebug);
+    this._onPauseClient = void 0;
+    const resultPromise = new import_utils.ManualPromise();
+    const interruptPromise = new import_utils.ManualPromise();
+    this._interruptPromise = interruptPromise;
+    this._mainBackend.callTool(name, args, this._progressCallback).then((result2) => {
+      resultPromise.resolve(result2);
+    }).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 _createOnPauseClient(params) {
+    if (this._onPauseClient)
+      await this._onPauseClient.client.close().catch(errorsDebug);
+    this._onPauseClient = await this._createClient(params.mcpUrl);
+    this._interruptPromise?.resolve({
+      content: [{
+        type: "text",
+        text: params.introMessage || ""
+      }]
+    });
+    this._interruptPromise = void 0;
+  }
+  async _createClient(url) {
+    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) => {
+      if (notification.method === "notifications/progress") {
+        const { message } = notification.params;
+        if (message)
+          this._progress.push({ type: "text", text: message });
+      }
+    });
+    const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(url));
+    await client.connect(transport);
+    const { tools } = await client.listTools();
+    return { client, tools, transport };
+  }
+}
+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: z.object({
+    mcpUrl: z.string(),
+    introMessage: z.string().optional()
+  }),
+  type: "readOnly"
+});
+async function runMainBackend(backendFactory, options) {
+  const mdbBackend = new MDBBackend(backendFactory.create());
+  const factory = {
+    ...backendFactory,
+    create: () => mdbBackend
+  };
+  const url = await startAsHttp(factory, { port: options?.port || 0 });
+  process.env.PLAYWRIGHT_DEBUGGER_MCP = url;
+  if (options?.port !== void 0)
+    return url;
+  await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);
+}
+async function runOnPauseBackendLoop(backend, introMessage) {
+  const wrappedBackend = new ServerBackendWithCloseListener(backend);
+  const factory = {
+    name: "on-pause-backend",
+    nameInConfig: "on-pause-backend",
+    version: "0.0.0",
+    create: () => wrappedBackend
+  };
+  const httpServer = await mcpHttp.startHttpServer({ port: 0 });
+  const url = await mcpHttp.installHttpTransport(httpServer, factory, true);
+  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);
+  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);
+  return await mcpHttp.installHttpTransport(httpServer, backendFactory, true);
+}
+class ServerBackendWithCloseListener {
+  constructor(backend) {
+    this._serverClosedPromise = new import_utils.ManualPromise();
+    this._backend = backend;
+  }
+  async initialize(server, clientInfo) {
+    await this._backend.initialize?.(server, clientInfo);
+  }
+  async listTools() {
+    return this._backend.listTools();
+  }
+  async callTool(name, args, progress) {
+    return this._backend.callTool(name, args, progress);
+  }
+  serverClosed(server) {
+    this._backend.serverClosed?.(server);
+    this._serverClosedPromise.resolve();
+  }
+  async waitForClosed() {
+    await this._serverClosedPromise;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MDBBackend,
+  runMainBackend,
+  runOnPauseBackendLoop
+});

package/lib/mcp/sdk/mdb.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/mdb.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\nimport { ManualPromise } from 'playwright-core/lib/utils';\n\nimport { PingRequestSchema, z } from './bundle.js';\nimport { StreamableHTTPClientTransport } from './bundle.js';\nimport * as mcpBundle from './bundle.js';\n\nimport { defineToolSchema } from './tool.js';\nimport * as mcpServer from './server.js';\nimport * as mcpHttp from './http.js';\nimport { wrapInProcess } from './server.js';\n\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\n\nconst mdbDebug = debug('pw:mcp:mdb');\nconst errorsDebug = debug('pw:mcp:errors');\n\nexport class MDBBackend implements mcpServer.ServerBackend {\n  private _stack: { client: Client, toolNames: string[], resultPromise: ManualPromise<mcpServer.CallToolResult> | undefined }[] = [];\n  private _interruptPromise: ManualPromise<mcpServer.CallToolResult> | undefined;\n  private _topLevelBackend: mcpServer.ServerBackend;\n  private _initialized = false;\n\n  constructor(topLevelBackend: mcpServer.ServerBackend) {\n    this._topLevelBackend = topLevelBackend;\n  }\n\n  async initialize(server: mcpServer.Server): Promise<void> {\n    if (this._initialized)\n      return;\n    this._initialized = true;\n    const transport = await wrapInProcess(this._topLevelBackend);\n    await this._pushClient(transport);\n  }\n\n  async listTools(): Promise<mcpServer.Tool[]> {\n    const response = await this._client().listTools();\n    return response.tools;\n  }\n\n  async callTool(name: string, args: mcpServer.CallToolRequest['params']['arguments']): Promise<mcpServer.CallToolResult> {\n    if (name === pushToolsSchema.name)\n      return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));\n\n    const interruptPromise = new ManualPromise<mcpServer.CallToolResult>();\n    this._interruptPromise = interruptPromise;\n    let [entry] = this._stack;\n\n    // Pop the client while the tool is not found.\n    while (entry && !entry.toolNames.includes(name)) {\n      mdbDebug('popping client from stack for ', name);\n      this._stack.shift();\n      await entry.client.close();\n      entry = this._stack[0];\n    }\n\n    const resultPromise = new ManualPromise<mcpServer.CallToolResult>();\n    entry.resultPromise = resultPromise;\n\n    this._client().callTool({\n      name,\n      arguments: args,\n    }).then(result => {\n      resultPromise.resolve(result as mcpServer.CallToolResult);\n    }).catch(e => {\n      mdbDebug('error in client call', e);\n      if (this._stack.length < 2)\n        throw e;\n      this._stack.shift();\n      const prevEntry = this._stack[0];\n      void prevEntry.resultPromise!.then(result => resultPromise.resolve(result));\n    });\n    const result = await Promise.race([interruptPromise, resultPromise]);\n    if (interruptPromise.isDone())\n      mdbDebug('client call intercepted', result);\n    else\n      mdbDebug('client call result', result);\n    return result;\n  }\n\n  private _client(): Client {\n    const [entry] = this._stack;\n    if (!entry)\n      throw new Error('No debugging backend available');\n    return entry.client;\n  }\n\n  private async _pushTools(params: { mcpUrl: string, introMessage?: string }): Promise<mcpServer.CallToolResult> {\n    mdbDebug('pushing tools to the stack', params.mcpUrl);\n    const transport = new StreamableHTTPClientTransport(new URL(params.mcpUrl));\n    await this._pushClient(transport, params.introMessage);\n    return { content: [{ type: 'text', text: 'Tools pushed' }] };\n  }\n\n  private async _pushClient(transport: Transport, introMessage?: string): Promise<mcpServer.CallToolResult> {\n    mdbDebug('pushing client to the stack');\n    const client = new mcpBundle.Client({ name: 'Internal client', version: '0.0.0' });\n    client.setRequestHandler(PingRequestSchema, () => ({}));\n    await client.connect(transport);\n    mdbDebug('connected to the new client');\n    const { tools } = await client.listTools();\n    this._stack.unshift({ client, toolNames: tools.map(tool => tool.name), resultPromise: undefined });\n    mdbDebug('new tools added to the stack:', tools.map(tool => tool.name));\n    mdbDebug('interrupting current call:', !!this._interruptPromise);\n    this._interruptPromise?.resolve({\n      content: [{\n        type: 'text',\n        text: introMessage || '',\n      }],\n    });\n    this._interruptPromise = undefined;\n    return { content: [{ type: 'text', text: 'Tools pushed' }] };\n  }\n}\n\nconst pushToolsSchema = defineToolSchema({\n  name: 'mdb_push_tools',\n  title: 'Push MCP tools to the tools stack',\n  description: 'Push MCP tools to the tools stack',\n  inputSchema: z.object({\n    mcpUrl: z.string(),\n    introMessage: z.string().optional(),\n  }),\n  type: 'readOnly',\n});\n\nexport type ServerBackendOnPause = mcpServer.ServerBackend & {\n  requestSelfDestruct?: () => void;\n};\n\nexport async function runMainBackend(backendFactory: mcpServer.ServerBackendFactory, options?: { port?: number }): Promise<string | undefined> {\n  const mdbBackend = new MDBBackend(backendFactory.create());\n  // Start HTTP unconditionally.\n  const factory: mcpServer.ServerBackendFactory = {\n    ...backendFactory,\n    create: () => mdbBackend\n  };\n  const url = await startAsHttp(factory, { port: options?.port || 0 });\n  process.env.PLAYWRIGHT_MDB_URL = url;\n\n  if (options?.port !== undefined)\n    return url;\n\n  // Start stdio conditionally.\n  await mcpServer.connect(factory, new mcpBundle.StdioServerTransport(), false);\n}\n\nexport async function runOnPauseBackendLoop(mdbUrl: string, backend: ServerBackendOnPause, introMessage: string) {\n  const wrappedBackend = new OnceTimeServerBackendWrapper(backend);\n\n  const factory = {\n    name: 'on-pause-backend',\n    nameInConfig: 'on-pause-backend',\n    version: '0.0.0',\n    create: () => wrappedBackend,\n  };\n\n  const httpServer = await mcpHttp.startHttpServer({ port: 0 });\n  await mcpHttp.installHttpTransport(httpServer, factory);\n  const url = mcpHttp.httpAddressToString(httpServer.address());\n\n  const client = new mcpBundle.Client({ name: 'Internal client', version: '0.0.0' });\n  client.setRequestHandler(PingRequestSchema, () => ({}));\n  const transport = new StreamableHTTPClientTransport(new URL(mdbUrl));\n  await client.connect(transport);\n\n  const pushToolsResult = await client.callTool({\n    name: pushToolsSchema.name,\n    arguments: {\n      mcpUrl: url,\n      introMessage,\n    },\n  });\n  if (pushToolsResult.isError)\n    errorsDebug('Failed to push tools', pushToolsResult.content);\n  await transport.terminateSession();\n  await client.close();\n\n  await wrappedBackend.waitForClosed();\n  httpServer.close();\n}\n\nasync function startAsHttp(backendFactory: mcpServer.ServerBackendFactory, options: { port: number }) {\n  const httpServer = await mcpHttp.startHttpServer(options);\n  await mcpHttp.installHttpTransport(httpServer, backendFactory);\n  return mcpHttp.httpAddressToString(httpServer.address());\n}\n\n\nclass OnceTimeServerBackendWrapper implements mcpServer.ServerBackend {\n  private _backend: ServerBackendOnPause;\n  private _selfDestructPromise = new ManualPromise<void>();\n\n  constructor(backend: ServerBackendOnPause) {\n    this._backend = backend;\n    this._backend.requestSelfDestruct = () => this._selfDestructPromise.resolve();\n  }\n\n  async initialize(server: mcpServer.Server, clientVersion: mcpServer.ClientVersion, roots: mcpServer.Root[]): Promise<void> {\n    await this._backend.initialize?.(server, clientVersion, roots);\n  }\n\n  async listTools(): Promise<mcpServer.Tool[]> {\n    return this._backend.listTools();\n  }\n\n  async callTool(name: string, args: mcpServer.CallToolRequest['params']['arguments']): Promise<mcpServer.CallToolResult> {\n    return this._backend.callTool(name, args);\n  }\n\n  serverClosed(server: mcpServer.Server) {\n    this._backend.serverClosed?.(server);\n    this._selfDestructPromise.resolve();\n  }\n\n  async waitForClosed() {\n    await this._selfDestructPromise;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["import_bundle", "result"]
+}

package/lib/mcp/sdk/proxyBackend.js

@@ -0,0 +1,128 @@
+"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 proxyBackend_exports = {};
+__export(proxyBackend_exports, {
+  ProxyBackend: () => ProxyBackend
+});
+module.exports = __toCommonJS(proxyBackend_exports);
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var mcpBundle = __toESM(require("./bundle"));
+const errorsDebug = (0, import_utilsBundle.debug)("pw:mcp:errors");
+const { z, zodToJsonSchema } = mcpBundle;
+class ProxyBackend {
+  constructor(mcpProviders) {
+    this._mcpProviders = mcpProviders;
+    this._contextSwitchTool = this._defineContextSwitchTool();
+  }
+  async initialize(server, clientInfo) {
+    this._clientInfo = clientInfo;
+  }
+  async listTools() {
+    const currentClient = await this._ensureCurrentClient();
+    const response = await currentClient.listTools();
+    if (this._mcpProviders.length === 1)
+      return response.tools;
+    return [
+      ...response.tools,
+      this._contextSwitchTool
+    ];
+  }
+  async callTool(name, args) {
+    if (name === this._contextSwitchTool.name)
+      return this._callContextSwitchTool(args);
+    const currentClient = await this._ensureCurrentClient();
+    return await currentClient.callTool({
+      name,
+      arguments: args
+    });
+  }
+  serverClosed() {
+    void this._currentClient?.close().catch(errorsDebug);
+  }
+  async _callContextSwitchTool(params) {
+    try {
+      const factory = this._mcpProviders.find((factory2) => factory2.name === params.name);
+      if (!factory)
+        throw new Error("Unknown connection method: " + params.name);
+      await this._setCurrentClient(factory);
+      return {
+        content: [{ type: "text", text: "### Result\nSuccessfully changed connection method.\n" }]
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: `### Result
+Error: ${error}
+` }],
+        isError: true
+      };
+    }
+  }
+  _defineContextSwitchTool() {
+    return {
+      name: "browser_connect",
+      description: [
+        "Connect to a browser using one of the available methods:",
+        ...this._mcpProviders.map((factory) => `- "${factory.name}": ${factory.description}`)
+      ].join("\n"),
+      inputSchema: zodToJsonSchema(z.object({
+        name: 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",
+        readOnlyHint: true,
+        openWorldHint: false
+      }
+    };
+  }
+  async _ensureCurrentClient() {
+    if (this._currentClient)
+      return this._currentClient;
+    return await this._setCurrentClient(this._mcpProviders[0]);
+  }
+  async _setCurrentClient(factory) {
+    await this._currentClient?.close();
+    this._currentClient = void 0;
+    const client = new mcpBundle.Client({ name: "Playwright MCP Proxy", version: "0.0.0" });
+    client.registerCapabilities({
+      roots: {
+        listRoots: true
+      }
+    });
+    client.setRequestHandler(mcpBundle.ListRootsRequestSchema, () => ({ roots: this._clientInfo?.roots || [] }));
+    client.setRequestHandler(mcpBundle.PingRequestSchema, () => ({}));
+    const transport = await factory.connect();
+    await client.connect(transport);
+    this._currentClient = client;
+    return client;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ProxyBackend
+});

package/lib/mcp/sdk/proxyBackend.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/proxyBackend.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\nimport * as mcp from './bundle';\n\nimport type { ServerBackend, ClientVersion, Root, Server } from './server.js';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { Tool, CallToolResult, CallToolRequest } from '@modelcontextprotocol/sdk/types.js';\nimport type { Client } from '@modelcontextprotocol/sdk/client/index.js';\n\nexport type MCPProvider = {\n  name: string;\n  description: string;\n  connect(): Promise<Transport>;\n};\n\nconst errorsDebug = debug('pw:mcp:errors');\n\nexport class ProxyBackend implements ServerBackend {\n  private _mcpProviders: MCPProvider[];\n  private _currentClient: Client | undefined;\n  private _contextSwitchTool: Tool;\n  private _roots: Root[] = [];\n\n  constructor(mcpProviders: MCPProvider[]) {\n    this._mcpProviders = mcpProviders;\n    this._contextSwitchTool = this._defineContextSwitchTool();\n  }\n\n  async initialize(server: Server, clientVersion: ClientVersion, roots: Root[]): Promise<void> {\n    this._roots = roots;\n    await this._setCurrentClient(this._mcpProviders[0]);\n  }\n\n  async listTools(): Promise<Tool[]> {\n    const response = await this._currentClient!.listTools();\n    if (this._mcpProviders.length === 1)\n      return response.tools;\n    return [\n      ...response.tools,\n      this._contextSwitchTool,\n    ];\n  }\n\n  async callTool(name: string, args: CallToolRequest['params']['arguments']): Promise<CallToolResult> {\n    if (name === this._contextSwitchTool.name)\n      return this._callContextSwitchTool(args);\n    return await this._currentClient!.callTool({\n      name,\n      arguments: args,\n    }) as CallToolResult;\n  }\n\n  serverClosed?(): void {\n    void this._currentClient?.close().catch(errorsDebug);\n  }\n\n  private async _callContextSwitchTool(params: any): Promise<CallToolResult> {\n    try {\n      const factory = this._mcpProviders.find(factory => factory.name === params.name);\n      if (!factory)\n        throw new Error('Unknown connection method: ' + params.name);\n\n      await this._setCurrentClient(factory);\n      return {\n        content: [{ type: 'text', text: '### Result\\nSuccessfully changed connection method.\\n' }],\n      };\n    } catch (error) {\n      return {\n        content: [{ type: 'text', text: `### Result\\nError: ${error}\\n` }],\n        isError: true,\n      };\n    }\n  }\n\n  private _defineContextSwitchTool(): Tool {\n    return {\n      name: 'browser_connect',\n      description: [\n        'Connect to a browser using one of the available methods:',\n        ...this._mcpProviders.map(factory => `- \"${factory.name}\": ${factory.description}`),\n      ].join('\\n'),\n      inputSchema: mcp.zodToJsonSchema(mcp.z.object({\n        name: mcp.z.enum(this._mcpProviders.map(factory => factory.name) as [string, ...string[]]).default(this._mcpProviders[0].name).describe('The method to use to connect to the browser'),\n      }), { strictUnions: true }) as Tool['inputSchema'],\n      annotations: {\n        title: 'Connect to a browser context',\n        readOnlyHint: true,\n        openWorldHint: false,\n      },\n    };\n  }\n\n  private async _setCurrentClient(factory: MCPProvider) {\n    await this._currentClient?.close();\n    this._currentClient = undefined;\n\n    const client = new mcp.Client({ name: 'Playwright MCP Proxy', version: '0.0.0' });\n    client.registerCapabilities({\n      roots: {\n        listRoots: true,\n      },\n    });\n    client.setRequestHandler(mcp.ListRootsRequestSchema, () => ({ roots: this._roots }));\n    client.setRequestHandler(mcp.PingRequestSchema, () => ({}));\n\n    const transport = await factory.connect();\n    await client.connect(transport);\n    this._currentClient = client;\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["factory"]
+}

package/lib/mcp/sdk/server.js

@@ -0,0 +1,189 @@
+"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 server_exports = {};
+__export(server_exports, {
+  connect: () => connect,
+  createServer: () => createServer,
+  firstRootPath: () => firstRootPath,
+  start: () => start,
+  wrapInProcess: () => wrapInProcess
+});
+module.exports = __toCommonJS(server_exports);
+var import_url = require("url");
+var import_utilsBundle = require("playwright-core/lib/utilsBundle");
+var mcpBundle = __toESM(require("./bundle"));
+var import_http = require("./http");
+var import_inProcessTransport = require("./inProcessTransport");
+const serverDebug = (0, import_utilsBundle.debug)("pw:mcp:server");
+async function connect(factory, transport, runHeartbeat) {
+  const server = createServer(factory.name, factory.version, factory.create(), runHeartbeat);
+  await server.connect(transport);
+}
+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) {
+  const server = new mcpBundle.Server({ name, version }, {
+    capabilities: {
+      tools: {}
+    }
+  });
+  server.setRequestHandler(mcpBundle.ListToolsRequestSchema, async () => {
+    serverDebug("listTools");
+    const tools = await backend.listTools();
+    return { tools };
+  });
+  let initializePromise;
+  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 mergeTextParts(await backend.callTool(request.params.name, request.params.arguments || {}, progress));
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: "### Result\n" + String(error) }],
+        isError: true
+      };
+    }
+  });
+  addServerListener(server, "close", () => backend.serverClosed?.(server));
+  return server;
+}
+const initializeServer = async (server, backend, runHeartbeat) => {
+  const capabilities = server.getClientCapabilities();
+  let clientRoots = [];
+  if (capabilities?.roots) {
+    const { roots } = await server.listRoots().catch((e) => {
+      serverDebug(e);
+      return { roots: [] };
+    });
+    clientRoots = roots;
+  }
+  const clientInfo = {
+    name: server.getClientVersion()?.name ?? "unknown",
+    version: server.getClientVersion()?.version ?? "unknown",
+    roots: clientRoots,
+    timestamp: Date.now()
+  };
+  await backend.initialize?.(server, clientInfo);
+  if (runHeartbeat)
+    startHeartbeat(server);
+};
+const startHeartbeat = (server) => {
+  const beat = () => {
+    Promise.race([
+      server.ping(),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("ping timeout")), 5e3))
+    ]).then(() => {
+      setTimeout(beat, 3e3);
+    }).catch(() => {
+      void server.close();
+    });
+  };
+  beat();
+};
+function addServerListener(server, event, listener) {
+  const oldListener = server[`on${event}`];
+  server[`on${event}`] = () => {
+    oldListener?.();
+    listener();
+  };
+}
+async function start(serverBackendFactory, options) {
+  if (options.port === void 0) {
+    await connect(serverBackendFactory, new mcpBundle.StdioServerTransport(), false);
+    return;
+  }
+  const httpServer = await (0, import_http.startHttpServer)(options);
+  const url = await (0, import_http.installHttpTransport)(httpServer, serverBackendFactory, false, options.allowedHosts);
+  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);
+}
+function firstRootPath(clientInfo) {
+  if (clientInfo.roots.length === 0)
+    return void 0;
+  const firstRootUri = clientInfo.roots[0]?.uri;
+  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,
+  createServer,
+  firstRootPath,
+  start,
+  wrapInProcess
+});

package/lib/mcp/sdk/server.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/server.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { debug } from 'playwright-core/lib/utilsBundle';\n\nimport * as mcp from './bundle';\nimport { InProcessTransport } from './inProcessTransport';\nimport { httpAddressToString, installHttpTransport, startHttpServer } from './http';\n\nimport type { Tool, CallToolResult, CallToolRequest, Root } from '@modelcontextprotocol/sdk/types.js';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { Server } from '@modelcontextprotocol/sdk/server/index.js';\nexport type { Server } from '@modelcontextprotocol/sdk/server/index.js';\nexport type { Tool, CallToolResult, CallToolRequest, Root } from '@modelcontextprotocol/sdk/types.js';\n\nconst serverDebug = debug('pw:mcp:server');\nconst errorsDebug = debug('pw:mcp:errors');\n\nexport type ClientVersion = { name: string, version: string };\nexport interface ServerBackend {\n  initialize?(server: Server, clientVersion: ClientVersion, roots: Root[]): Promise<void>;\n  listTools(): Promise<Tool[]>;\n  callTool(name: string, args: CallToolRequest['params']['arguments']): Promise<CallToolResult>;\n  serverClosed?(server: Server): void;\n}\n\nexport type ServerBackendFactory = {\n  name: string;\n  nameInConfig: string;\n  version: string;\n  create: () => ServerBackend;\n};\n\nexport async function connect(factory: ServerBackendFactory, transport: Transport, runHeartbeat: boolean) {\n  const server = createServer(factory.name, factory.version, factory.create(), runHeartbeat);\n  await server.connect(transport);\n}\n\nexport async function wrapInProcess(backend: ServerBackend): Promise<Transport> {\n  const server = createServer('Internal', '0.0.0', backend, false);\n  return new InProcessTransport(server);\n}\n\nexport function createServer(name: string, version: string, backend: ServerBackend, runHeartbeat: boolean): Server {\n  let initializedPromiseResolve = () => {};\n  const initializedPromise = new Promise<void>(resolve => initializedPromiseResolve = resolve);\n  const server = new mcp.Server({ name, version }, {\n    capabilities: {\n      tools: {},\n    }\n  });\n\n  server.setRequestHandler(mcp.ListToolsRequestSchema, async () => {\n    serverDebug('listTools');\n    await initializedPromise;\n    const tools = await backend.listTools();\n    return { tools };\n  });\n\n  let heartbeatRunning = false;\n  server.setRequestHandler(mcp.CallToolRequestSchema, async request => {\n    serverDebug('callTool', request);\n    await initializedPromise;\n\n    if (runHeartbeat && !heartbeatRunning) {\n      heartbeatRunning = true;\n      startHeartbeat(server);\n    }\n\n    try {\n      return await backend.callTool(request.params.name, request.params.arguments || {});\n    } catch (error) {\n      return {\n        content: [{ type: 'text', text: '### Result\\n' + String(error) }],\n        isError: true,\n      };\n    }\n  });\n  addServerListener(server, 'initialized', async () => {\n    try {\n      const capabilities = server.getClientCapabilities();\n      let clientRoots: Root[] = [];\n      if (capabilities?.roots) {\n        const { roots } = await server.listRoots(undefined, { timeout: 2_000 }).catch(() => ({ roots: [] }));\n        clientRoots = roots;\n      }\n      const clientVersion = server.getClientVersion() ?? { name: 'unknown', version: 'unknown' };\n      await backend.initialize?.(server, clientVersion, clientRoots);\n      initializedPromiseResolve();\n    } catch (e) {\n      errorsDebug(e);\n    }\n  });\n  addServerListener(server, 'close', () => backend.serverClosed?.(server));\n  return server;\n}\n\nconst startHeartbeat = (server: Server) => {\n  const beat = () => {\n    Promise.race([\n      server.ping(),\n      new Promise((_, reject) => setTimeout(() => reject(new Error('ping timeout')), 5000)),\n    ]).then(() => {\n      setTimeout(beat, 3000);\n    }).catch(() => {\n      void server.close();\n    });\n  };\n\n  beat();\n};\n\nfunction addServerListener(server: Server, event: 'close' | 'initialized', listener: () => void) {\n  const oldListener = server[`on${event}`];\n  server[`on${event}`] = () => {\n    oldListener?.();\n    listener();\n  };\n}\n\nexport async function start(serverBackendFactory: ServerBackendFactory, options: { host?: string; port?: number }) {\n  if (options.port === undefined) {\n    await connect(serverBackendFactory, new mcp.StdioServerTransport(), false);\n    return;\n  }\n\n  const httpServer = await startHttpServer(options);\n  await installHttpTransport(httpServer, serverBackendFactory);\n  const url = httpAddressToString(httpServer.address());\n\n  const mcpConfig: any = { mcpServers: { } };\n  mcpConfig.mcpServers[serverBackendFactory.nameInConfig] = {\n    url: `${url}/mcp`\n  };\n  const message = [\n    `Listening on ${url}`,\n    'Put this in your client config:',\n    JSON.stringify(mcpConfig, undefined, 2),\n    'For legacy SSE transport support, you can use the /sse endpoint instead.',\n  ].join('\\n');\n    // eslint-disable-next-line no-console\n  console.error(message);\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,yBAAsB;AAEtB,UAAqB;AACrB,gCAAmC;AACnC,kBAA2E;AAQ3E,MAAM,kBAAc,0BAAM,eAAe;AACzC,MAAM,kBAAc,0BAAM,eAAe;AAiBzC,eAAsB,QAAQ,SAA+B,WAAsB,cAAuB;AACxG,QAAM,SAAS,aAAa,QAAQ,MAAM,QAAQ,SAAS,QAAQ,OAAO,GAAG,YAAY;AACzF,QAAM,OAAO,QAAQ,SAAS;AAChC;AAEA,eAAsB,cAAc,SAA4C;AAC9E,QAAM,SAAS,aAAa,YAAY,SAAS,SAAS,KAAK;AAC/D,SAAO,IAAI,6CAAmB,MAAM;AACtC;AAEO,SAAS,aAAa,MAAc,SAAiB,SAAwB,cAA+B;AACjH,MAAI,4BAA4B,MAAM;AAAA,EAAC;AACvC,QAAM,qBAAqB,IAAI,QAAc,aAAW,4BAA4B,OAAO;AAC3F,QAAM,SAAS,IAAI,IAAI,OAAO,EAAE,MAAM,QAAQ,GAAG;AAAA,IAC/C,cAAc;AAAA,MACZ,OAAO,CAAC;AAAA,IACV;AAAA,EACF,CAAC;AAED,SAAO,kBAAkB,IAAI,wBAAwB,YAAY;AAC/D,gBAAY,WAAW;AACvB,UAAM;AACN,UAAM,QAAQ,MAAM,QAAQ,UAAU;AACtC,WAAO,EAAE,MAAM;AAAA,EACjB,CAAC;AAED,MAAI,mBAAmB;AACvB,SAAO,kBAAkB,IAAI,uBAAuB,OAAM,YAAW;AACnE,gBAAY,YAAY,OAAO;AAC/B,UAAM;AAEN,QAAI,gBAAgB,CAAC,kBAAkB;AACrC,yBAAmB;AACnB,qBAAe,MAAM;AAAA,IACvB;AAEA,QAAI;AACF,aAAO,MAAM,QAAQ,SAAS,QAAQ,OAAO,MAAM,QAAQ,OAAO,aAAa,CAAC,CAAC;AAAA,IACnF,SAAS,OAAO;AACd,aAAO;AAAA,QACL,SAAS,CAAC,EAAE,MAAM,QAAQ,MAAM,iBAAiB,OAAO,KAAK,EAAE,CAAC;AAAA,QAChE,SAAS;AAAA,MACX;AAAA,IACF;AAAA,EACF,CAAC;AACD,oBAAkB,QAAQ,eAAe,YAAY;AACnD,QAAI;AACF,YAAM,eAAe,OAAO,sBAAsB;AAClD,UAAI,cAAsB,CAAC;AAC3B,UAAI,cAAc,OAAO;AACvB,cAAM,EAAE,MAAM,IAAI,MAAM,OAAO,UAAU,QAAW,EAAE,SAAS,IAAM,CAAC,EAAE,MAAM,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE;AACnG,sBAAc;AAAA,MAChB;AACA,YAAM,gBAAgB,OAAO,iBAAiB,KAAK,EAAE,MAAM,WAAW,SAAS,UAAU;AACzF,YAAM,QAAQ,aAAa,QAAQ,eAAe,WAAW;AAC7D,gCAA0B;AAAA,IAC5B,SAAS,GAAG;AACV,kBAAY,CAAC;AAAA,IACf;AAAA,EACF,CAAC;AACD,oBAAkB,QAAQ,SAAS,MAAM,QAAQ,eAAe,MAAM,CAAC;AACvE,SAAO;AACT;AAEA,MAAM,iBAAiB,CAAC,WAAmB;AACzC,QAAM,OAAO,MAAM;AACjB,YAAQ,KAAK;AAAA,MACX,OAAO,KAAK;AAAA,MACZ,IAAI,QAAQ,CAAC,GAAG,WAAW,WAAW,MAAM,OAAO,IAAI,MAAM,cAAc,CAAC,GAAG,GAAI,CAAC;AAAA,IACtF,CAAC,EAAE,KAAK,MAAM;AACZ,iBAAW,MAAM,GAAI;AAAA,IACvB,CAAC,EAAE,MAAM,MAAM;AACb,WAAK,OAAO,MAAM;AAAA,IACpB,CAAC;AAAA,EACH;AAEA,OAAK;AACP;AAEA,SAAS,kBAAkB,QAAgB,OAAgC,UAAsB;AAC/F,QAAM,cAAc,OAAO,KAAK,KAAK,EAAE;AACvC,SAAO,KAAK,KAAK,EAAE,IAAI,MAAM;AAC3B,kBAAc;AACd,aAAS;AAAA,EACX;AACF;AAEA,eAAsB,MAAM,sBAA4C,SAA2C;AACjH,MAAI,QAAQ,SAAS,QAAW;AAC9B,UAAM,QAAQ,sBAAsB,IAAI,IAAI,qBAAqB,GAAG,KAAK;AACzE;AAAA,EACF;AAEA,QAAM,aAAa,UAAM,6BAAgB,OAAO;AAChD,YAAM,kCAAqB,YAAY,oBAAoB;AAC3D,QAAM,UAAM,iCAAoB,WAAW,QAAQ,CAAC;AAEpD,QAAM,YAAiB,EAAE,YAAY,CAAE,EAAE;AACzC,YAAU,WAAW,qBAAqB,YAAY,IAAI;AAAA,IACxD,KAAK,GAAG,GAAG;AAAA,EACb;AACA,QAAM,UAAU;AAAA,IACd,gBAAgB,GAAG;AAAA,IACnB;AAAA,IACA,KAAK,UAAU,WAAW,QAAW,CAAC;AAAA,IACtC;AAAA,EACF,EAAE,KAAK,IAAI;AAEX,UAAQ,MAAM,OAAO;AACvB;",
+  "names": []
+}

package/lib/mcp/sdk/tool.js

@@ -0,0 +1,51 @@
+"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 tool_exports = {};
+__export(tool_exports, {
+  defineToolSchema: () => defineToolSchema,
+  toMcpTool: () => toMcpTool
+});
+module.exports = __toCommonJS(tool_exports);
+var import_bundle = require("../sdk/bundle");
+const typesWithIntent = ["action", "assertion", "input"];
+function toMcpTool(tool, options) {
+  const inputSchema = options?.addIntent && typesWithIntent.includes(tool.type) ? tool.inputSchema.extend({
+    intent: import_bundle.z.string().describe("The intent of the call, for example the test step description plan idea")
+  }) : tool.inputSchema;
+  const readOnly = tool.type === "readOnly" || tool.type === "assertion";
+  return {
+    name: tool.name,
+    description: tool.description,
+    inputSchema: (0, import_bundle.zodToJsonSchema)(inputSchema, { strictUnions: true }),
+    annotations: {
+      title: tool.title,
+      readOnlyHint: readOnly,
+      destructiveHint: !readOnly,
+      openWorldHint: true
+    }
+  };
+}
+function defineToolSchema(tool) {
+  return tool;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  defineToolSchema,
+  toMcpTool
+});

package/lib/mcp/sdk/tool.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/mcp/sdk/tool.ts"],
+  "sourcesContent": ["/**\n * Copyright (c) Microsoft Corporation.\n *\n * Licensed under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License.\n * You may obtain a copy of the License at\n *\n * http://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software\n * distributed under the License is distributed on an \"AS IS\" BASIS,\n * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n * See the License for the specific language governing permissions and\n * limitations under the License.\n */\n\nimport { zodToJsonSchema } from './bundle.js';\n\nimport type { z } from 'zod';\nimport type * as mcpServer from './server.js';\n\nexport type ToolSchema<Input extends z.Schema> = {\n  name: string;\n  title: string;\n  description: string;\n  inputSchema: Input;\n  type: 'readOnly' | 'destructive';\n};\n\nexport function toMcpTool(tool: ToolSchema<any>): mcpServer.Tool {\n  return {\n    name: tool.name,\n    description: tool.description,\n    inputSchema: zodToJsonSchema(tool.inputSchema, { strictUnions: true }) as mcpServer.Tool['inputSchema'],\n    annotations: {\n      title: tool.title,\n      readOnlyHint: tool.type === 'readOnly',\n      destructiveHint: tool.type === 'destructive',\n      openWorldHint: true,\n    },\n  };\n}\n\nexport function defineToolSchema<Input extends z.Schema>(tool: ToolSchema<Input>): ToolSchema<Input> {\n  return tool;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAgBA,oBAAgC;AAazB,SAAS,UAAU,MAAuC;AAC/D,SAAO;AAAA,IACL,MAAM,KAAK;AAAA,IACX,aAAa,KAAK;AAAA,IAClB,iBAAa,+BAAgB,KAAK,aAAa,EAAE,cAAc,KAAK,CAAC;AAAA,IACrE,aAAa;AAAA,MACX,OAAO,KAAK;AAAA,MACZ,cAAc,KAAK,SAAS;AAAA,MAC5B,iBAAiB,KAAK,SAAS;AAAA,MAC/B,eAAe;AAAA,IACjB;AAAA,EACF;AACF;AAEO,SAAS,iBAAyC,MAA4C;AACnG,SAAO;AACT;",
+  "names": []
+}