playwright_assert_response

Instructions

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>>();