Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/web/__tests__/mcp.test.ts

Raw
import { afterEach, describe, expect, it, vi } from "vitest";
import { MAX_SEARCH_RESPONSE_BYTES } from "../constants.js";
import { callMcpTool } from "../mcp.js";

const result = { content: [{ type: "text", text: "found" }] };
const options = () => ({
	url: "https://provider.test/mcp",
	protocolVersion: "2025-03-26",
	headers: { Authorization: "Bearer test" },
	signal: new AbortController().signal,
	name: "search",
	arguments: { query: "example" },
});

function provider(body: string | ReadableStream<Uint8Array>, headers = {}) {
	const fetch = vi
		.fn()
		.mockResolvedValueOnce(
			new Response(
				JSON.stringify({ id: 1, result: { protocolVersion: "2025-06-18" } }),
				{ headers: { "mcp-session-id": "session" } },
			),
		)
		.mockResolvedValueOnce(new Response(null, { status: 202 }))
		.mockResolvedValueOnce(new Response(body, { headers }));
	vi.stubGlobal("fetch", fetch);
	return fetch;
}

afterEach(() => vi.unstubAllGlobals());

describe("MCP provider calls", () => {
	it.each(["\r", "\n", "\r\n"])(
		"accepts %j SSE lines, multiple events, multiline data and DONE",
		async (newline) => {
			const body = [
				": keepalive",
				"",
				'data: {"method":"notifications/progress"}',
				"",
				'data: {"id":999,"result":{}}',
				"",
				"event: message",
				'data: {"id":2,',
				`data: "result":${JSON.stringify(result)}}`,
				"",
				"data: [DONE]",
				"",
				"",
			].join(newline);
			// Deliberately split every CRLF and JSON token across transport chunks.
			const bytes = new TextEncoder().encode(body);
			let offset = 0;
			const fetch = provider(
				new ReadableStream({
					pull(controller) {
						if (offset === bytes.length) controller.close();
						else controller.enqueue(bytes.subarray(offset, ++offset));
					},
				}),
			);
			expect(await callMcpTool(options())).toEqual(result);
			const requests = fetch.mock.calls.map(([, init]) => ({
				...init,
				body: JSON.parse(init.body),
			}));
			expect(requests.map((request) => request.body.method)).toEqual([
				"initialize",
				"notifications/initialized",
				"tools/call",
			]);
			expect(requests[2]).toMatchObject({
				redirect: "error",
				headers: {
					Authorization: "Bearer test",
					"mcp-session-id": "session",
					"MCP-Protocol-Version": "2025-06-18",
				},
				body: {
					id: 2,
					params: { name: "search", arguments: { query: "example" } },
				},
			});
		},
	);

	it("accepts mixed SSE line endings and plain JSON", async () => {
		provider(
			`: ping\r\n\rdata: [DONE]\n\ndata: ${JSON.stringify({ id: 2, result })}\r\n\r\n`,
		);
		expect(await callMcpTool(options())).toEqual(result);
		provider(JSON.stringify({ id: 2, result }));
		expect(await callMcpTool(options())).toEqual(result);
	});

	it.each([
		["data: invalid\r\r", "Malformed MCP response"],
		[
			'data: {"id":99,"result":{}}\r\rdata: [DONE]\r\r',
			"no matching MCP response",
		],
		[
			'data: {"id":2,"error":{"code":-32602,"message":"bad query"}}\r\r',
			"bad query",
		],
	])("preserves malformed, unmatched and RPC errors", async (body, message) => {
		provider(body);
		await expect(callMcpTool(options())).rejects.toThrow(message);
	});

	it("preserves HTTP errors", async () => {
		const fetch = provider("");
		fetch
			.mockReset()
			.mockResolvedValue(new Response("denied", { status: 403 }));
		await expect(callMcpTool(options())).rejects.toMatchObject({
			name: "McpError",
			status: 403,
		});
	});

	it.each([true, false])(
		"bounds SSE responses with content-length=%s",
		async (declared) => {
			const cancel = vi.fn();
			const chunk = new Uint8Array(64 * 1024).fill(32);
			provider(
				new ReadableStream(
					{
						pull(controller) {
							controller.enqueue(chunk);
						},
						cancel,
					},
					{ highWaterMark: 0 },
				),
				declared
					? {
							"content-length": String(MAX_SEARCH_RESPONSE_BYTES + 1),
						}
					: {},
			);
			await expect(callMcpTool(options())).rejects.toThrow(
				"Response exceeds search response limit",
			);
			expect(cancel).toHaveBeenCalledOnce();
		},
	);

	it("cancels a pending SSE read on abort", async () => {
		const abort = new AbortController();
		const cancel = vi.fn();
		let reading!: () => void;
		const started = new Promise<void>((resolve) => {
			reading = resolve;
		});
		provider(
			new ReadableStream(
				{
					pull() {
						reading();
					},
					cancel,
				},
				{ highWaterMark: 0 },
			),
		);
		const pending = callMcpTool({ ...options(), signal: abort.signal });
		await started;
		abort.abort();
		await expect(pending).rejects.toMatchObject({ name: "AbortError" });
		expect(cancel).toHaveBeenCalledOnce();
	});
});