playwright_assert_response

Validate HTTP responses in browser automation by checking expected data in response bodies after initiating wait operations.

Instructions

Wait for and validate a previously initiated HTTP response wait operation.

Input Schema

TableJSON Schema

Name	Required	Description	Default
`id`	Yes	Identifier of the HTTP response initially expected using `Playwright_expect_response`.
`value`	No	Data to expect in the body of the HTTP response. If provided, the assertion will fail if this value is not found in the response body.

Implementation Reference

src/tools/browser/response.ts:42-86 (handler)

The AssertResponseTool class containing the execute method that implements the core logic for the playwright_assert_response tool: retrieves the stored response promise, awaits the response, parses JSON body, asserts optional value presence, and returns success/error details.

export class AssertResponseTool extends BrowserToolBase {
  /**
   * Execute the assert response tool
   */
  async execute(args: AssertResponseArgs, context: ToolContext): Promise<ToolResponse> {
    return this.safeExecute(context, async () => {
      if (!args.id) {
        return createErrorResponse("Missing required parameter: id must be provided");
      }

      const responsePromise = responsePromises.get(args.id);
      if (!responsePromise) {
        return createErrorResponse(`No response wait operation found with ID: ${args.id}`);
      }

      try {
        const response = await responsePromise;
        const body = await response.json();

        if (args.value) {
          const bodyStr = JSON.stringify(body);
          if (!bodyStr.includes(args.value)) {
            const messages = [
              `Response body does not contain expected value: ${args.value}`,
              `Actual body: ${bodyStr}`
            ];
            return createErrorResponse(messages.join('\n'));
          }
        }

        const messages = [
          `Response assertion for ID ${args.id} successful`,
          `URL: ${response.url()}`,
          `Status: ${response.status()}`,
          `Body: ${JSON.stringify(body, null, 2)}`
        ];
        return createSuccessResponse(messages.join('\n'));
      } catch (error) {
        return createErrorResponse(`Failed to assert response: ${(error as Error).message}`);
      } finally {
        responsePromises.delete(args.id);
      }
    });
  }
}

src/tools.ts:319-330 (schema)

Tool definition including name, description, and input schema for playwright_assert_response.

{
  name: "playwright_assert_response",
  description: "Wait for and validate a previously initiated HTTP response wait operation.",
  inputSchema: {
    type: "object",
    properties: {
      id: { type: "string", description: "Identifier of the HTTP response initially expected using `Playwright_expect_response`." },
      value: { type: "string", description: "Data to expect in the body of the HTTP response. If provided, the assertion will fail if this value is not found in the response body." }
    },
    required: ["id"],
  },
},

src/toolHandler.ts:511-512 (registration)
Registration in the main tool handler switch statement that dispatches calls to the AssertResponseTool.
```
case "playwright_assert_response":
  return await assertResponseTool.execute(args, context);
```

src/tools/browser/response.ts:21-37 (helper)

Companion ExpectResponseTool that sets up the response promise storage used by assert tool.

export class ExpectResponseTool extends BrowserToolBase {
  /**
   * Execute the expect response tool
   */
  async execute(args: ExpectResponseArgs, context: ToolContext): Promise<ToolResponse> {
    return this.safeExecute(context, async (page) => {
      if (!args.id || !args.url) {
        return createErrorResponse("Missing required parameters: id and url must be provided");
      }

      const responsePromise = page.waitForResponse(args.url);
      responsePromises.set(args.id, responsePromise);

      return createSuccessResponse(`Started waiting for response with ID ${args.id}`);
    });
  }
}

src/tools/browser/response.ts:6-6 (helper)
Global Map storing response promises keyed by ID for coordination between expect and assert tools.
```
const responsePromises = new Map<string, Promise<Response>>();
```

Playwright MCP Server