mcp-playwright

Instructions

Implementation Reference

• src/tools/api/requests.ts:115-148 (handler)

  The PatchRequestTool class provides the core handler logic for the "playwright_patch" tool. It performs an HTTP PATCH request to the specified URL with the provided data using Playwright's APIRequestContext, handles JSON validation, captures the response, and formats the output.

  export class PatchRequestTool extends ApiToolBase {
    /**
     * Execute the PATCH request tool
     */
    async execute(args: any, context: ToolContext): Promise<ToolResponse> {
      return this.safeExecute(context, async (apiContext) => {
        // Check if the value is valid JSON if it starts with { or [
        if (args.value && typeof args.value === "string" && (args.value.startsWith("{") || args.value.startsWith("["))) {
          try {
            JSON.parse(args.value);
          } catch (error) {
            return createErrorResponse(`Failed to parse request body: ${(error as Error).message}`);
          }
        }
  
        const response = await apiContext.patch(args.url, {
          data: args.value,
        });
  
        let responseText: string;
        try {
          responseText = await response.text();
        } catch (_error) {
          responseText = "Unable to get response text";
        }
  
        return createSuccessResponse([
          `PATCH request to ${args.url}`,
          `Status: ${response.status()} ${response.statusText()}`,
          `Response: ${responseText.substring(0, 1000)}${responseText.length > 1000 ? "..." : ""}`,
        ]);
      });
    }
  }

• src/tools.ts:314-325 (schema)

  Defines the input schema and metadata for the "playwright_patch" tool as part of the tool definitions returned by createToolDefinitions().

  {
    name: "playwright_patch",
    description: "Perform an HTTP PATCH request",
    inputSchema: {
      type: "object",
      properties: {
        url: { type: "string", description: "URL to perform PUT operation" },
        value: { type: "string", description: "Data to PATCH in the body" },
      },
      required: ["url", "value"],
    },
  },

• src/toolHandler.ts:634-635 (registration)

  Registers and dispatches the "playwright_patch" tool call to the PatchRequestTool instance in the main handleToolCall switch statement.

  case "playwright_patch":
    return await patchRequestTool.execute(args, context);

• src/toolHandler.ts:409-411 (registration)

  Instantiates the PatchRequestTool instance during tool initialization in initializeTools().

  if (!putRequestTool) putRequestTool = new PutRequestTool(server);
  if (!patchRequestTool) patchRequestTool = new PatchRequestTool(server);
  if (!deleteRequestTool) deleteRequestTool = new DeleteRequestTool(server);

• src/tools/api/base.ts:8-64 (helper)

  Base class for API tools providing safeExecute method used by PatchRequestTool for error handling and API context validation.

  export abstract class ApiToolBase implements ToolHandler {
    protected server: any;
  
    constructor(server: any) {
      this.server = server;
    }
  
    /**
     * Main execution method that all tools must implement
     */
    abstract execute(args: any, context: ToolContext): Promise<ToolResponse>;
  
    /**
     * Ensures an API context is available and returns it
     * @param context The tool context containing apiContext
     * @returns The apiContext or null if not available
     */
    protected ensureApiContext(context: ToolContext): APIRequestContext | null {
      if (!context.apiContext) {
        return null;
      }
      return context.apiContext;
    }
  
    /**
     * Validates that an API context is available and returns an error response if not
     * @param context The tool context
     * @returns Either null if apiContext is available, or an error response
     */
    protected validateApiContextAvailable(context: ToolContext): ToolResponse | null {
      if (!this.ensureApiContext(context)) {
        return createErrorResponse("API context not initialized");
      }
      return null;
    }
  
    /**
     * Safely executes an API operation with proper error handling
     * @param context The tool context
     * @param operation The async operation to perform
     * @returns The tool response
     */
    protected async safeExecute(
      context: ToolContext,
      operation: (apiContext: APIRequestContext) => Promise<ToolResponse>,
    ): Promise<ToolResponse> {
      const apiError = this.validateApiContextAvailable(context);
      if (apiError) return apiError;
  
      try {
        return await operation(context.apiContext!);
      } catch (error) {
        return createErrorResponse(`API operation failed: ${(error as Error).message}`);
      }
    }
  }