@oh-my-pi/pi-coding-agent 1.337.0

package/src/core/mcp/tool-bridge.ts

@@ -0,0 +1,148 @@
+/**
+ * MCP to CustomTool bridge.
+ *
+ * Converts MCP tool definitions to CustomTool format for the agent.
+ */
+
+import type { TSchema } from "@sinclair/typebox";
+import type { CustomTool, CustomToolResult } from "../custom-tools/types.js";
+import { callTool } from "./client.js";
+import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types.js";
+
+/** Details included in MCP tool results for rendering */
+export interface MCPToolDetails {
+	/** Server name */
+	serverName: string;
+	/** Original MCP tool name */
+	mcpToolName: string;
+	/** Whether the call resulted in an error */
+	isError?: boolean;
+	/** Raw content from MCP response */
+	rawContent?: MCPContent[];
+}
+
+/**
+ * Convert JSON Schema from MCP to TypeBox-compatible schema.
+ * MCP uses standard JSON Schema, TypeBox uses a compatible subset.
+ */
+function convertSchema(mcpSchema: MCPToolDefinition["inputSchema"]): TSchema {
+	// MCP schemas are JSON Schema objects, TypeBox can use them directly
+	// as long as we ensure the structure is correct
+	return mcpSchema as unknown as TSchema;
+}
+
+/**
+ * Format MCP content for LLM consumption.
+ */
+function formatMCPContent(content: MCPContent[]): string {
+	const parts: string[] = [];
+
+	for (const item of content) {
+		switch (item.type) {
+			case "text":
+				parts.push(item.text);
+				break;
+			case "image":
+				parts.push(`[Image: ${item.mimeType}]`);
+				break;
+			case "resource":
+				if (item.resource.text) {
+					parts.push(`[Resource: ${item.resource.uri}]\n${item.resource.text}`);
+				} else {
+					parts.push(`[Resource: ${item.resource.uri}]`);
+				}
+				break;
+		}
+	}
+
+	return parts.join("\n\n");
+}
+
+/**
+ * Create a unique tool name for an MCP tool.
+ * Prefixes with server name to avoid conflicts.
+ */
+export function createMCPToolName(serverName: string, toolName: string): string {
+	// Use underscore separator since tool names can't have special chars
+	return `mcp_${serverName}_${toolName}`;
+}
+
+/**
+ * Parse an MCP tool name back to server and tool components.
+ */
+export function parseMCPToolName(name: string): { serverName: string; toolName: string } | null {
+	if (!name.startsWith("mcp_")) return null;
+
+	const rest = name.slice(4);
+	const underscoreIdx = rest.indexOf("_");
+	if (underscoreIdx === -1) return null;
+
+	return {
+		serverName: rest.slice(0, underscoreIdx),
+		toolName: rest.slice(underscoreIdx + 1),
+	};
+}
+
+/**
+ * Convert an MCP tool definition to a CustomTool.
+ */
+export function createMCPTool(
+	connection: MCPServerConnection,
+	tool: MCPToolDefinition,
+): CustomTool<TSchema, MCPToolDetails> {
+	const name = createMCPToolName(connection.name, tool.name);
+	const schema = convertSchema(tool.inputSchema);
+
+	return {
+		name,
+		label: `${connection.name}/${tool.name}`,
+		description: tool.description ?? `MCP tool from ${connection.name}`,
+		parameters: schema,
+
+		async execute(_toolCallId, params, _onUpdate, _ctx, _signal): Promise<CustomToolResult<MCPToolDetails>> {
+			try {
+				const result = await callTool(connection, tool.name, params as Record<string, unknown>);
+
+				const text = formatMCPContent(result.content);
+				const details: MCPToolDetails = {
+					serverName: connection.name,
+					mcpToolName: tool.name,
+					isError: result.isError,
+					rawContent: result.content,
+				};
+
+				if (result.isError) {
+					return {
+						content: [{ type: "text", text: `Error: ${text}` }],
+						details,
+					};
+				}
+
+				return {
+					content: [{ type: "text", text }],
+					details,
+				};
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return {
+					content: [{ type: "text", text: `MCP error: ${message}` }],
+					details: {
+						serverName: connection.name,
+						mcpToolName: tool.name,
+						isError: true,
+					},
+				};
+			}
+		},
+	};
+}
+
+/**
+ * Convert all tools from an MCP server to CustomTools.
+ */
+export function createMCPTools(
+	connection: MCPServerConnection,
+	tools: MCPToolDefinition[],
+): CustomTool<TSchema, MCPToolDetails>[] {
+	return tools.map((tool) => createMCPTool(connection, tool));
+}

