Luigit
repositories / pi-ext

pi-ext

bugabingas pi extensions

owned by admin

extensions/web/mcp.ts

Raw
import { readBoundedText } from "./http-body.js";

/** Single-call MCP sessions shared by search providers, not a general MCP client. */
export interface McpToolResult {
	isError?: boolean;
	content?: Array<{ type?: string; text?: string }>;
}

export class McpError extends Error {
	readonly status: number;
	readonly code?: number | string | undefined;
	readonly response?: Response | undefined;

	constructor(
		message: string,
		status: number,
		code?: number | string,
		response?: Response,
	) {
		super(message);
		this.name = "McpError";
		this.status = status;
		this.code = code;
		this.response = response;
	}
}

interface RpcMessage {
	id?: number;
	result?: unknown;
	error?: { code?: number | string; message?: string };
}

function parseMessage(text: string, id: number, status: number): RpcMessage {
	let messages: RpcMessage[];
	try {
		messages = text.trimStart().startsWith("{")
			? [JSON.parse(text)]
			: text
					.replace(/\r\n?/g, "\n")
					.split("\n\n")
					.flatMap((event) => {
						const data = event
							.split("\n")
							.filter((line) => line.startsWith("data:"))
							.map((line) => line.slice(5).trimStart())
							.join("\n");
						return data && data !== "[DONE]" ? [JSON.parse(data)] : [];
					});
	} catch {
		throw new McpError(`Malformed MCP response: ${text.slice(0, 500)}`, status);
	}
	const message = messages.find((entry) => entry?.id === id);
	if (!message) throw new McpError("no matching MCP response", status);
	if (message.error)
		throw new McpError(
			message.error.message ?? "request failed",
			status,
			message.error.code,
		);
	return message;
}

export async function callMcpTool(options: {
	url: string;
	protocolVersion: string;
	headers?: Record<string, string>;
	signal: AbortSignal;
	name: string;
	arguments: Record<string, unknown>;
}): Promise<McpToolResult> {
	let sessionId: string | undefined;
	let protocolVersion = options.protocolVersion;
	async function post(
		method: string,
		params: object,
		id?: number,
	): Promise<unknown> {
		options.signal.throwIfAborted();
		const response = await fetch(options.url, {
			method: "POST",
			redirect: "error",
			headers: {
				...options.headers,
				"Content-Type": "application/json",
				Accept: "application/json, text/event-stream",
				"MCP-Protocol-Version": protocolVersion,
				...(sessionId ? { "mcp-session-id": sessionId } : {}),
			},
			body: JSON.stringify({
				jsonrpc: "2.0",
				...(id === undefined ? {} : { id }),
				method,
				params,
			}),
			signal: options.signal,
		});
		if (!response.ok) {
			const text = await readBoundedText(response, undefined, options.signal);
			throw new McpError(
				`HTTP ${response.status}: ${response.statusText}`,
				response.status,
				undefined,
				new Response(text, {
					status: response.status,
					statusText: response.statusText,
					headers: response.headers,
				}),
			);
		}
		sessionId = response.headers.get("mcp-session-id") ?? sessionId;
		const text = await readBoundedText(response, undefined, options.signal);
		if (id === undefined) return undefined;
		const result = parseMessage(text, id, response.status).result;
		if (method === "initialize") {
			const initialized = result as { protocolVersion?: unknown } | undefined;
			if (
				typeof initialized?.protocolVersion !== "string" ||
				!initialized.protocolVersion
			) {
				throw new McpError("MCP initialization failed", response.status);
			}
			protocolVersion = initialized.protocolVersion;
		}
		return result;
	}

	await post(
		"initialize",
		{
			protocolVersion,
			capabilities: {},
			clientInfo: { name: "pi-web-extension", version: "0.1.0" },
		},
		1,
	);
	await post("notifications/initialized", {});
	const result = await post(
		"tools/call",
		{ name: options.name, arguments: options.arguments },
		2,
	);
	if (!result || typeof result !== "object" || Array.isArray(result)) {
		throw new McpError("MCP tool returned an invalid result", 200);
	}
	return result as McpToolResult;
}