Better Playwright MCP

Instructions

Implementation Reference

• lib/tools/navigate.js:45-49 (handler)

  The handler function for the 'browser_navigate_back' tool. It calls goBack on the current tab's page, includes a snapshot in the response, and adds the corresponding Playwright code snippet.

  handle: async (tab, params, response) => {
      await tab.page.goBack();
      response.setIncludeSnapshot();
      response.addCode(`await page.goBack();`);
  },

• lib/tools/navigate.js:38-44 (schema)

  Schema definition for the 'browser_navigate_back' tool, including name, title, description, empty input schema, and readOnly type.

  schema: {
      name: 'browser_navigate_back',
      title: 'Go back',
      description: 'Go back to the previous page',
      inputSchema: z.object({}),
      type: 'readOnly',
  },

• lib/tools.js:32-49 (registration)

  Registration of all tools, including the navigate tools (which contain 'browser_navigate_back') by spreading the imported navigate array into the allTools export.

  export const allTools = [
      ...common,
      ...console,
      ...dialogs,
      ...evaluate,
      ...files,
      ...form,
      ...install,
      ...keyboard,
      ...navigate,
      ...network,
      ...mouse,
      ...pdf,
      ...screenshot,
      ...snapshot,
      ...tabs,
      ...wait,
  ];

• lib/browserServerBackend.js:50-52 (registration)

  MCP tool listing registration: maps internal tools (including 'browser_navigate_back') to MCP tool format using toMcpTool.

  async listTools() {
      return this._tools.map(tool => toMcpTool(tool.schema));
  }

• lib/browserServerBackend.js:53-73 (registration)

  MCP tool execution: finds tool by name (e.g., 'browser_navigate_back'), parses arguments, calls the handle function, and serializes the response.

  async callTool(name, rawArguments) {
      const tool = this._tools.find(tool => tool.schema.name === name);
      if (!tool)
          throw new Error(`Tool "${name}" not found`);
      const parsedArguments = tool.schema.inputSchema.parse(rawArguments || {});
      const context = this._context;
      const response = new Response(context, name, parsedArguments);
      context.setRunningTool(name);
      try {
          await tool.handle(context, parsedArguments, response);
          await response.finish();
          this._sessionLog?.logResponse(response);
      }
      catch (error) {
          response.addError(String(error));
      }
      finally {
          context.setRunningTool(undefined);
      }
      return response.serialize();
  }