Skip to content

Playwright is a framework for Web Testing and Automation. It allows testing Chromium, Firefox and WebKit with a single API.

chore: simplify outer/inner mdb interaction (#37670)

Pavel Feldman6e2cc2a2e4a8
diff --git a/packages/playwright/bundles/mcp/src/mcpBundleImpl.ts b/packages/playwright/bundles/mcp/src/mcpBundleImpl.ts
index 890479adc9..613a648e15 100644
--- a/packages/playwright/bundles/mcp/src/mcpBundleImpl.ts
+++ b/packages/playwright/bundles/mcp/src/mcpBundleImpl.ts
@@ -16,6 +16,7 @@
export { Client } from '@modelcontextprotocol/sdk/client/index.js';
export { Server } from '@modelcontextprotocol/sdk/server/index.js';
+export { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
export { SSEServerTransport } from '@modelcontextprotocol/sdk/server/sse.js';
export { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
export { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
diff --git a/packages/playwright/src/mcp/browser/tools/screenshot.ts b/packages/playwright/src/mcp/browser/tools/screenshot.ts
index d074fe507c..7aa37db998 100644
--- a/packages/playwright/src/mcp/browser/tools/screenshot.ts
+++ b/packages/playwright/src/mcp/browser/tools/screenshot.ts
@@ -27,16 +27,6 @@ const screenshotSchema = z.object({
element: z.string().optional().describe('Human-readable element description used to obtain permission to screenshot the element. If not provided, the screenshot will be taken of viewport. If element is provided, ref must be provided too.'),
ref: z.string().optional().describe('Exact target element reference from the page snapshot. If not provided, the screenshot will be taken of viewport. If ref is provided, element must be provided too.'),
fullPage: z.boolean().optional().describe('When true, takes a screenshot of the full scrollable page, instead of the currently visible viewport. Cannot be used with element screenshots.'),
-}).refine(data => {
- return !!data.element === !!data.ref;
-}, {
- message: 'Both element and ref must be provided or neither.',
- path: ['ref', 'element']
-}).refine(data => {
- return !(data.fullPage && (data.element || data.ref));
-}, {
- message: 'fullPage cannot be used with element screenshots.',
- path: ['fullPage']
});
const screenshot = defineTabTool({
@@ -50,6 +40,11 @@ const screenshot = defineTabTool({
},
handle: async (tab, params, response) => {
+ if (!!params.element !== !!params.ref)
+ throw new Error('Both element and ref must be provided or neither.');
+ if (params.fullPage && params.ref)
+ throw new Error('fullPage cannot be used with element screenshots.');
+
const fileType = params.type || 'png';
const fileName = await tab.context.outputFile(params.filename ?? dateAsFileName(fileType), { origin: 'llm', reason: 'Saving screenshot' });
const options: playwright.PageScreenshotOptions = {
diff --git a/packages/playwright/src/mcp/sdk/bundle.ts b/packages/playwright/src/mcp/sdk/bundle.ts
index 4f181063fd..43fa2d3941 100644
--- a/packages/playwright/src/mcp/sdk/bundle.ts
+++ b/packages/playwright/src/mcp/sdk/bundle.ts
@@ -20,6 +20,7 @@ import * as bundle from '../../mcpBundleImpl';
const zodToJsonSchema: typeof import('zod-to-json-schema').zodToJsonSchema = bundle.zodToJsonSchema;
const Client: typeof import('@modelcontextprotocol/sdk/client/index.js').Client = bundle.Client;
const Server: typeof import('@modelcontextprotocol/sdk/server/index.js').Server = bundle.Server;
+const SSEClientTransport: typeof import('@modelcontextprotocol/sdk/client/sse.js').SSEClientTransport = bundle.SSEClientTransport;
const SSEServerTransport: typeof import('@modelcontextprotocol/sdk/server/sse.js').SSEServerTransport = bundle.SSEServerTransport;
const StdioClientTransport: typeof import('@modelcontextprotocol/sdk/client/stdio.js').StdioClientTransport = bundle.StdioClientTransport;
const StdioServerTransport: typeof import('@modelcontextprotocol/sdk/server/stdio.js').StdioServerTransport = bundle.StdioServerTransport;
@@ -36,6 +37,7 @@ export {
zodToJsonSchema,
Client,
Server,
+ SSEClientTransport,
SSEServerTransport,
StdioClientTransport,
StdioServerTransport,
diff --git a/packages/playwright/src/mcp/sdk/mdb.ts b/packages/playwright/src/mcp/sdk/mdb.ts
index 7952798edf..af4969ec3d 100644
--- a/packages/playwright/src/mcp/sdk/mdb.ts
+++ b/packages/playwright/src/mcp/sdk/mdb.ts
@@ -22,7 +22,7 @@ import * as mcpBundle from './bundle';
import * as mcpServer from './server';
import * as mcpHttp from './http';
-import type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';
+import type { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
import type { Client } from '@modelcontextprotocol/sdk/client/index.js';
const mdbDebug = debug('pw:mcp:mdb');
@@ -30,17 +30,15 @@ const errorsDebug = debug('pw:mcp:errors');
const z = mcpBundle.z;
export class MDBBackend implements mcpServer.ServerBackend {
- private _onPauseClient: { client: Client, tools: mcpServer.Tool[] } | undefined;
+ private _onPauseClient: { client: Client, tools: mcpServer.Tool[], transport: StreamableHTTPClientTransport } | undefined;
private _interruptPromise: ManualPromise<mcpServer.CallToolResult> | undefined;
private _mainBackend: mcpServer.ServerBackend;
- private _allowedOnPause: string[];
private _clientInfo: mcpServer.ClientInfo | undefined;
private _progress: mcpServer.CallToolResult['content'] = [];
private _progressCallback: mcpServer.ProgressCallback;
- constructor(mainBackend: mcpServer.ServerBackend, allowedOnPause: string[]) {
+ constructor(mainBackend: mcpServer.ServerBackend) {
this._mainBackend = mainBackend;
- this._allowedOnPause = allowedOnPause;
this._progressCallback = (params: mcpServer.ProgressParams) => {
if (params.message)
this._progress.push({ type: 'text', text: params.message });
@@ -59,25 +57,32 @@ export class MDBBackend implements mcpServer.ServerBackend {
}
async callTool(name: string, args: mcpServer.CallToolRequest['params']['arguments']): Promise<mcpServer.CallToolResult> {
- if (name === pushToolsSchema.name)
- return await this._pushTools(pushToolsSchema.inputSchema.parse(args || {}));
-
- if (this._onPauseClient && this._onPauseClient.tools.find(tool => tool.name === name)) {
- const result = await this._onPauseClient.client.callTool({
- name,
- arguments: args,
- });
- return result as mcpServer.CallToolResult;
+ if (name === pushToolsSchema.name) {
+ await this._createOnPauseClient(pushToolsSchema.inputSchema.parse(args || {}));
+ return { content: [{ type: 'text', text: 'Tools pushed' }] };
}
- if (this._onPauseClient && !this._allowedOnPause.includes(name)) {
- await this._onPauseClient.client.close().catch(errorsDebug);
+ const disposition = await this._mainBackend.beforeCallTool?.(name, args);
+ if (disposition?.resetOnPause) {
+ await this._onPauseClient?.transport.terminateSession().catch(errorsDebug);
+ await this._onPauseClient?.client.close().catch(errorsDebug);
this._onPauseClient = undefined;
}
+ if (disposition?.fallbackToOnPause) {
+ if (!this._onPauseClient)
+ throw new Error(`Can't call tool while not in on-pause mode`);
+
+ return await this._onPauseClient.client.callTool({
+ name,
+ arguments: args,
+ }) as mcpServer.CallToolResult;
+ }
+
const resultPromise = new ManualPromise<mcpServer.CallToolResult>();
const interruptPromise = new ManualPromise<mcpServer.CallToolResult>();
this._interruptPromise = interruptPromise;
+
this._mainBackend.callTool(name, args, this._progressCallback).then(result => {
resultPromise.resolve(result as mcpServer.CallToolResult);
}).catch(e => {
@@ -94,13 +99,22 @@ export class MDBBackend implements mcpServer.ServerBackend {
return result;
}
- private async _pushTools(params: { mcpUrl: string, introMessage?: string }): Promise<mcpServer.CallToolResult> {
- const transport = new mcpBundle.StreamableHTTPClientTransport(new URL(params.mcpUrl));
- await this._pushClient(transport, params.introMessage);
- return { content: [{ type: 'text', text: 'Tools pushed' }] };
+ private async _createOnPauseClient(params: { mcpUrl: string, introMessage?: string }) {
+ 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 = undefined;
}
- private async _createClient(transport: Transport, introMessage?: string): Promise<{ client: Client, tools: mcpServer.Tool[] }> {
+ private async _createClient(url: string): Promise<{ client: Client, tools: mcpServer.Tool[], transport: StreamableHTTPClientTransport }> {
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, () => ({}));
@@ -111,24 +125,10 @@ export class MDBBackend implements mcpServer.ServerBackend {
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 };
- }
-
- private async _pushClient(transport: Transport, introMessage?: string): Promise<mcpServer.CallToolResult> {
- if (this._onPauseClient)
- await this._onPauseClient.client.close().catch(errorsDebug);
- this._onPauseClient = await this._createClient(transport);
-
- this._interruptPromise?.resolve({
- content: [{
- type: 'text',
- text: introMessage || '',
- }],
- });
- this._interruptPromise = undefined;
- return { content: [{ type: 'text', text: 'Tools pushed' }] };
+ return { client, tools, transport };
}
}
@@ -143,8 +143,8 @@ const pushToolsSchema = defineToolSchema({
type: 'readOnly',
});
-export async function runMainBackend(backendFactory: mcpServer.ServerBackendFactory, allowedOnPause: string[], options?: { port?: number }): Promise<string | undefined> {
- const mdbBackend = new MDBBackend(backendFactory.create(), allowedOnPause);
+export async function runMainBackend(backendFactory: mcpServer.ServerBackendFactory, options?: { port?: number }): Promise<string | undefined> {
+ const mdbBackend = new MDBBackend(backendFactory.create());
// Start HTTP unconditionally.
const factory: mcpServer.ServerBackendFactory = {
...backendFactory,
diff --git a/packages/playwright/src/mcp/sdk/server.ts b/packages/playwright/src/mcp/sdk/server.ts
index 7169f79e93..416f214e5c 100644
--- a/packages/playwright/src/mcp/sdk/server.ts
+++ b/packages/playwright/src/mcp/sdk/server.ts
@@ -43,6 +43,7 @@ export type ProgressCallback = (params: ProgressParams) => void;
export interface ServerBackend {
initialize?(server: Server, clientInfo: ClientInfo): Promise<void>;
listTools(): Promise<Tool[]>;
+ beforeCallTool?(name: string, args: CallToolRequest['params']['arguments']): Promise<{ fallbackToOnPause?: boolean, resetOnPause?: boolean }>;
callTool(name: string, args: CallToolRequest['params']['arguments'], progress: ProgressCallback): Promise<CallToolResult>;
serverClosed?(server: Server): void;
}
diff --git a/packages/playwright/src/mcp/test/testBackend.ts b/packages/playwright/src/mcp/test/testBackend.ts
index ade9e83d60..66aa27c070 100644
--- a/packages/playwright/src/mcp/test/testBackend.ts
+++ b/packages/playwright/src/mcp/test/testBackend.ts
@@ -40,10 +40,6 @@ export class TestServerBackend implements mcp.ServerBackend {
private _context: TestContext;
private _configOption: string | undefined;
- static allowedOnPause: string[] = [
- generatorTools.generatorLogStep.schema.name,
- ];
-
constructor(configOption: string | undefined, options?: { muteConsole?: boolean, headless?: boolean }) {
this._context = new TestContext(options);
this._configOption = configOption;
@@ -72,6 +68,14 @@ export class TestServerBackend implements mcp.ServerBackend {
];
}
+ async beforeCallTool(name: string, args: mcp.CallToolRequest['params']['arguments']) {
+ if (browserTools.find(tool => tool.schema.name === name))
+ return { fallbackToOnPause: true };
+ if (name !== generatorTools.generatorLogStep.schema.name)
+ return { resetOnPause: true };
+ return {};
+ }
+
async callTool(name: string, args: mcp.CallToolRequest['params']['arguments'], progress: mcp.ProgressCallback): Promise<mcp.CallToolResult> {
const tool = this._tools.find(tool => tool.schema.name === name);
if (!tool)
diff --git a/packages/playwright/src/program.ts b/packages/playwright/src/program.ts
index 82857da2ef..4180153327 100644
--- a/packages/playwright/src/program.ts
+++ b/packages/playwright/src/program.ts
@@ -171,7 +171,6 @@ function addTestMCPServerCommand(program: Command) {
};
const mdbUrl = await runMainBackend(
backendFactory,
- TestServerBackend.allowedOnPause,
{
port: options.port === undefined ? undefined : +options.port
},
diff --git a/tests/mcp/console.spec.ts b/tests/mcp/console.spec.ts
index 30d9cd84ec..4deec26097 100644
--- a/tests/mcp/console.spec.ts
+++ b/tests/mcp/console.spec.ts
@@ -107,7 +107,6 @@ test('browser_console_messages errors only', async ({ client, server }) => {
},
});
- console.log(performance.now());
await client.callTool({
name: 'browser_evaluate',
arguments: {
@@ -120,7 +119,6 @@ test('browser_console_messages errors only', async ({ client, server }) => {
}`,
},
});
- console.log(performance.now());
const response = parseResponse(await client.callTool({
name: 'browser_console_messages',
@@ -128,7 +126,6 @@ test('browser_console_messages errors only', async ({ client, server }) => {
onlyErrors: true,
},
}));
- console.log(performance.now());
expect.soft(response.result).toContain('console.error');
expect.soft(response.result).toContain('Error: unhandled');
expect.soft(response.result).toContain('404');
diff --git a/tests/mcp/mdb.spec.ts b/tests/mcp/mdb.spec.ts
index 7946795ad5..94a293c5e2 100644
--- a/tests/mcp/mdb.spec.ts
+++ b/tests/mcp/mdb.spec.ts
@@ -119,18 +119,58 @@ test('outer and inner roots available', async () => {
await mdbClient.close();
});
-async function startMDBAndCLI(): Promise<{ mdbUrl: string }> {
+test('reset on pause tools', async () => {
+ const { mdbUrl, log } = await startMDBAndCLI();
+ const mdbClient = await createMDBClient(mdbUrl);
+
+ // Make a call that results in a recoverable error.
+ const interruptResult = await mdbClient.client.callTool({
+ name: 'cli_pause_in_gdb',
+ arguments: {},
+ });
+ expect(interruptResult.content).toEqual([{ type: 'text', text: 'Paused on exception' }]);
+
+ // Call the new inner tool.
+ const btResult = await mdbClient.client.callTool({
+ name: 'gdb_bt',
+ arguments: {},
+ });
+ expect(btResult.content).toEqual([{ type: 'text', text: 'Backtrace' }]);
+
+ await mdbClient.client.callTool({
+ name: 'cli_echo',
+ arguments: {},
+ });
+
+ await expect.poll(() => log).toEqual([
+ 'CLI: initialize',
+ 'CLI: beforeCallTool cli_pause_in_gdb',
+ 'CLI: callTool cli_pause_in_gdb',
+ 'GDB: listTools',
+ 'CLI: beforeCallTool gdb_bt',
+ 'GDB: initialize',
+ 'GDB: callTool gdb_bt',
+ 'CLI: beforeCallTool cli_echo',
+ 'GDB: serverClosed',
+ 'CLI: callTool cli_echo',
+ ]);
+
+ await mdbClient.close();
+});
+
+async function startMDBAndCLI(): Promise<{ mdbUrl: string, log: string[] }> {
const mdbUrlBox = { mdbUrl: undefined as string | undefined };
+ const log: string[] = [];
const cliBackendFactory = {
name: 'CLI',
nameInConfig: 'cli',
version: '0.0.0',
- create: () => new CLIBackend(mdbUrlBox)
+ create: () => new CLIBackend(log)
};
- const mdbUrl = (await runMainBackend(cliBackendFactory, [], { port: 0 }))!;
+ const mdbUrl = (await runMainBackend(cliBackendFactory, { port: 0 }))!;
mdbUrlBox.mdbUrl = mdbUrl;
- return { mdbUrl };
+ return { mdbUrl, log };
}
async function createMDBClient(mdbUrl: string, roots: any[] | undefined = undefined): Promise<{ client: Client, close: () => Promise<void> }> {
@@ -150,14 +190,19 @@ async function createMDBClient(mdbUrl: string, roots: any[] | undefined = undefi
class CLIBackend {
private _roots: any[] | undefined;
+ private _log: string[] = [];
- constructor(private readonly mdbUrlBox: { mdbUrl: string | undefined }) {}
+ constructor(log: string[]) {
+ this._log = log;
+ }
async initialize(server, clientInfo) {
+ this._log.push('CLI: initialize');
this._roots = clientInfo.roots;
}
async listTools() {
+ this._log.push('CLI: listTools');
return [{
name: 'cli_echo',
description: 'Echo a message',
@@ -181,30 +226,49 @@ class CLIBackend {
}];
}
+ async beforeCallTool(name: string, args: any) {
+ this._log.push(`CLI: beforeCallTool ${name}`);
+ if (name.startsWith('gdb_'))
+ return { fallbackToOnPause: true };
+ return { resetOnPause: true };
+ }
+
async callTool(name: string, args: any) {
+ this._log.push(`CLI: callTool ${name}`);
if (name === 'cli_echo')
return { content: [{ type: 'text', text: `Echo: ${args?.message as string}, roots: ${stringifyRoots(this._roots)}` }] };
if (name === 'cli_pause_in_gdb') {
- await runOnPauseBackendLoop(new GDBBackend(), 'Paused on exception');
+ await runOnPauseBackendLoop(new GDBBackend(this._log), 'Paused on exception');
return { content: [{ type: 'text', text: 'Done' }] };
}
if (name === 'cli_pause_in_gdb_twice') {
- await runOnPauseBackendLoop(new GDBBackend(), 'Paused on exception 1');
- await runOnPauseBackendLoop(new GDBBackend(), 'Paused on exception 2');
+ await runOnPauseBackendLoop(new GDBBackend(this._log), 'Paused on exception 1');
+ await runOnPauseBackendLoop(new GDBBackend(this._log), 'Paused on exception 2');
return { content: [{ type: 'text', text: 'Done' }] };
}
throw new Error(`Unknown tool: ${name}`);
}
+
+ serverClosed() {
+ this._log.push('CLI: serverClosed');
+ }
}
class GDBBackend {
private _roots: any[] | undefined;
+ private _log: string[] = [];
+
+ constructor(log: string[]) {
+ this._log = log;
+ }
async initialize(server, clientVersion) {
+ this._log.push('GDB: initialize');
this._roots = clientVersion.roots;
}
async listTools() {
+ this._log.push('GDB: listTools');
return [{
name: 'gdb_bt',
description: 'Print backtrace',
@@ -217,12 +281,17 @@ class GDBBackend {
}
async callTool(name: string, args: any) {
+ this._log.push(`GDB: callTool ${name}`);
if (name === 'gdb_echo')
return { content: [{ type: 'text', text: `Echo: ${args?.message as string}, roots: ${stringifyRoots(this._roots)}` }] };
if (name === 'gdb_bt')
return { content: [{ type: 'text', text: 'Backtrace' }] };
throw new Error(`Unknown tool: ${name}`);
}
+
+ serverClosed() {
+ this._log.push('GDB: serverClosed');
+ }
}
function stringifyRoots(roots: any[]) {