@yofriadi/pi-mcp 0.1.0

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

@@ -0,0 +1,325 @@
+import type { ExtensionAPI, ToolDefinition } from "@mariozechner/pi-coding-agent";
+import type { McpManager, McpManagerState } from "../runtime/mcp-manager";
+
+const BRIDGED_TOOL_NAME_MAX_LENGTH = 64;
+const FALLBACK_PARAMETERS_SCHEMA = {
+	type: "object",
+	additionalProperties: true,
+};
+
+interface McpDiscoveredTool {
+	name: string;
+	description?: string;
+	inputSchema?: Record<string, unknown>;
+}
+
+export interface McpBridgedToolRegistration {
+	key: string;
+	server: string;
+	mcpToolName: string;
+	registeredName: string;
+	description?: string;
+}
+
+export interface McpToolBridgeSyncResult {
+	added: number;
+	total: number;
+	addedTools: string[];
+	failed: Array<{ key: string; reason: string }>;
+}
+
+export interface McpToolBridge {
+	sync(): McpToolBridgeSyncResult;
+	getRegistrations(): McpBridgedToolRegistration[];
+}
+
+export function createMcpToolBridge(pi: ExtensionAPI, manager: McpManager): McpToolBridge {
+	const registrationsByKey = new Map<string, McpBridgedToolRegistration>();
+	const usedToolNames = new Set<string>(["mcp_call", "mcp_list_tools"]);
+
+	return {
+		sync(): McpToolBridgeSyncResult {
+			const state = manager.getState();
+			const addedTools: string[] = [];
+			const failed: Array<{ key: string; reason: string }> = [];
+
+			for (const [serverName, toolListState] of Object.entries(state.toolLists)) {
+				if (toolListState.state !== "ready") {
+					continue;
+				}
+
+				const discoveredTools = extractDiscoveredTools(toolListState.tools);
+				for (const discovered of discoveredTools) {
+					const key = createRegistrationKey(serverName, discovered.name);
+					if (registrationsByKey.has(key)) {
+						continue;
+					}
+
+					try {
+						const registeredName = createStableBridgedToolName(serverName, discovered.name, usedToolNames);
+						const toolDefinition = createBridgedToolDefinition({
+							manager,
+							serverName,
+							discovered,
+							registeredName,
+						});
+						pi.registerTool(toolDefinition);
+
+						const registration: McpBridgedToolRegistration = {
+							key,
+							server: serverName,
+							mcpToolName: discovered.name,
+							registeredName,
+							description: discovered.description,
+						};
+						registrationsByKey.set(key, registration);
+						usedToolNames.add(registeredName);
+						addedTools.push(registeredName);
+					} catch (error) {
+						failed.push({
+							key,
+							reason: formatError(error),
+						});
+					}
+				}
+			}
+
+			return {
+				added: addedTools.length,
+				total: registrationsByKey.size,
+				addedTools,
+				failed,
+			};
+		},
+
+		getRegistrations(): McpBridgedToolRegistration[] {
+			return [...registrationsByKey.values()];
+		},
+	};
+}
+
+export function createStableBridgedToolName(
+	serverName: string,
+	mcpToolName: string,
+	usedToolNames: Set<string>,
+): string {
+	const base = `mcp_${sanitizeToolNameSegment(serverName)}_${sanitizeToolNameSegment(mcpToolName)}`;
+	const hashInput = `${serverName}::${mcpToolName}`;
+	let candidate = trimToolName(base);
+
+	if (!usedToolNames.has(candidate)) {
+		return candidate;
+	}
+
+	const hash = shortHash(hashInput);
+	candidate = trimToolName(`${base}_${hash}`);
+	if (!usedToolNames.has(candidate)) {
+		return candidate;
+	}
+
+	let counter = 2;
+	while (usedToolNames.has(candidate)) {
+		candidate = trimToolName(`${base}_${hash}_${counter}`);
+		counter += 1;
+	}
+	return candidate;
+}
+
+export function normalizeMcpInputSchema(inputSchema: unknown): Record<string, unknown> {
+	if (!isObject(inputSchema)) {
+		return { ...FALLBACK_PARAMETERS_SCHEMA };
+	}
+
+	const normalized = cloneJsonObject(inputSchema);
+	if (!normalized) {
+		return { ...FALLBACK_PARAMETERS_SCHEMA };
+	}
+
+	const hasObjectSignals =
+		normalized.type === "object" ||
+		isObject(normalized.properties) ||
+		Array.isArray(normalized.required) ||
+		isObject(normalized.patternProperties);
+
+	if (!hasObjectSignals) {
+		return { ...FALLBACK_PARAMETERS_SCHEMA };
+	}
+
+	if (normalized.type === undefined) {
+		normalized.type = "object";
+	}
+
+	if (normalized.additionalProperties === undefined) {
+		normalized.additionalProperties = true;
+	}
+
+	return normalized;
+}
+
+function createBridgedToolDefinition(input: {
+	manager: McpManager;
+	serverName: string;
+	discovered: McpDiscoveredTool;
+	registeredName: string;
+}): ToolDefinition {
+	const { manager, serverName, discovered, registeredName } = input;
+	const schema = normalizeMcpInputSchema(discovered.inputSchema);
+
+	return {
+		name: registeredName,
+		label: `MCP ${discovered.name}`,
+		description:
+			discovered.description?.trim() || `Bridged MCP tool "${discovered.name}" from server "${serverName}".`,
+		parameters: schema as any,
+		async execute(_toolCallId, params, signal) {
+			const argumentsPayload = normalizeToolArguments(params);
+			try {
+				const result = await manager.callTool(serverName, discovered.name, argumentsPayload, {
+					timeoutMs: 30_000,
+					signal,
+				});
+				return {
+					content: [
+						{
+							type: "text",
+							text: formatJsonResult(`MCP ${serverName}.${discovered.name}`, result),
+						},
+					],
+					details: {
+						server: serverName,
+						mcpToolName: discovered.name,
+						registeredToolName: registeredName,
+						result,
+					},
+				};
+			} catch (error) {
+				return {
+					isError: true,
+					content: [
+						{
+							type: "text",
+							text: `MCP tool call failed (${serverName}.${discovered.name}): ${formatError(error)}`,
+						},
+					],
+					details: {
+						server: serverName,
+						mcpToolName: discovered.name,
+						registeredToolName: registeredName,
+						error: formatError(error),
+					},
+				};
+			}
+		},
+	};
+}
+
+function extractDiscoveredTools(tools: unknown[]): McpDiscoveredTool[] {
+	const discovered: McpDiscoveredTool[] = [];
+	for (const entry of tools) {
+		if (!isObject(entry)) {
+			continue;
+		}
+
+		const name = typeof entry.name === "string" ? entry.name.trim() : "";
+		if (!name) {
+			continue;
+		}
+
+		const description = typeof entry.description === "string" ? entry.description.trim() : undefined;
+		const inputSchema = normalizeInputSchemaField(entry);
+		discovered.push({
+			name,
+			description,
+			inputSchema,
+		});
+	}
+	return discovered;
+}
+
+function normalizeInputSchemaField(entry: Record<string, unknown>): Record<string, unknown> | undefined {
+	const candidates = [entry.inputSchema, entry.input_schema, entry.parameters];
+	for (const candidate of candidates) {
+		if (isObject(candidate)) {
+			return candidate;
+		}
+	}
+	return undefined;
+}
+
+function normalizeToolArguments(params: unknown): Record<string, unknown> {
+	if (isObject(params)) {
+		return params;
+	}
+	if (params === undefined || params === null) {
+		return {};
+	}
+	return { value: params };
+}
+
+function createRegistrationKey(serverName: string, mcpToolName: string): string {
+	return `${serverName}::${mcpToolName}`;
+}
+
+function sanitizeToolNameSegment(value: string): string {
+	const sanitized = value
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "_")
+		.replace(/^_+|_+$/g, "");
+	if (!sanitized) {
+		return "tool";
+	}
+	return sanitized;
+}
+
+function trimToolName(value: string): string {
+	if (value.length <= BRIDGED_TOOL_NAME_MAX_LENGTH) {
+		return value;
+	}
+	return value.slice(0, BRIDGED_TOOL_NAME_MAX_LENGTH);
+}
+
+function shortHash(value: string): string {
+	let hash = 2166136261;
+	for (let index = 0; index < value.length; index += 1) {
+		hash ^= value.charCodeAt(index);
+		hash = Math.imul(hash, 16777619);
+	}
+	return (hash >>> 0).toString(36);
+}
+
+function cloneJsonObject(value: Record<string, unknown>): Record<string, unknown> | undefined {
+	try {
+		const cloned = JSON.parse(JSON.stringify(value));
+		return isObject(cloned) ? cloned : undefined;
+	} catch {
+		return undefined;
+	}
+}
+
+function isObject(value: unknown): value is Record<string, unknown> {
+	return !!value && typeof value === "object" && !Array.isArray(value);
+}
+
+function formatJsonResult(prefix: string, payload: unknown): string {
+	return `${prefix}:\n${JSON.stringify(payload, null, 2)}`;
+}
+
+function formatError(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}
+
+export function getMcpBridgeToolSummary(state: McpManagerState): { readyServers: number; discoveredTools: number } {
+	let readyServers = 0;
+	let discoveredTools = 0;
+	for (const toolListState of Object.values(state.toolLists)) {
+		if (toolListState.state !== "ready") {
+			continue;
+		}
+		readyServers += 1;
+		discoveredTools += extractDiscoveredTools(toolListState.tools).length;
+	}
+	return { readyServers, discoveredTools };
+}