package/src/core/mcp/transports/http.ts

@@ -0,0 +1,316 @@
+/**
+ * MCP HTTP transport (Streamable HTTP).
+ *
+ * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
+ * Based on MCP spec 2025-03-26.
+ */
+
+import type { JsonRpcResponse, MCPHttpServerConfig, MCPSseServerConfig, MCPTransport } from "../types.js";
+
+/** Generate unique request ID */
+function generateId(): string {
+	return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+/** Parse SSE data line */
+function parseSSELine(line: string): { event?: string; data?: string; id?: string } | null {
+	if (line.startsWith("data:")) {
+		return { data: line.slice(5).trim() };
+	}
+	if (line.startsWith("event:")) {
+		return { event: line.slice(6).trim() };
+	}
+	if (line.startsWith("id:")) {
+		return { id: line.slice(3).trim() };
+	}
+	return null;
+}
+
+/**
+ * HTTP transport for MCP servers.
+ * Uses POST for requests, supports SSE responses.
+ */
+export class HttpTransport implements MCPTransport {
+	private _connected = false;
+	private sessionId: string | null = null;
+	private sseConnection: AbortController | null = null;
+
+	onClose?: () => void;
+	onError?: (error: Error) => void;
+	onNotification?: (method: string, params: unknown) => void;
+
+	constructor(private config: MCPHttpServerConfig | MCPSseServerConfig) {}
+
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	get url(): string {
+		return this.config.url;
+	}
+
+	/**
+	 * Mark transport as connected.
+	 * HTTP doesn't need persistent connection, but we track state.
+	 */
+	async connect(): Promise<void> {
+		if (this._connected) return;
+		this._connected = true;
+	}
+
+	/**
+	 * Start SSE listener for server-initiated messages.
+	 * Optional - only needed if server sends notifications.
+	 */
+	async startSSEListener(): Promise<void> {
+		if (!this._connected) return;
+		if (this.sseConnection) return;
+
+		this.sseConnection = new AbortController();
+		const headers: Record<string, string> = {
+			Accept: "text/event-stream",
+			...this.config.headers,
+		};
+
+		if (this.sessionId) {
+			headers["Mcp-Session-Id"] = this.sessionId;
+		}
+
+		try {
+			const response = await fetch(this.config.url, {
+				method: "GET",
+				headers,
+				signal: this.sseConnection.signal,
+			});
+
+			if (response.status === 405) {
+				// Server doesn't support SSE listening, that's OK
+				this.sseConnection = null;
+				return;
+			}
+
+			if (!response.ok || !response.body) {
+				this.sseConnection = null;
+				return;
+			}
+
+			// Read SSE stream
+			const reader = response.body.getReader();
+			const decoder = new TextDecoder();
+			let buffer = "";
+
+			while (this._connected) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				buffer += decoder.decode(value, { stream: true });
+				const lines = buffer.split("\n");
+				buffer = lines.pop() ?? "";
+
+				for (const line of lines) {
+					const parsed = parseSSELine(line);
+					if (parsed?.data && parsed.data !== "[DONE]") {
+						try {
+							const message = JSON.parse(parsed.data);
+							if ("method" in message && !("id" in message)) {
+								this.onNotification?.(message.method, message.params);
+							}
+						} catch {
+							// Ignore parse errors
+						}
+					}
+				}
+			}
+		} catch (error) {
+			if (error instanceof Error && error.name !== "AbortError") {
+				this.onError?.(error);
+			}
+		} finally {
+			this.sseConnection = null;
+		}
+	}
+
+	async request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T> {
+		if (!this._connected) {
+			throw new Error("Transport not connected");
+		}
+
+		const id = generateId();
+		const body = {
+			jsonrpc: "2.0" as const,
+			id,
+			method,
+			params: params ?? {},
+		};
+
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			...this.config.headers,
+		};
+
+		if (this.sessionId) {
+			headers["Mcp-Session-Id"] = this.sessionId;
+		}
+
+		const response = await fetch(this.config.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+		});
+
+		// Check for session ID in response
+		const newSessionId = response.headers.get("Mcp-Session-Id");
+		if (newSessionId) {
+			this.sessionId = newSessionId;
+		}
+
+		if (!response.ok) {
+			const text = await response.text();
+			throw new Error(`HTTP ${response.status}: ${text}`);
+		}
+
+		const contentType = response.headers.get("Content-Type") ?? "";
+
+		// Handle SSE response
+		if (contentType.includes("text/event-stream")) {
+			return this.parseSSEResponse<T>(response, id);
+		}
+
+		// Handle JSON response
+		const result = (await response.json()) as JsonRpcResponse;
+
+		if (result.error) {
+			throw new Error(`MCP error ${result.error.code}: ${result.error.message}`);
+		}
+
+		return result.result as T;
+	}
+
+	private async parseSSEResponse<T>(response: Response, expectedId: string | number): Promise<T> {
+		if (!response.body) {
+			throw new Error("No response body");
+		}
+
+		const reader = response.body.getReader();
+		const decoder = new TextDecoder();
+		let buffer = "";
+		let result: T | undefined;
+
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split("\n");
+			buffer = lines.pop() ?? "";
+
+			for (const line of lines) {
+				const parsed = parseSSELine(line);
+				if (parsed?.data && parsed.data !== "[DONE]") {
+					try {
+						const message = JSON.parse(parsed.data) as JsonRpcResponse;
+
+						// Handle our response
+						if ("id" in message && message.id === expectedId) {
+							if (message.error) {
+								throw new Error(`MCP error ${message.error.code}: ${message.error.message}`);
+							}
+							result = message.result as T;
+						}
+						// Handle notifications
+						else if ("method" in message && !("id" in message)) {
+							const notification = message as { method: string; params?: unknown };
+							this.onNotification?.(notification.method, notification.params);
+						}
+					} catch (error) {
+						if (error instanceof Error && error.message.startsWith("MCP error")) {
+							throw error;
+						}
+						// Ignore other parse errors
+					}
+				}
+			}
+		}
+
+		if (result === undefined) {
+			throw new Error("No response received");
+		}
+
+		return result;
+	}
+
+	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
+		if (!this._connected) {
+			throw new Error("Transport not connected");
+		}
+
+		const body = {
+			jsonrpc: "2.0" as const,
+			method,
+			params: params ?? {},
+		};
+
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+			...this.config.headers,
+		};
+
+		if (this.sessionId) {
+			headers["Mcp-Session-Id"] = this.sessionId;
+		}
+
+		const response = await fetch(this.config.url, {
+			method: "POST",
+			headers,
+			body: JSON.stringify(body),
+		});
+
+		// 202 Accepted is success for notifications
+		if (!response.ok && response.status !== 202) {
+			const text = await response.text();
+			throw new Error(`HTTP ${response.status}: ${text}`);
+		}
+	}
+
+	async close(): Promise<void> {
+		if (!this._connected) return;
+		this._connected = false;
+
+		// Abort SSE listener
+		if (this.sseConnection) {
+			this.sseConnection.abort();
+			this.sseConnection = null;
+		}
+
+		// Send session termination if we have a session
+		if (this.sessionId) {
+			try {
+				const headers: Record<string, string> = {
+					...this.config.headers,
+					"Mcp-Session-Id": this.sessionId,
+				};
+
+				await fetch(this.config.url, {
+					method: "DELETE",
+					headers,
+				});
+			} catch {
+				// Ignore termination errors
+			}
+			this.sessionId = null;
+		}
+
+		this.onClose?.();
+	}
+}
+
+/**
+ * Create and connect an HTTP transport.
+ */
+export async function createHttpTransport(config: MCPHttpServerConfig | MCPSseServerConfig): Promise<HttpTransport> {
+	const transport = new HttpTransport(config);
+	await transport.connect();
+	return transport;
+}

