@oh-my-pi/pi-coding-agent 6.2.0 → 6.7.67

package/src/core/hooks/index.ts

@@ -11,6 +11,6 @@ export {
 	type SendMessageHandler,
 } from "./loader";
 export { execCommand, HookRunner, type HookErrorListener } from "./runner";
-export { wrapToolsWithHooks, wrapToolWithHooks } from "./tool-wrapper";
+export { HookToolWrapper, wrapToolsWithHooks, wrapToolWithHooks } from "./tool-wrapper";
 export * from "./types";
 export type { UsageStatistics, ReadonlySessionManager } from "../session-manager";

package/src/core/hooks/tool-wrapper.ts

@@ -7,93 +7,119 @@ import type { HookRunner } from "./runner";
 import type { ToolCallEventResult, ToolResultEventResult } from "./types";
 
 /**
- * Wrap a tool with hook callbacks.
+ * Wraps an AgentTool with hook callbacks for interception.
+ *
+ * Features:
  * - Emits tool_call event before execution (can block)
  * - Emits tool_result event after execution (can modify result)
  * - Forwards onUpdate callback to wrapped tool for progress streaming
  */
-export function wrapToolWithHooks<T>(tool: AgentTool<any, T>, hookRunner: HookRunner): AgentTool<any, T> {
-	return {
-		...tool,
-		execute: async (
-			toolCallId: string,
-			params: Record<string, unknown>,
-			signal?: AbortSignal,
-			onUpdate?: AgentToolUpdateCallback<T>,
-			context?: AgentToolContext,
-		) => {
-			// Emit tool_call event - hooks can block execution
-			// If hook errors/times out, block by default (fail-safe)
-			if (hookRunner.hasHandlers("tool_call")) {
-				try {
-					const callResult = (await hookRunner.emitToolCall({
-						type: "tool_call",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-					})) as ToolCallEventResult | undefined;
+export class HookToolWrapper<T> implements AgentTool<any, T> {
+	name: string;
+	label: string;
+	description: string;
+	parameters: unknown;
+	renderCall?: AgentTool["renderCall"];
+	renderResult?: AgentTool["renderResult"];
+
+	constructor(
+		private tool: AgentTool<any, T>,
+		private hookRunner: HookRunner,
+	) {
+		this.name = tool.name;
+		this.label = tool.label ?? "";
+		this.description = tool.description;
+		this.parameters = tool.parameters;
+		this.renderCall = tool.renderCall;
+		this.renderResult = tool.renderResult;
+	}
+
+	async execute(
+		toolCallId: string,
+		params: Record<string, unknown>,
+		signal?: AbortSignal,
+		onUpdate?: AgentToolUpdateCallback<T>,
+		context?: AgentToolContext,
+	) {
+		// Emit tool_call event - hooks can block execution
+		// If hook errors/times out, block by default (fail-safe)
+		if (this.hookRunner.hasHandlers("tool_call")) {
+			try {
+				const callResult = (await this.hookRunner.emitToolCall({
+					type: "tool_call",
+					toolName: this.tool.name,
+					toolCallId,
+					input: params,
+				})) as ToolCallEventResult | undefined;
 
-					if (callResult?.block) {
-						const reason = callResult.reason || "Tool execution was blocked by a hook";
-						throw new Error(reason);
-					}
-				} catch (err) {
-					// Hook error or block - throw to mark as error
-					if (err instanceof Error) {
-						throw err;
-					}
-					throw new Error(`Hook failed, blocking execution: ${String(err)}`);
+				if (callResult?.block) {
+					const reason = callResult.reason || "Tool execution was blocked by a hook";
+					throw new Error(reason);
 				}
+			} catch (err) {
+				// Hook error or block - throw to mark as error
+				if (err instanceof Error) {
+					throw err;
+				}
+				throw new Error(`Hook failed, blocking execution: ${String(err)}`);
 			}
+		}
 
-			// Execute the actual tool, forwarding onUpdate for progress streaming
-			try {
-				const result = await tool.execute(toolCallId, params, signal, onUpdate, context);
+		// Execute the actual tool, forwarding onUpdate for progress streaming
+		try {
+			const result = await this.tool.execute(toolCallId, params, signal, onUpdate, context);
 
-				// Emit tool_result event - hooks can modify the result
-				if (hookRunner.hasHandlers("tool_result")) {
-					const resultResult = (await hookRunner.emit({
-						type: "tool_result",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-						content: result.content,
-						details: result.details,
-						isError: false,
-					})) as ToolResultEventResult | undefined;
+			// Emit tool_result event - hooks can modify the result
+			if (this.hookRunner.hasHandlers("tool_result")) {
+				const resultResult = (await this.hookRunner.emit({
+					type: "tool_result",
+					toolName: this.tool.name,
+					toolCallId,
+					input: params,
+					content: result.content,
+					details: result.details,
+					isError: false,
+				})) as ToolResultEventResult | undefined;
 
-					// Apply modifications if any
-					if (resultResult) {
-						return {
-							content: resultResult.content ?? result.content,
-							details: (resultResult.details ?? result.details) as T,
-						};
-					}
+				// Apply modifications if any
+				if (resultResult) {
+					return {
+						content: resultResult.content ?? result.content,
+						details: (resultResult.details ?? result.details) as T,
+					};
 				}
+			}
 
-				return result;
-			} catch (err) {
-				// Emit tool_result event for errors so hooks can observe failures
-				if (hookRunner.hasHandlers("tool_result")) {
-					await hookRunner.emit({
-						type: "tool_result",
-						toolName: tool.name,
-						toolCallId,
-						input: params,
-						content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
-						details: undefined,
-						isError: true,
-					});
-				}
-				throw err; // Re-throw original error for agent-loop
+			return result;
+		} catch (err) {
+			// Emit tool_result event for errors so hooks can observe failures
+			if (this.hookRunner.hasHandlers("tool_result")) {
+				await this.hookRunner.emit({
+					type: "tool_result",
+					toolName: this.tool.name,
+					toolCallId,
+					input: params,
+					content: [{ type: "text", text: err instanceof Error ? err.message : String(err) }],
+					details: undefined,
+					isError: true,
+				});
 			}
-		},
-	};
+			throw err; // Re-throw original error for agent-loop
+		}
+	}
 }
 
 /**
  * Wrap all tools with hook callbacks.
  */
 export function wrapToolsWithHooks<T>(tools: AgentTool<any, T>[], hookRunner: HookRunner): AgentTool<any, T>[] {
-	return tools.map((tool) => wrapToolWithHooks(tool, hookRunner));
+	return tools.map((tool) => new HookToolWrapper(tool, hookRunner));
+}
+
+/**
+ * Backward compatibility alias - use HookToolWrapper directly.
+ * @deprecated Use HookToolWrapper class instead
+ */
+export function wrapToolWithHooks<T>(tool: AgentTool<any, T>, hookRunner: HookRunner): AgentTool<any, T> {
+	return new HookToolWrapper(tool, hookRunner);
 }

package/src/core/hooks/types.ts

@@ -21,9 +21,8 @@ import type {
 	SessionEntry,
 	SessionManager,
 } from "../session-manager";
-
-import type { EditToolDetails } from "../tools/edit";
 import type { BashToolDetails, FindToolDetails, GrepToolDetails, LsToolDetails, ReadToolDetails } from "../tools/index";
+import type { EditToolDetails } from "../tools/patch";
 
 // Re-export for backward compatibility
 export type { ExecOptions, ExecResult } from "../exec";

package/src/core/index.ts

@@ -35,6 +35,7 @@ export {
 	MCPManager,
 	type MCPServerConfig,
 	type MCPServerConnection,
+	MCPToolCache,
 	type MCPToolDefinition,
 	type MCPToolDetails,
 	type MCPToolsLoadResult,

package/src/core/mcp/index.ts

@@ -7,7 +7,6 @@
 
 // Client
 export { callTool, connectToServer, disconnectServer, listTools, serverSupportsTools } from "./client";
-
 // Config
 export type { ExaFilterResult, LoadMCPConfigsOptions, LoadMCPConfigsResult } from "./config";
 export {
@@ -17,6 +16,9 @@ export {
 	loadAllMCPConfigs,
 	validateServerConfig,
 } from "./config";
+// JSON-RPC (lightweight HTTP-based MCP calls)
+export type { JsonRpcResponse } from "./json-rpc";
+export { callMCP, parseSSE } from "./json-rpc";
 // Loader (for SDK integration)
 export type { MCPToolsLoadOptions, MCPToolsLoadResult } from "./loader";
 export { discoverAndLoadMCPTools } from "./loader";
@@ -25,7 +27,9 @@ export type { MCPDiscoverOptions, MCPLoadResult } from "./manager";
 export { createMCPManager, MCPManager } from "./manager";
 // Tool bridge
 export type { MCPToolDetails } from "./tool-bridge";
-export { createMCPTool, createMCPToolName, createMCPTools, parseMCPToolName } from "./tool-bridge";
+export { createMCPToolName, DeferredMCPTool, MCPTool, parseMCPToolName } from "./tool-bridge";
+// Tool cache
+export { MCPToolCache } from "./tool-cache";
 // Transports
 export { createHttpTransport, HttpTransport } from "./transports/http";
 export { createStdioTransport, StdioTransport } from "./transports/stdio";

package/src/core/mcp/json-rpc.ts

@@ -0,0 +1,88 @@
+/**
+ * MCP JSON-RPC 2.0 over HTTPS.
+ *
+ * Lightweight utilities for calling MCP servers directly via HTTP
+ * without maintaining persistent connections.
+ */
+
+import { logger } from "../logger";
+
+/** Parse SSE response format (lines starting with "data: ") */
+export function parseSSE(text: string): unknown {
+	const lines = text.split("\n");
+	for (const line of lines) {
+		if (line.startsWith("data: ")) {
+			const data = line.slice(6).trim();
+			if (data === "[DONE]") continue;
+			try {
+				return JSON.parse(data);
+			} catch {
+				// Try next line
+			}
+		}
+	}
+	// Fallback: try parsing entire response as JSON
+	try {
+		return JSON.parse(text);
+	} catch {
+		return null;
+	}
+}
+
+/** JSON-RPC 2.0 response structure */
+export interface JsonRpcResponse<T = unknown> {
+	jsonrpc: "2.0";
+	id: string | number;
+	result?: T;
+	error?: {
+		code: number;
+		message: string;
+		data?: unknown;
+	};
+}
+
+/**
+ * Call an MCP server with JSON-RPC 2.0 over HTTPS.
+ *
+ * @param url - Full MCP server URL (including any query parameters)
+ * @param method - JSON-RPC method name (e.g., "tools/list", "tools/call")
+ * @param params - Method parameters
+ * @returns Parsed JSON-RPC response
+ */
+export async function callMCP<T = unknown>(
+	url: string,
+	method: string,
+	params?: Record<string, unknown>,
+): Promise<JsonRpcResponse<T>> {
+	const body = {
+		jsonrpc: "2.0",
+		id: Math.random().toString(36).slice(2),
+		method,
+		params: params ?? {},
+	};
+
+	const response = await fetch(url, {
+		method: "POST",
+		headers: {
+			"Content-Type": "application/json",
+			Accept: "application/json, text/event-stream",
+		},
+		body: JSON.stringify(body),
+	});
+
+	if (!response.ok) {
+		const errorMsg = `MCP request failed: ${response.status} ${response.statusText}`;
+		logger.error(errorMsg, { url, method, params });
+		throw new Error(errorMsg);
+	}
+
+	const text = await response.text();
+	const result = parseSSE(text) as JsonRpcResponse<T> | null;
+
+	if (!result) {
+		logger.error("Failed to parse MCP response", { url, method, responseText: text.slice(0, 500) });
+		throw new Error("Failed to parse MCP response");
+	}
+
+	return result;
+}

package/src/core/mcp/loader.ts

@@ -4,9 +4,12 @@
  * Integrates MCP tool discovery with the custom tools system.
  */
 
+import { AgentStorage } from "../agent-storage";
 import type { LoadedCustomTool } from "../custom-tools/types";
+import { logger } from "../logger";
 import { type MCPLoadResult, MCPManager } from "./manager";
 import { parseMCPToolName } from "./tool-bridge";
+import { MCPToolCache } from "./tool-cache";
 
 /** Result from loading MCP tools */
 export interface MCPToolsLoadResult {
@@ -30,6 +33,19 @@ export interface MCPToolsLoadOptions {
 	enableProjectConfig?: boolean;
 	/** Whether to filter out Exa MCP servers (default: true) */
 	filterExa?: boolean;
+	/** SQLite storage for MCP tool cache (null disables cache) */
+	cacheStorage?: AgentStorage | null;
+}
+
+function resolveToolCache(storage: AgentStorage | null | undefined): MCPToolCache | null {
+	if (storage === null) return null;
+	try {
+		const resolved = storage ?? AgentStorage.open();
+		return new MCPToolCache(resolved);
+	} catch (error) {
+		logger.warn("MCP tool cache unavailable", { error: String(error) });
+		return null;
+	}
 }
 
 /**
@@ -40,7 +56,8 @@ export interface MCPToolsLoadOptions {
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoadOptions): Promise<MCPToolsLoadResult> {
-	const manager = new MCPManager(cwd);
+	const toolCache = resolveToolCache(options?.cacheStorage);
+	const manager = new MCPManager(cwd, toolCache);
 
 	let result: MCPLoadResult;
 	try {
@@ -69,12 +86,13 @@ export async function discoverAndLoadMCPTools(cwd: string, options?: MCPToolsLoa
 
 		// Get provider info from manager's connection if available
 		const connection = serverName ? manager.getConnection(serverName) : undefined;
-		const provider = connection?._source?.provider;
+		const source = serverName ? manager.getSource(serverName) : undefined;
+		const providerName =
+			connection?._source?.providerName ?? source?.providerName ?? connection?._source?.provider ?? source?.provider;
 
 		// Format path with provider info if available
 		// Format: "mcp:serverName via providerName" (e.g., "mcp:agentx via Claude Code")
-		const path =
-			provider && serverName ? `mcp:${serverName} via ${connection._source!.providerName}` : `mcp:${tool.name}`;
+		const path = serverName && providerName ? `mcp:${serverName} via ${providerName}` : `mcp:${tool.name}`;
 
 		return {
 			path,