@oh-my-pi/pi-coding-agent 13.13.2 → 13.14.0

package/CHANGELOG.md

@@ -2,6 +2,32 @@
 
 ## [Unreleased]
 
+## [13.14.0] - 2026-03-20
+
+### Added
+
+- Auto-reconnect MCP servers on connection loss with proactive SSE stream monitoring and retry backoff
+- Tool-level reconnect: retriable connection errors (ECONNREFUSED, ECONNRESET, stale session 404/502/503) trigger automatic reconnection and single retry
+- `/mcp reconnect <name>` command for manual server recovery after extended outages
+
+### Changed
+
+- Extended transport reconnect handling to all transport types (not just HTTP/SSE), ensuring stdio and other transports trigger automatic reconnection on connection loss
+- Improved reconnect robustness by aborting retry attempts when MCP server configuration changes during reconnection sequence
+- Updated explore agent thinking level from off to med for improved reasoning
+- Simplified explore agent output schema: consolidated file references into single `ref` field with optional line ranges instead of separate `path`, `line_start`, `line_end` fields
+- Removed `code` section from explore agent output (critical code excerpts no longer extracted)
+- Removed `dependencies` section from explore agent output
+- Removed `risks` section from explore agent output
+- Removed `start_here` section from explore agent output
+
+### Fixed
+
+- Fixed reconnect retry loop continuing after configuration changes by checking epoch before each reconnection attempt
+- `roots/list` timeout on MCP server initialization: `connectToServer` now always installs a default handler for `ping` and `roots/list`
+- Fixed resumed GitHub Copilot conversations that could fail with `401 input item does not belong to this connection` on the first follow-up after process restart ([#488](https://github.com/can1357/oh-my-pi/issues/488))
+- Fixed STT Alt+H mic cursor rendering to measure the actual microphone glyph width, preventing one-column TUI overflow crashes when the active symbol preset uses a wide icon ([#484](https://github.com/can1357/oh-my-pi/issues/484))
+
 ## [13.13.2] - 2026-03-18
 
 ### Added

package/package.json

@@ -1,7 +1,7 @@
 {
 	"type": "module",
 	"name": "@oh-my-pi/pi-coding-agent",
-	"version": "13.13.2",
+	"version": "13.14.0",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"homepage": "https://github.com/can1357/oh-my-pi",
 	"author": "Can Boluk",
@@ -41,12 +41,12 @@
 	},
 	"dependencies": {
 		"@mozilla/readability": "^0.6",
-		"@oh-my-pi/omp-stats": "13.13.2",
-		"@oh-my-pi/pi-agent-core": "13.13.2",
-		"@oh-my-pi/pi-ai": "13.13.2",
-		"@oh-my-pi/pi-natives": "13.13.2",
-		"@oh-my-pi/pi-tui": "13.13.2",
-		"@oh-my-pi/pi-utils": "13.13.2",
+		"@oh-my-pi/omp-stats": "13.14.0",
+		"@oh-my-pi/pi-agent-core": "13.14.0",
+		"@oh-my-pi/pi-ai": "13.14.0",
+		"@oh-my-pi/pi-natives": "13.14.0",
+		"@oh-my-pi/pi-tui": "13.14.0",
+		"@oh-my-pi/pi-utils": "13.14.0",
 		"@sinclair/typebox": "^0.34",
 		"@xterm/headless": "^6.0",
 		"ajv": "^8.18",

package/src/config/model-registry.ts

@@ -1440,10 +1440,17 @@ export class ModelRegistry {
 	}
 	#applyHardcodedModelPolicies(models: Model<Api>[]): Model<Api>[] {
 		return models.map(model => {
-			if (model.id === "gpt-5.4" && model.provider !== "github-copilot") {
-				return { ...model, contextWindow: 1_000_000 };
+			if (model.id !== "gpt-5.4" || model.provider === "github-copilot") {
+				return model;
+			}
+			const overrides = this.#modelOverrides.get(model.provider)?.get(model.id);
+			if (!overrides) {
+				return applyModelOverride(model, { contextWindow: 1_000_000 });
 			}
-			return model;
+			return applyModelOverride(model, {
+				contextWindow: overrides.contextWindow ?? 1_000_000,
+				...overrides,
+			});
 		});
 	}
 

package/src/config/settings-schema.ts

@@ -1521,6 +1521,8 @@ export const SETTINGS_SCHEMA = {
 	"thinkingBudgets.medium": { type: "number", default: 8192 },
 
 	"thinkingBudgets.high": { type: "number", default: 16384 },
+
+	"thinkingBudgets.xhigh": { type: "number", default: 32768 },
 } as const;
 
 // ═══════════════════════════════════════════════════════════════════════════
@@ -1703,6 +1705,7 @@ export interface ThinkingBudgetsSettings {
 	low: number;
 	medium: number;
 	high: number;
+	xhigh: number;
 }
 
 export interface SttSettings {

package/src/discovery/helpers.ts

@@ -3,7 +3,7 @@ import * as path from "node:path";
 import type { ThinkingLevel } from "@oh-my-pi/pi-agent-core";
 import { FileType, glob } from "@oh-my-pi/pi-natives";
 import { CONFIG_DIR_NAME, getConfigDirName, tryParseJson } from "@oh-my-pi/pi-utils";
-import { readFile } from "../capability/fs";
+import { readDirEntries, readFile } from "../capability/fs";
 import { parseRuleConditionAndScope, type Rule, type RuleFrontmatter } from "../capability/rule";
 import type { Skill, SkillFrontmatter } from "../capability/skill";
 import type { LoadContext, LoadResult, SourceMeta } from "../capability/types";
@@ -529,7 +529,14 @@ export async function discoverExtensionModulePaths(_ctx: LoadContext, dir: strin
 		subdirsWithDeclaredExtensions.add(subdir);
 		const subdirPath = path.join(dir, subdir);
 		for (const extPath of declaredExtensions) {
-			const resolvedExtPath = path.resolve(subdirPath, extPath);
+			let resolvedExtPath = path.resolve(subdirPath, extPath);
+			const entries = await readDirEntries(resolvedExtPath);
+			if (entries.length !== 0) {
+				const pluginFilePath = entries.find(
+					e => e.isFile() && (e.name === "index.ts" || e.name === "index.js"),
+				)?.name;
+				resolvedExtPath = pluginFilePath ? path.join(resolvedExtPath, pluginFilePath) : resolvedExtPath;
+			}
 			const content = await readFile(resolvedExtPath);
 			if (content !== null) {
 				discovered.add(resolvedExtPath);

package/src/mcp/client.ts

@@ -3,7 +3,9 @@
  *
  * Handles connection initialization, tool listing, and tool calling.
  */
-import { logger, withTimeout } from "@oh-my-pi/pi-utils";
+import * as path from "node:path";
+import * as url from "node:url";
+import { getProjectDir, logger, withTimeout } from "@oh-my-pi/pi-utils";
 import { createHttpTransport } from "./transports/http";
 import { createStdioTransport } from "./transports/stdio";
 import type {
@@ -46,6 +48,27 @@ const CLIENT_INFO = {
 	version: "1.0.0",
 };
 
+/**
+ * Default handler for standard MCP server-to-client requests.
+ * Handles `ping` and `roots/list`; rejects unknown methods with -32601.
+ * Reads getProjectDir() at call time so the root stays stable even if
+ * the process cwd changes during tool execution.
+ */
+async function defaultRequestHandler(method: string, _params: unknown): Promise<unknown> {
+	switch (method) {
+		case "ping":
+			return {};
+		case "roots/list": {
+			const cwd = getProjectDir();
+			return {
+				roots: [{ uri: url.pathToFileURL(cwd).href, name: path.basename(cwd) }],
+			};
+		}
+		default:
+			throw Object.assign(new Error(`Unsupported server request: ${method}`), { code: -32601 });
+	}
+}
+
 /**
  * Create a transport for the given server config.
  */
@@ -124,9 +147,11 @@ export async function connectToServer(
 		if (options?.onNotification) {
 			transport.onNotification = options.onNotification;
 		}
-		if (options?.onRequest) {
-			transport.onRequest = options.onRequest;
-		}
+
+		// Always handle standard MCP server-to-client requests (ping, roots/list).
+		// The initialize request declares roots capability, so we must respond to
+		// roots/list — even for short-lived test connections.
+		transport.onRequest = options?.onRequest ?? defaultRequestHandler;
 
 		try {
 			const initResult = await initializeConnection(transport, {

package/src/mcp/manager.ts

@@ -131,6 +131,11 @@ export class MCPManager {
 	#notificationsEpoch = 0;
 	#subscribedResources = new Map<string, Set<string>>();
 	#pendingResourceRefresh = new Map<string, { connection: MCPServerConnection; promise: Promise<void> }>();
+	#pendingReconnections = new Map<string, Promise<MCPServerConnection | null>>();
+	/** Preserved configs for reconnection after connection loss. */
+	#serverConfigs = new Map<string, MCPServerConfig>();
+	/** Monotonic epoch incremented on disconnectAll to invalidate stale reconnections. */
+	#epoch = 0;
 
 	constructor(
 		private cwd: string,
@@ -287,7 +292,11 @@ export class MCPManager {
 				continue;
 			}
 
-			if (this.#pendingConnections.has(name) || this.#pendingToolLoads.has(name)) {
+			if (
+				this.#pendingConnections.has(name) ||
+				this.#pendingToolLoads.has(name) ||
+				this.#pendingReconnections.has(name)
+			) {
 				continue;
 			}
 
@@ -299,6 +308,10 @@ export class MCPManager {
 				continue;
 			}
 
+			// Save config early so reconnection works even if the initial connect times out
+			// and falls back to cached/deferred tools.
+			this.#serverConfigs.set(name, config);
+
 			// Resolve auth config before connecting, but do so per-server in parallel.
 			const connectionPromise = (async () => {
 				const resolvedConfig = await this.#resolveAuthConfig(config);
@@ -315,6 +328,7 @@ export class MCPManager {
 					// Store original config (without resolved tokens) to keep
 					// cache keys stable and avoid leaking rotating credentials.
 					connection.config = config;
+					this.#serverConfigs.set(name, config);
 					if (sources[name]) {
 						connection._source = sources[name];
 					}
@@ -323,7 +337,7 @@ export class MCPManager {
 						this.#connections.set(name, connection);
 					}
 
-					// Wire auth refresh for HTTP transports so 401s trigger token refresh
+					// Wire auth refresh for HTTP transports so 401s trigger token refresh.
 					if (connection.transport instanceof HttpTransport && config.auth?.type === "oauth") {
 						connection.transport.onAuthError = async () => {
 							const refreshed = await this.#resolveAuthConfig(config, true);
@@ -334,6 +348,13 @@ export class MCPManager {
 						};
 					}
 
+					// Re-establish connection if the transport closes (server restart,
+					// network interruption).
+					connection.transport.onClose = () => {
+						logger.debug("MCP transport lost, triggering reconnect", { path: `mcp:${name}` });
+						void this.reconnectServer(name);
+					};
+
 					return connection;
 				},
 				error => {
@@ -358,61 +379,13 @@ export class MCPManager {
 				.then(async ({ connection, serverTools }) => {
 					if (this.#pendingToolLoads.get(name) !== toolsPromise) return;
 					this.#pendingToolLoads.delete(name);
-					const customTools = MCPTool.fromTools(connection, serverTools);
+					const reconnect = () => this.reconnectServer(name);
+					const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
 					this.#replaceServerTools(name, customTools);
 					this.#onToolsChanged?.(this.#tools);
 					void this.toolCache?.set(name, config, serverTools);
 
-					// Load resources and create resource tool (best-effort)
-					if (serverSupportsResources(connection.capabilities)) {
-						try {
-							const [resources] = await Promise.all([
-								listResources(connection),
-								listResourceTemplates(connection),
-							]);
-
-							if (this.#notificationsEnabled && connection.capabilities.resources?.subscribe) {
-								const uris = resources.map(r => r.uri);
-								const notificationEpoch = this.#notificationsEpoch;
-								void subscribeToResources(connection, uris)
-									.then(() => {
-										const action = resolveSubscriptionPostAction(
-											this.#notificationsEnabled,
-											this.#notificationsEpoch,
-											notificationEpoch,
-										);
-										if (action === "rollback") {
-											void unsubscribeFromResources(connection, uris).catch(error => {
-												logger.debug("Failed to rollback stale MCP resource subscription", {
-													path: `mcp:${name}`,
-													error,
-												});
-											});
-											return;
-										}
-										if (action === "ignore") {
-											return;
-										}
-										this.#subscribedResources.set(name, new Set(uris));
-									})
-									.catch(error => {
-										logger.debug("Failed to subscribe to MCP resources", { path: `mcp:${name}`, error });
-									});
-							}
-						} catch (error) {
-							logger.debug("Failed to load MCP resources", { path: `mcp:${name}`, error });
-						}
-					}
-
-					// Load prompts (best-effort)
-					if (serverSupportsPrompts(connection.capabilities)) {
-						try {
-							await listPrompts(connection);
-							this.#onPromptsChanged?.(name);
-						} catch (error) {
-							logger.debug("Failed to load MCP prompts", { path: `mcp:${name}`, error });
-						}
-					}
+					await this.#loadServerResourcesAndPrompts(name, connection);
 				})
 				.catch(error => {
 					if (this.#pendingToolLoads.get(name) !== toolsPromise) return;
@@ -462,7 +435,8 @@ export class MCPManager {
 					if (!value) continue;
 					const { connection, serverTools } = value;
 					connectedServers.add(name);
-					allTools.push(...MCPTool.fromTools(connection, serverTools));
+					const reconnect = () => this.reconnectServer(name);
+					allTools.push(...MCPTool.fromTools(connection, serverTools, reconnect));
 				} else if (task.tracked.status === "rejected") {
 					const message =
 						task.tracked.reason instanceof Error ? task.tracked.reason.message : String(task.tracked.reason);
@@ -472,7 +446,10 @@ export class MCPManager {
 					const cached = cachedTools.get(name);
 					if (cached) {
 						const source = this.#sources.get(name);
-						allTools.push(...DeferredMCPTool.fromTools(name, cached, () => this.waitForConnection(name), source));
+						const reconnect = () => this.reconnectServer(name);
+						allTools.push(
+							...DeferredMCPTool.fromTools(name, cached, () => this.waitForConnection(name), source, reconnect),
+						);
 					}
 				}
 			}
@@ -580,7 +557,12 @@ export class MCPManager {
 	 */
 	getConnectionStatus(name: string): "connected" | "connecting" | "disconnected" {
 		if (this.#connections.has(name)) return "connected";
-		if (this.#pendingConnections.has(name) || this.#pendingToolLoads.has(name)) return "connecting";
+		if (
+			this.#pendingConnections.has(name) ||
+			this.#pendingToolLoads.has(name) ||
+			this.#pendingReconnections.has(name)
+		)
+			return "connecting";
 		return "disconnected";
 	}
 
@@ -599,6 +581,12 @@ export class MCPManager {
 		if (connection) return connection;
 		const pending = this.#pendingConnections.get(name);
 		if (pending) return pending;
+		// If a reconnection is in flight, wait for it to complete
+		const reconnecting = this.#pendingReconnections.get(name);
+		if (reconnecting) {
+			const result = await reconnecting;
+			if (result) return result;
+		}
 		throw new Error(`MCP server not connected: ${name}`);
 	}
 
@@ -631,7 +619,9 @@ export class MCPManager {
 	async disconnectServer(name: string): Promise<void> {
 		this.#pendingConnections.delete(name);
 		this.#pendingToolLoads.delete(name);
+		this.#pendingReconnections.delete(name);
 		this.#sources.delete(name);
+		this.#serverConfigs.delete(name);
 		this.#pendingResourceRefresh.delete(name);
 
 		const connection = this.#connections.get(name);
@@ -643,6 +633,8 @@ export class MCPManager {
 		this.#subscribedResources.delete(name);
 
 		if (connection) {
+			// Detach onClose to prevent spurious reconnect from close()
+			connection.transport.onClose = undefined;
 			await disconnectServer(connection);
 			this.#connections.delete(name);
 		}
@@ -660,18 +652,224 @@ export class MCPManager {
 	 * Disconnect from all servers.
 	 */
 	async disconnectAll(): Promise<void> {
+		// Invalidate any in-flight reconnection attempts that outlive this call.
+		// They captured the old epoch; after increment they'll detect staleness.
+		this.#epoch++;
+		// Detach onClose before closing to prevent spurious reconnect attempts
+		for (const conn of this.#connections.values()) {
+			conn.transport.onClose = undefined;
+		}
 		const promises = Array.from(this.#connections.values()).map(conn => disconnectServer(conn));
 		await Promise.allSettled(promises);
 
 		this.#pendingConnections.clear();
 		this.#pendingToolLoads.clear();
+		this.#pendingReconnections.clear();
 		this.#pendingResourceRefresh.clear();
 		this.#sources.clear();
+		this.#serverConfigs.clear();
 		this.#connections.clear();
 		this.#tools = [];
 		this.#subscribedResources.clear();
 	}
 
+	/**
+	 * Reconnect to a server after a connection failure.
+	 * Tears down the stale connection, re-resolves auth, establishes a new
+	 * connection, reloads tools, and notifies consumers.
+	 * Concurrent calls for the same server share one reconnection attempt.
+	 * Returns the new connection, or null if reconnection failed.
+	 */
+	async reconnectServer(name: string): Promise<MCPServerConnection | null> {
+		const pending = this.#pendingReconnections.get(name);
+		if (pending) return pending;
+
+		const attempt = this.#doReconnect(name);
+		this.#pendingReconnections.set(name, attempt);
+		return attempt.finally(() => this.#pendingReconnections.delete(name));
+	}
+
+	async #doReconnect(name: string): Promise<MCPServerConnection | null> {
+		const oldConnection = this.#connections.get(name);
+		const config = oldConnection?.config ?? this.#serverConfigs.get(name);
+		const source = this.#sources.get(name) ?? oldConnection?._source;
+		if (!config) return null;
+
+		logger.debug("MCP reconnecting", { path: `mcp:${name}` });
+
+		// Close the old transport without removing tools or notifying consumers.
+		// Tools stay available (stale) while we establish the new connection.
+		// Fire-and-forget: don't await the close — HttpTransport.close() sends a
+		// DELETE with config.timeout (30s default), and blocking here delays the
+		// reconnect loop by that amount on every server restart.
+		const reconnectEpoch = this.#epoch;
+		if (oldConnection) {
+			// Detach onClose to prevent re-entrant reconnect from the close itself
+			oldConnection.transport.onClose = undefined;
+			void oldConnection.transport.close().catch(() => {});
+			this.#connections.delete(name);
+		}
+		this.#pendingConnections.delete(name);
+		this.#pendingToolLoads.delete(name);
+
+		// Retry with backoff — the server may still be starting up.
+		const delays = [500, 1000, 2000, 4000];
+		for (let attempt = 0; attempt <= delays.length; attempt++) {
+			if (this.#epoch !== reconnectEpoch) {
+				logger.debug("MCP reconnect aborted before attempt after configuration changed", {
+					path: `mcp:${name}`,
+					storedEpoch: reconnectEpoch,
+					currentEpoch: this.#epoch,
+				});
+				return null;
+			}
+			try {
+				const connection = await this.#connectAndWireServer(name, config, source, reconnectEpoch);
+				logger.debug("MCP reconnected", { path: `mcp:${name}`, tools: connection.tools?.length ?? 0 });
+				return connection;
+			} catch (error) {
+				if (this.#epoch !== reconnectEpoch) {
+					logger.debug("MCP reconnect aborted after configuration changed", {
+						path: `mcp:${name}`,
+						storedEpoch: reconnectEpoch,
+						currentEpoch: this.#epoch,
+					});
+					return null;
+				}
+
+				const msg = error instanceof Error ? error.message : String(error);
+				if (attempt < delays.length) {
+					logger.debug("MCP reconnect attempt failed, retrying", {
+						path: `mcp:${name}`,
+						attempt: attempt + 1,
+						error: msg,
+					});
+					await Bun.sleep(delays[attempt]);
+				} else {
+					logger.error("MCP reconnect failed after retries", { path: `mcp:${name}`, error: msg });
+					// Don't remove stale tools — keep them in the registry so they
+					// remain selected. Calls will fail with MCP errors, which
+					// triggers the tool-level reconnect, or the user can run
+					// /mcp reconnect <name> manually.
+				}
+			}
+		}
+		return null;
+	}
+
+	/** Establish a new connection to a server, wire handlers, load tools. */
+	async #connectAndWireServer(
+		name: string,
+		config: MCPServerConfig,
+		source: SourceMeta | undefined,
+		reconnectEpoch: number,
+	): Promise<MCPServerConnection> {
+		const resolvedConfig = await this.#resolveAuthConfig(config);
+		const connection = await connectToServer(name, resolvedConfig, {
+			onNotification: (method, params) => {
+				this.#handleServerNotification(name, method, params);
+			},
+			onRequest: (method, params) => {
+				return this.#handleServerRequest(method, params);
+			},
+		});
+
+		connection.config = config;
+		if (source) connection._source = source;
+
+		// Bail out if the server was disconnected or the manager was reset
+		// while we were connecting (e.g. /mcp reload called disconnectAll).
+		if (!this.#serverConfigs.has(name) || this.#epoch !== reconnectEpoch) {
+			await connection.transport.close().catch(() => {});
+			throw new Error(`Server "${name}" was disconnected during reconnection`);
+		}
+
+		this.#connections.set(name, connection);
+
+		// Wire auth refresh for HTTP transports, and reconnect for any transport.
+		if (connection.transport instanceof HttpTransport && config.auth?.type === "oauth") {
+			connection.transport.onAuthError = async () => {
+				const refreshed = await this.#resolveAuthConfig(config, true);
+				if (refreshed.type === "http" || refreshed.type === "sse") {
+					return refreshed.headers ?? null;
+				}
+				return null;
+			};
+		}
+		connection.transport.onClose = () => {
+			logger.debug("MCP transport lost, triggering reconnect", { path: `mcp:${name}` });
+			void this.reconnectServer(name);
+		};
+		try {
+			const serverTools = await listTools(connection);
+			const reconnect = () => this.reconnectServer(name);
+			const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
+			void this.toolCache?.set(name, config, serverTools);
+			this.#replaceServerTools(name, customTools);
+			this.#onToolsChanged?.(this.#tools);
+			void this.#loadServerResourcesAndPrompts(name, connection);
+			return connection;
+		} catch (error) {
+			// Clean up the connection to avoid zombie transports
+			connection.transport.onClose = undefined;
+			await connection.transport.close().catch(() => {});
+			this.#connections.delete(name);
+			throw error;
+		}
+	}
+
+	/**
+	 * Best-effort loading of resources, resource subscriptions, and prompts.
+	 * Shared between initial connection and reconnection.
+	 */
+	async #loadServerResourcesAndPrompts(name: string, connection: MCPServerConnection): Promise<void> {
+		if (serverSupportsResources(connection.capabilities)) {
+			try {
+				const [resources] = await Promise.all([listResources(connection), listResourceTemplates(connection)]);
+
+				if (this.#notificationsEnabled && connection.capabilities.resources?.subscribe) {
+					const uris = resources.map(r => r.uri);
+					const notificationEpoch = this.#notificationsEpoch;
+					void subscribeToResources(connection, uris)
+						.then(() => {
+							const action = resolveSubscriptionPostAction(
+								this.#notificationsEnabled,
+								this.#notificationsEpoch,
+								notificationEpoch,
+							);
+							if (action === "rollback") {
+								void unsubscribeFromResources(connection, uris).catch(error => {
+									logger.debug("Failed to rollback stale MCP resource subscription", {
+										path: `mcp:${name}`,
+										error,
+									});
+								});
+								return;
+							}
+							if (action === "ignore") {
+								return;
+							}
+							this.#subscribedResources.set(name, new Set(uris));
+						})
+						.catch(error => {
+							logger.debug("Failed to subscribe to MCP resources", { path: `mcp:${name}`, error });
+						});
+				}
+			} catch (error) {
+				logger.debug("Failed to load MCP resources", { path: `mcp:${name}`, error });
+			}
+		}
+
+		if (serverSupportsPrompts(connection.capabilities)) {
+			try {
+				await listPrompts(connection);
+				this.#onPromptsChanged?.(name);
+			} catch (error) {
+				logger.debug("Failed to load MCP prompts", { path: `mcp:${name}`, error });
+			}
+		}
+	}
+
 	/**
 	 * Refresh tools from a specific server.
 	 */
@@ -684,7 +882,8 @@ export class MCPManager {
 
 		// Reload tools
 		const serverTools = await listTools(connection);
-		const customTools = MCPTool.fromTools(connection, serverTools);
+		const reconnect = () => this.reconnectServer(name);
+		const customTools = MCPTool.fromTools(connection, serverTools, reconnect);
 		void this.toolCache?.set(name, connection.config, serverTools);
 
 		// Replace tools from this server