package/src/core/mcp/transports/index.ts

@@ -0,0 +1,6 @@
+/**
+ * MCP transport exports.
+ */
+
+export { createHttpTransport, HttpTransport } from "./http.js";
+export { createStdioTransport, StdioTransport } from "./stdio.js";

package/src/core/mcp/transports/stdio.ts

@@ -0,0 +1,252 @@
+/**
+ * MCP stdio transport.
+ *
+ * Implements JSON-RPC 2.0 over subprocess stdin/stdout.
+ * Messages are newline-delimited JSON.
+ */
+
+import { type Subprocess, spawn } from "bun";
+import type { JsonRpcResponse, MCPStdioServerConfig, MCPTransport } from "../types.js";
+
+/** Generate unique request ID */
+function generateId(): string {
+	return Math.random().toString(36).slice(2) + Date.now().toString(36);
+}
+
+/**
+ * Stdio transport for MCP servers.
+ * Spawns a subprocess and communicates via stdin/stdout.
+ */
+export class StdioTransport implements MCPTransport {
+	private process: Subprocess<"pipe", "pipe", "pipe"> | null = null;
+	private pendingRequests = new Map<
+		string | number,
+		{
+			resolve: (value: unknown) => void;
+			reject: (error: Error) => void;
+		}
+	>();
+	private buffer = "";
+	private _connected = false;
+	private readLoop: Promise<void> | null = null;
+
+	onClose?: () => void;
+	onError?: (error: Error) => void;
+	onNotification?: (method: string, params: unknown) => void;
+
+	constructor(private config: MCPStdioServerConfig) {}
+
+	get connected(): boolean {
+		return this._connected;
+	}
+
+	/**
+	 * Start the subprocess and begin reading.
+	 */
+	async connect(): Promise<void> {
+		if (this._connected) return;
+
+		const args = this.config.args ?? [];
+		const env = {
+			...process.env,
+			...this.config.env,
+		};
+
+		this.process = spawn({
+			cmd: [this.config.command, ...args],
+			cwd: this.config.cwd ?? process.cwd(),
+			env,
+			stdin: "pipe",
+			stdout: "pipe",
+			stderr: "pipe",
+		});
+
+		this._connected = true;
+
+		// Start reading stdout
+		this.readLoop = this.startReadLoop();
+
+		// Log stderr for debugging
+		this.startStderrLoop();
+	}
+
+	private async startReadLoop(): Promise<void> {
+		if (!this.process?.stdout) return;
+
+		const reader = this.process.stdout.getReader();
+		const decoder = new TextDecoder();
+
+		try {
+			while (this._connected) {
+				const { done, value } = await reader.read();
+				if (done) break;
+
+				this.buffer += decoder.decode(value, { stream: true });
+				this.processBuffer();
+			}
+		} catch (error) {
+			if (this._connected) {
+				this.onError?.(error instanceof Error ? error : new Error(String(error)));
+			}
+		} finally {
+			reader.releaseLock();
+			this.handleClose();
+		}
+	}
+
+	private async startStderrLoop(): Promise<void> {
+		if (!this.process?.stderr) return;
+
+		const reader = this.process.stderr.getReader();
+		const decoder = new TextDecoder();
+
+		try {
+			while (this._connected) {
+				const { done, value } = await reader.read();
+				if (done) break;
+				// Log stderr but don't treat as error - servers use it for logging
+				const text = decoder.decode(value, { stream: true });
+				if (text.trim()) {
+					// Could expose via onStderr callback if needed
+					// For now, silent - MCP spec says clients MAY capture/ignore
+				}
+			}
+		} catch {
+			// Ignore stderr read errors
+		} finally {
+			reader.releaseLock();
+		}
+	}
+
+	private processBuffer(): void {
+		const lines = this.buffer.split("\n");
+		// Keep incomplete last line in buffer
+		this.buffer = lines.pop() ?? "";
+
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+
+			try {
+				const message = JSON.parse(trimmed) as JsonRpcResponse;
+				this.handleMessage(message);
+			} catch {
+				// Ignore malformed lines
+			}
+		}
+	}
+
+	private handleMessage(message: JsonRpcResponse): void {
+		// Check if it's a response (has id)
+		if ("id" in message && message.id !== null) {
+			const pending = this.pendingRequests.get(message.id);
+			if (pending) {
+				this.pendingRequests.delete(message.id);
+				if (message.error) {
+					pending.reject(new Error(`MCP error ${message.error.code}: ${message.error.message}`));
+				} else {
+					pending.resolve(message.result);
+				}
+			}
+		} else if ("method" in message) {
+			// It's a notification from server
+			const notification = message as { method: string; params?: unknown };
+			this.onNotification?.(notification.method, notification.params);
+		}
+	}
+
+	private handleClose(): void {
+		if (!this._connected) return;
+		this._connected = false;
+
+		// Reject all pending requests
+		for (const [, pending] of this.pendingRequests) {
+			pending.reject(new Error("Transport closed"));
+		}
+		this.pendingRequests.clear();
+
+		this.onClose?.();
+	}
+
+	async request<T = unknown>(method: string, params?: Record<string, unknown>): Promise<T> {
+		if (!this._connected || !this.process?.stdin) {
+			throw new Error("Transport not connected");
+		}
+
+		const id = generateId();
+		const request = {
+			jsonrpc: "2.0" as const,
+			id,
+			method,
+			params: params ?? {},
+		};
+
+		return new Promise<T>((resolve, reject) => {
+			this.pendingRequests.set(id, {
+				resolve: resolve as (value: unknown) => void,
+				reject,
+			});
+
+			const message = `${JSON.stringify(request)}\n`;
+			try {
+				// Bun's FileSink has write() method directly
+				this.process!.stdin.write(message);
+				this.process!.stdin.flush();
+			} catch (error: unknown) {
+				this.pendingRequests.delete(id);
+				reject(error);
+			}
+		});
+	}
+
+	async notify(method: string, params?: Record<string, unknown>): Promise<void> {
+		if (!this._connected || !this.process?.stdin) {
+			throw new Error("Transport not connected");
+		}
+
+		const notification = {
+			jsonrpc: "2.0" as const,
+			method,
+			params: params ?? {},
+		};
+
+		const message = `${JSON.stringify(notification)}\n`;
+		// Bun's FileSink has write() method directly
+		this.process.stdin.write(message);
+		this.process.stdin.flush();
+	}
+
+	async close(): Promise<void> {
+		if (!this._connected) return;
+		this._connected = false;
+
+		// Reject pending requests
+		for (const [, pending] of this.pendingRequests) {
+			pending.reject(new Error("Transport closed"));
+		}
+		this.pendingRequests.clear();
+
+		// Kill subprocess
+		if (this.process) {
+			this.process.kill();
+			this.process = null;
+		}
+
+		// Wait for read loop to finish
+		if (this.readLoop) {
+			await this.readLoop.catch(() => {});
+			this.readLoop = null;
+		}
+
+		this.onClose?.();
+	}
+}
+
+/**
+ * Create and connect a stdio transport.
+ */
+export async function createStdioTransport(config: MCPStdioServerConfig): Promise<StdioTransport> {
+	const transport = new StdioTransport(config);
+	await transport.connect();
+	return transport;
+}