package/src/tools/mcp-tools.ts

@@ -0,0 +1,257 @@
+import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import { Type } from "@sinclair/typebox";
+import type { McpManager } from "../runtime/mcp-manager";
+import { createMcpToolBridge, getMcpBridgeToolSummary, type McpToolBridge } from "./mcp-tool-bridge";
+
+const MCP_CALL_PARAMS = Type.Object({
+	server: Type.String({ description: "Configured MCP server name" }),
+	method: Type.String({ description: "JSON-RPC method name" }),
+	params: Type.Optional(Type.Unknown({ description: "JSON-RPC params payload" })),
+	timeoutMs: Type.Optional(Type.Number({ minimum: 1_000, maximum: 120_000 })),
+});
+
+const MCP_LIST_TOOLS_PARAMS = Type.Object({
+	server: Type.String({ description: "Configured MCP server name" }),
+	timeoutMs: Type.Optional(Type.Number({ minimum: 1_000, maximum: 120_000 })),
+});
+
+export function registerMcpTools(pi: ExtensionAPI, manager: McpManager): McpToolBridge {
+	const bridge = createMcpToolBridge(pi, manager);
+
+	pi.registerCommand("mcp-status", {
+		description: "Show status information for configured MCP servers",
+		handler: async (_args, ctx) => {
+			const state = manager.getState();
+			const config = state.config;
+			const status = state.runtime;
+			const bridgeSummary = getMcpBridgeToolSummary(state);
+			const lines = [
+				`MCP manager: ${state.lifecycle} (${state.reason})`,
+				`MCP state: ${status.state}`,
+				`Reason: ${status.reason}`,
+				`Configured servers: ${status.configuredServers}`,
+				`Active servers: ${status.activeServers}`,
+				`Discovered MCP tools: ${bridgeSummary.discoveredTools} across ${bridgeSummary.readyServers} ready server(s)`,
+				`Bridged MCP tools: ${bridge.getRegistrations().length}`,
+			];
+
+			if (state.session) {
+				const sessionLabel = state.session.sessionId ?? "<none>";
+				const activeLabel = state.session.isActive ? "active" : "inactive";
+				lines.push(`Session: ${sessionLabel} (${activeLabel}, reloads: ${state.session.reloadCount})`);
+			}
+
+			if (status.servers.length > 0) {
+				lines.push("Servers:");
+				for (const server of status.servers) {
+					const location =
+						server.transport === "http"
+							? (server.url ?? "<missing url>")
+							: (server.command?.join(" ") ?? "<missing command>");
+					lines.push(`- ${server.name}: ${server.state} (${server.transport}) ${location} -> ${server.reason}`);
+				}
+			}
+
+			const toolLists = Object.values(state.toolLists);
+			if (toolLists.length > 0) {
+				lines.push("Tool list cache:");
+				for (const entry of toolLists) {
+					lines.push(`- ${entry.server}: ${entry.state} (${entry.tools.length} tool(s)) -> ${entry.reason}`);
+				}
+			}
+
+			if (config.diagnostics.length > 0) {
+				lines.push("Diagnostics:");
+				for (const diagnostic of config.diagnostics) {
+					lines.push(`- ${diagnostic.level} ${diagnostic.code}: ${diagnostic.message}`);
+				}
+			}
+
+			ctx.ui.notify(lines.join("\n"), status.state === "error" ? "warning" : "info");
+		},
+	});
+
+	pi.registerCommand("mcp-tools", {
+		description: "List tools exposed by a configured MCP server (/mcp-tools <server>)",
+		handler: async (args, ctx) => {
+			const server = args.trim();
+			if (!server) {
+				ctx.ui.notify("Usage: /mcp-tools <server>", "warning");
+				return;
+			}
+
+			try {
+				const result = await manager.listTools(server, { timeoutMs: 20_000 });
+				ctx.ui.notify(formatJsonResult(`MCP tools for ${server}`, result), "info");
+			} catch (error) {
+				ctx.ui.notify(`Failed to list MCP tools for ${server}: ${formatError(error)}`, "warning");
+			}
+		},
+	});
+
+	pi.registerCommand("mcp-call", {
+		description: "Call an MCP method (/mcp-call <server> <method> [jsonParams])",
+		handler: async (args, ctx) => {
+			const parsed = parseCommandArgs(args);
+			if (!parsed) {
+				ctx.ui.notify("Usage: /mcp-call <server> <method> [jsonParams]", "warning");
+				return;
+			}
+
+			try {
+				const result = await manager.request(parsed.server, parsed.method, parsed.params ?? {}, {
+					timeoutMs: 25_000,
+				});
+				ctx.ui.notify(formatJsonResult(`MCP result ${parsed.server}.${parsed.method}`, result), "info");
+			} catch (error) {
+				ctx.ui.notify(`MCP request failed: ${formatError(error)}`, "warning");
+			}
+		},
+	});
+
+	pi.registerTool({
+		name: "mcp_call",
+		label: "MCP call",
+		description: "Call a JSON-RPC method on a configured MCP server",
+		parameters: MCP_CALL_PARAMS,
+		async execute(_toolCallId, params, signal) {
+			try {
+				const result = await manager.request(params.server, params.method, params.params ?? {}, {
+					timeoutMs: params.timeoutMs,
+					signal,
+				});
+				return {
+					content: [
+						{
+							type: "text",
+							text: formatJsonResult(`MCP ${params.server}.${params.method}`, result),
+						},
+					],
+					details: {
+						server: params.server,
+						method: params.method,
+						result,
+					},
+				};
+			} catch (error) {
+				return {
+					isError: true,
+					content: [
+						{
+							type: "text",
+							text: `MCP request failed: ${formatError(error)}`,
+						},
+					],
+					details: {
+						server: params.server,
+						method: params.method,
+						error: formatError(error),
+					},
+				};
+			}
+		},
+	});
+
+	pi.registerTool({
+		name: "mcp_list_tools",
+		label: "MCP list tools",
+		description: "List tools exposed by a configured MCP server",
+		parameters: MCP_LIST_TOOLS_PARAMS,
+		async execute(_toolCallId, params, signal) {
+			try {
+				const result = await manager.listTools(params.server, {
+					timeoutMs: params.timeoutMs,
+					signal,
+				});
+				return {
+					content: [
+						{
+							type: "text",
+							text: formatJsonResult(`MCP tools ${params.server}`, result),
+						},
+					],
+					details: {
+						server: params.server,
+						result,
+					},
+				};
+			} catch (error) {
+				return {
+					isError: true,
+					content: [
+						{
+							type: "text",
+							text: `Failed to list MCP tools for ${params.server}: ${formatError(error)}`,
+						},
+					],
+					details: {
+						server: params.server,
+						error: formatError(error),
+					},
+				};
+			}
+		},
+	});
+
+	return bridge;
+}
+
+function parseCommandArgs(input: string): { server: string; method: string; params?: unknown } | undefined {
+	const trimmed = input.trim();
+	if (!trimmed) {
+		return undefined;
+	}
+
+	const firstSpace = trimmed.indexOf(" ");
+	if (firstSpace === -1) {
+		return undefined;
+	}
+	const server = trimmed.slice(0, firstSpace).trim();
+	const rest = trimmed.slice(firstSpace + 1).trim();
+	if (!server || !rest) {
+		return undefined;
+	}
+
+	const secondSpace = rest.indexOf(" ");
+	if (secondSpace === -1) {
+		return {
+			server,
+			method: rest,
+		};
+	}
+
+	const method = rest.slice(0, secondSpace).trim();
+	const paramsRaw = rest.slice(secondSpace + 1).trim();
+	if (!method) {
+		return undefined;
+	}
+
+	if (!paramsRaw) {
+		return { server, method };
+	}
+
+	try {
+		return {
+			server,
+			method,
+			params: JSON.parse(paramsRaw),
+		};
+	} catch {
+		return {
+			server,
+			method,
+			params: paramsRaw,
+		};
+	}
+}
+
+function formatJsonResult(prefix: string, payload: unknown): string {
+	return `${prefix}:\n${JSON.stringify(payload, null, 2)}`;
+}
+
+function formatError(error: unknown): string {
+	if (error instanceof Error) {
+		return error.message;
+	}
+	return String(error);
+}