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

package/src/mcp/tool-bridge.ts

@@ -5,6 +5,7 @@
  */
 import type { AgentToolUpdateCallback } from "@oh-my-pi/pi-agent-core";
 import { sanitizeSchemaForMCP } from "@oh-my-pi/pi-ai/utils/schema";
+import { untilAborted } from "@oh-my-pi/pi-utils";
 import type { TSchema } from "@sinclair/typebox";
 import type { SourceMeta } from "../capability/types";
 import type {
@@ -17,22 +18,43 @@ import type { Theme } from "../modes/theme/theme";
 import { ToolAbortError, throwIfAborted } from "../tools/tool-errors";
 import { callTool } from "./client";
 import { renderMCPCall, renderMCPResult } from "./render";
-import type { MCPContent, MCPServerConnection, MCPToolDefinition } from "./types";
+import type { MCPContent, MCPServerConnection, MCPToolCallParams, MCPToolCallResult, MCPToolDefinition } from "./types";
 
-function withAbort<T>(promise: Promise<T>, signal?: AbortSignal): Promise<T> {
-	if (!signal) return promise;
-	if (signal.aborted) {
-		return Promise.reject(signal.reason instanceof Error ? signal.reason : new ToolAbortError());
-	}
+/** Reconnect callback: tears down stale connection, returns new one or null. */
+export type MCPReconnect = () => Promise<MCPServerConnection | null>;
 
-	const { promise: wrapped, resolve, reject } = Promise.withResolvers<T>();
-	const onAbort = () => {
-		reject(signal.reason instanceof Error ? signal.reason : new ToolAbortError());
-	};
+/**
+ * Network-level and stale-session errors that warrant a reconnect + single retry.
+ * Conservative: only catches errors where the server is likely alive but the
+ * connection object is stale (dead SSE, expired session, refused after restart).
+ */
+const RETRIABLE_PATTERNS = [
+	"econnrefused",
+	"econnreset",
+	"epipe",
+	"enetunreach",
+	"ehostunreach",
+	"fetch failed",
+	"transport not connected",
+	"transport closed",
+	"network error",
+];
+
+export function isRetriableConnectionError(error: unknown): boolean {
+	if (!(error instanceof Error)) return false;
+	const msg = error.message.toLowerCase();
+	// Stale session (server restarted, old session ID is gone)
+	if (/^http (404|502|503):/.test(msg)) return true;
+	return RETRIABLE_PATTERNS.some(p => msg.includes(p));
+}
 
-	signal.addEventListener("abort", onAbort, { once: true });
-	promise.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
-	return wrapped;
+type MCPToolArgs = NonNullable<MCPToolCallParams["arguments"]>;
+
+function normalizeToolArgs(value: unknown): MCPToolArgs {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) {
+		return {};
+	}
+	return value as MCPToolArgs;
 }
 
 /** Details included in MCP tool results for rendering */
@@ -77,6 +99,60 @@ function formatMCPContent(content: MCPContent[]): string {
 	return parts.join("\n\n");
 }
 
+/** Build a CustomToolResult from a callTool response. */
+function buildResult(
+	result: MCPToolCallResult,
+	serverName: string,
+	mcpToolName: string,
+	provider?: string,
+	providerName?: string,
+): CustomToolResult<MCPToolDetails> {
+	const text = formatMCPContent(result.content);
+	const details: MCPToolDetails = {
+		serverName,
+		mcpToolName,
+		isError: result.isError,
+		rawContent: result.content,
+		provider,
+		providerName,
+	};
+	if (result.isError) {
+		return { content: [{ type: "text", text: `Error: ${text}` }], details };
+	}
+	return { content: [{ type: "text", text }], details };
+}
+
+/** Build an error CustomToolResult from a caught exception. */
+function buildErrorResult(
+	error: unknown,
+	serverName: string,
+	mcpToolName: string,
+	provider?: string,
+	providerName?: string,
+): CustomToolResult<MCPToolDetails> {
+	const message = error instanceof Error ? error.message : String(error);
+	return {
+		content: [{ type: "text", text: `MCP error: ${message}` }],
+		details: { serverName, mcpToolName, isError: true, provider, providerName },
+	};
+}
+
+/** Re-throw abort-related errors so they bypass error-result handling. */
+function rethrowIfAborted(error: unknown, signal?: AbortSignal): void {
+	if (error instanceof ToolAbortError) throw error;
+	if (error instanceof Error && error.name === "AbortError") throw new ToolAbortError();
+	if (signal?.aborted) throw new ToolAbortError();
+}
+
+async function reconnectWithAbort(reconnect: MCPReconnect, signal?: AbortSignal): Promise<MCPServerConnection | null> {
+	try {
+		return await untilAborted(signal, reconnect);
+	} catch (error) {
+		rethrowIfAborted(error, signal);
+		return null;
+	}
+}
+
 /**
  * Create a unique tool name for an MCP tool.
  *
@@ -143,13 +219,14 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	readonly mcpServerName: string;
 
 	/** Create MCPTool instances for all tools from an MCP server connection */
-	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[]): MCPTool[] {
-		return tools.map(tool => new MCPTool(connection, tool));
+	static fromTools(connection: MCPServerConnection, tools: MCPToolDefinition[], reconnect?: MCPReconnect): MCPTool[] {
+		return tools.map(tool => new MCPTool(connection, tool, reconnect));
 	}
 
 	constructor(
-		private readonly connection: MCPServerConnection,
+		private connection: MCPServerConnection,
 		private readonly tool: MCPToolDefinition,
+		private readonly reconnect?: MCPReconnect,
 	) {
 		this.name = createMCPToolName(connection.name, tool.name);
 		this.label = `${connection.name}/${tool.name}`;
@@ -160,11 +237,11 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	}
 
 	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme) {
-		return renderMCPCall((args ?? {}) as Record<string, unknown>, theme, this.label);
+		return renderMCPCall(normalizeToolArgs(args), theme, this.label);
 	}
 
 	renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown) {
-		return renderMCPResult(result, options, theme, (args ?? {}) as Record<string, unknown>);
+		return renderMCPResult(result, options, theme, normalizeToolArgs(args));
 	}
 
 	async execute(
@@ -175,51 +252,38 @@ export class MCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
-		try {
-			const result = await callTool(this.connection, this.tool.name, params as Record<string, unknown>, { signal });
-
-			const text = formatMCPContent(result.content);
-			const details: MCPToolDetails = {
-				serverName: this.connection.name,
-				mcpToolName: this.tool.name,
-				isError: result.isError,
-				rawContent: result.content,
-				provider: this.connection._source?.provider,
-				providerName: this.connection._source?.providerName,
-			};
-
-			if (result.isError) {
-				return {
-					content: [{ type: "text", text: `Error: ${text}` }],
-					details,
-				};
-			}
+		const args = normalizeToolArgs(params);
+		const provider = this.connection._source?.provider;
+		const providerName = this.connection._source?.providerName;
 
-			return {
-				content: [{ type: "text", text }],
-				details,
-			};
+		try {
+			const result = await callTool(this.connection, this.tool.name, args, { signal });
+			return buildResult(result, this.connection.name, this.tool.name, provider, providerName);
 		} catch (error) {
-			if (error instanceof ToolAbortError) {
-				throw error;
-			}
-			if (error instanceof Error && error.name === "AbortError") {
-				throw new ToolAbortError();
-			}
-			if (signal?.aborted) {
-				throw new ToolAbortError();
+			rethrowIfAborted(error, signal);
+			if (this.reconnect && isRetriableConnectionError(error)) {
+				const newConn = await reconnectWithAbort(this.reconnect, signal);
+				if (newConn) {
+					// Rebind so subsequent calls on this instance use the fresh connection
+					this.connection = newConn;
+					const retryProvider = newConn._source?.provider ?? provider;
+					const retryProviderName = newConn._source?.providerName ?? providerName;
+					try {
+						const result = await callTool(newConn, this.tool.name, args, { signal });
+						return buildResult(result, newConn.name, this.tool.name, retryProvider, retryProviderName);
+					} catch (retryError) {
+						rethrowIfAborted(retryError, signal);
+						return buildErrorResult(
+							retryError,
+							this.connection.name,
+							this.tool.name,
+							retryProvider,
+							retryProviderName,
+						);
+					}
+				}
 			}
-			const message = error instanceof Error ? error.message : String(error);
-			return {
-				content: [{ type: "text", text: `MCP error: ${message}` }],
-				details: {
-					serverName: this.connection.name,
-					mcpToolName: this.tool.name,
-					isError: true,
-					provider: this.connection._source?.provider,
-					providerName: this.connection._source?.providerName,
-				},
-			};
+			return buildErrorResult(error, this.connection.name, this.tool.name, provider, providerName);
 		}
 	}
 }
@@ -245,8 +309,9 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		tools: MCPToolDefinition[],
 		getConnection: () => Promise<MCPServerConnection>,
 		source?: SourceMeta,
+		reconnect?: MCPReconnect,
 	): DeferredMCPTool[] {
-		return tools.map(tool => new DeferredMCPTool(serverName, tool, getConnection, source));
+		return tools.map(tool => new DeferredMCPTool(serverName, tool, getConnection, source, reconnect));
 	}
 
 	constructor(
@@ -254,6 +319,7 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		private readonly tool: MCPToolDefinition,
 		private readonly getConnection: () => Promise<MCPServerConnection>,
 		source?: SourceMeta,
+		private readonly reconnect?: MCPReconnect,
 	) {
 		this.name = createMCPToolName(serverName, tool.name);
 		this.label = `${serverName}/${tool.name}`;
@@ -266,11 +332,11 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 	}
 
 	renderCall(args: unknown, _options: RenderResultOptions, theme: Theme) {
-		return renderMCPCall((args ?? {}) as Record<string, unknown>, theme, this.label);
+		return renderMCPCall(normalizeToolArgs(args), theme, this.label);
 	}
 
 	renderResult(result: CustomToolResult<MCPToolDetails>, options: RenderResultOptions, theme: Theme, args?: unknown) {
-		return renderMCPResult(result, options, theme, (args ?? {}) as Record<string, unknown>);
+		return renderMCPResult(result, options, theme, normalizeToolArgs(args));
 	}
 
 	async execute(
@@ -281,53 +347,70 @@ export class DeferredMCPTool implements CustomTool<TSchema, MCPToolDetails> {
 		signal?: AbortSignal,
 	): Promise<CustomToolResult<MCPToolDetails>> {
 		throwIfAborted(signal);
+		const args = normalizeToolArgs(params);
+		const provider = this.#fallbackProvider;
+		const providerName = this.#fallbackProviderName;
+
 		try {
-			const connection = await withAbort(this.getConnection(), signal);
+			const connection = await untilAborted(signal, () => this.getConnection());
 			throwIfAborted(signal);
-			const result = await callTool(connection, this.tool.name, params as Record<string, unknown>, { signal });
-
-			const text = formatMCPContent(result.content);
-			const details: MCPToolDetails = {
-				serverName: this.serverName,
-				mcpToolName: this.tool.name,
-				isError: result.isError,
-				rawContent: result.content,
-				provider: connection._source?.provider ?? this.#fallbackProvider,
-				providerName: connection._source?.providerName ?? this.#fallbackProviderName,
-			};
-
-			if (result.isError) {
-				return {
-					content: [{ type: "text", text: `Error: ${text}` }],
-					details,
-				};
-			}
-
-			return {
-				content: [{ type: "text", text }],
-				details,
-			};
-		} catch (error) {
-			if (error instanceof ToolAbortError) {
-				throw error;
-			}
-			if (error instanceof Error && error.name === "AbortError") {
-				throw new ToolAbortError();
+			try {
+				const result = await callTool(connection, this.tool.name, args, { signal });
+				return buildResult(
+					result,
+					this.serverName,
+					this.tool.name,
+					connection._source?.provider ?? provider,
+					connection._source?.providerName ?? providerName,
+				);
+			} catch (callError) {
+				rethrowIfAborted(callError, signal);
+				if (this.reconnect && isRetriableConnectionError(callError)) {
+					const newConn = await reconnectWithAbort(this.reconnect, signal);
+					if (newConn) {
+						const retryProvider = newConn._source?.provider ?? provider;
+						const retryProviderName = newConn._source?.providerName ?? providerName;
+						try {
+							const result = await callTool(newConn, this.tool.name, args, { signal });
+							return buildResult(result, this.serverName, this.tool.name, retryProvider, retryProviderName);
+						} catch (retryError) {
+							rethrowIfAborted(retryError, signal);
+							return buildErrorResult(
+								retryError,
+								this.serverName,
+								this.tool.name,
+								retryProvider,
+								retryProviderName,
+							);
+						}
+					}
+				}
+				return buildErrorResult(callError, this.serverName, this.tool.name, provider, providerName);
 			}
-			if (signal?.aborted) {
-				throw new ToolAbortError();
+		} catch (connError) {
+			// getConnection() failed — server never connected or connection lost.
+			// This is always worth a reconnect attempt for deferred tools, since the
+			// error ("MCP server not connected") isn't a network error from callTool.
+			rethrowIfAborted(connError, signal);
+			if (this.reconnect) {
+				const newConn = await reconnectWithAbort(this.reconnect, signal);
+				if (newConn) {
+					try {
+						const result = await callTool(newConn, this.tool.name, args, { signal });
+						return buildResult(
+							result,
+							this.serverName,
+							this.tool.name,
+							newConn._source?.provider ?? provider,
+							newConn._source?.providerName ?? providerName,
+						);
+					} catch (retryError) {
+						rethrowIfAborted(retryError, signal);
+						return buildErrorResult(retryError, this.serverName, this.tool.name, provider, providerName);
+					}
+				}
 			}
-			const message = error instanceof Error ? error.message : String(error);
-			return {
-				content: [{ type: "text", text: `MCP error: ${message}` }],
-				details: {
-					serverName: this.serverName,
-					mcpToolName: this.tool.name,
-					isError: true,
-					provider: this.#fallbackProvider,
-					providerName: this.#fallbackProviderName,
-				},
-			};
+			return buildErrorResult(connError, this.serverName, this.tool.name, provider, providerName);
 		}
 	}
 }

package/src/mcp/transports/http.ts

@@ -4,7 +4,7 @@
  * Implements JSON-RPC 2.0 over HTTP POST with optional SSE streaming.
  * Based on MCP spec 2025-03-26.
  */
-import { readSseJson, Snowflake } from "@oh-my-pi/pi-utils";
+import { logger, readSseJson, Snowflake } from "@oh-my-pi/pi-utils";
 import type {
 	JsonRpcError,
 	JsonRpcMessage,
@@ -91,13 +91,16 @@ export class HttpTransport implements MCPTransport {
 			return;
 		}
 
-		// Connection established — read messages in background, reset sseConnection when done
+		// Connection established — read messages in background.
+		// If the stream ends unexpectedly (server restart, network drop),
+		// fire onClose so the manager can trigger reconnection.
 		const signal = this.#sseConnection.signal;
 		void this.#readSSEStream(response.body!, signal).finally(() => {
+			const wasConnected = this.#connected;
 			this.#sseConnection = null;
+			if (wasConnected) this.onClose?.();
 		});
 	}
-
 	async #readSSEStream(body: ReadableStream<Uint8Array>, signal: AbortSignal): Promise<void> {
 		try {
 			for await (const message of readSseJson<JsonRpcMessage>(body, signal)) {
@@ -106,6 +109,7 @@ export class HttpTransport implements MCPTransport {
 			}
 		} catch (error) {
 			if (error instanceof Error && error.name !== "AbortError") {
+				logger.debug("HTTP SSE stream error", { url: this.config.url, error: error.message });
 				this.onError?.(error);
 			}
 		}
@@ -457,6 +461,7 @@ export class HttpTransport implements MCPTransport {
 		}
 
 		this.onClose?.();
+		this.onClose = undefined;
 	}
 }
 

package/src/modes/components/bash-execution.ts

@@ -6,13 +6,17 @@ import { sanitizeText } from "@oh-my-pi/pi-natives";
 import { Container, ImageProtocol, Loader, Spacer, TERMINAL, Text, type TUI } from "@oh-my-pi/pi-tui";
 import { getSymbolTheme, theme } from "../../modes/theme/theme";
 import { formatTruncationMetaNotice, type TruncationMeta } from "../../tools/output-meta";
-import { getSixelLineMask, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
+import { getSixelLineMask, isSixelPassthroughEnabled, sanitizeWithOptionalSixelPassthrough } from "../../utils/sixel";
 import { DynamicBorder } from "./dynamic-border";
 import { truncateToVisualLines } from "./visual-truncate";
 
 // Preview line limit when not expanded (matches tool execution behavior)
 const PREVIEW_LINES = 20;
+const STREAMING_LINE_CAP = PREVIEW_LINES * 5;
 const MAX_DISPLAY_LINE_CHARS = 4000;
+// Minimum interval between processing incoming chunks for display (ms).
+// Chunks arriving faster than this are accumulated and processed in one batch.
+const CHUNK_THROTTLE_MS = 50;
 
 export class BashExecutionComponent extends Container {
 	#outputLines: string[] = [];
@@ -21,7 +25,10 @@ export class BashExecutionComponent extends Container {
 	#loader: Loader;
 	#truncation?: TruncationMeta;
 	#expanded = false;
+	#displayDirty = false;
+	#chunkGate = false;
 	#contentContainer: Container;
+	#headerText: Text;
 
 	constructor(
 		private readonly command: string,
@@ -45,8 +52,8 @@ export class BashExecutionComponent extends Container {
 		this.addChild(this.#contentContainer);
 
 		// Command header
-		const header = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
-		this.#contentContainer.addChild(header);
+		this.#headerText = new Text(theme.fg(colorKey, theme.bold(`$ ${command}`)), 1, 0);
+		this.#contentContainer.addChild(this.#headerText);
 
 		// Loader
 		this.#loader = new Loader(
@@ -72,14 +79,22 @@ export class BashExecutionComponent extends Container {
 
 	override invalidate(): void {
 		super.invalidate();
+		this.#displayDirty = false;
 		this.#updateDisplay();
 	}
 
 	appendOutput(chunk: string): void {
-		const clean = sanitizeWithOptionalSixelPassthrough(chunk, sanitizeText);
-
-		// Append to output lines
-		const incomingLines = clean.split("\n");
+		// During high-throughput output (e.g. seq 1 500M), processing every
+		// chunk would saturate the event loop. Instead, accept one chunk per
+		// throttle window and drop the rest — the OutputSink captures everything
+		// for the artifact, and setComplete() replaces with the final output.
+		if (this.#chunkGate) return;
+		this.#chunkGate = true;
+		setTimeout(() => {
+			this.#chunkGate = false;
+		}, CHUNK_THROTTLE_MS);
+
+		const incomingLines = chunk.split("\n");
 		if (this.#outputLines.length > 0 && incomingLines.length > 0) {
 			const lastIndex = this.#outputLines.length - 1;
 			const mergedLines = [`${this.#outputLines[lastIndex]}${incomingLines[0]}`, ...incomingLines.slice(1)];
@@ -90,7 +105,12 @@ export class BashExecutionComponent extends Container {
 			this.#outputLines.push(...this.#clampLinesPreservingSixel(incomingLines));
 		}
 
-		this.#updateDisplay();
+		// Cap stored lines during streaming to avoid unbounded memory growth
+		if (this.#outputLines.length > STREAMING_LINE_CAP) {
+			this.#outputLines = this.#outputLines.slice(-STREAMING_LINE_CAP);
+		}
+
+		this.#displayDirty = true;
 	}
 
 	setComplete(
@@ -115,6 +135,14 @@ export class BashExecutionComponent extends Container {
 		this.#updateDisplay();
 	}
 
+	override render(width: number): string[] {
+		if (this.#displayDirty) {
+			this.#displayDirty = false;
+			this.#updateDisplay();
+		}
+		return super.render(width);
+	}
+
 	#updateDisplay(): void {
 		const availableLines = this.#outputLines;
 
@@ -122,15 +150,16 @@ export class BashExecutionComponent extends Container {
 		const previewLogicalLines = availableLines.slice(-PREVIEW_LINES);
 		const hiddenLineCount = availableLines.length - previewLogicalLines.length;
 		const sixelLineMask =
-			TERMINAL.imageProtocol === ImageProtocol.Sixel ? getSixelLineMask(availableLines) : undefined;
+			TERMINAL.imageProtocol === ImageProtocol.Sixel && isSixelPassthroughEnabled()
+				? getSixelLineMask(availableLines)
+				: undefined;
 		const hasSixelOutput = sixelLineMask?.some(Boolean) ?? false;
 
 		// Rebuild content container
 		this.#contentContainer.clear();
 
 		// Command header
-		const header = new Text(theme.fg("bashMode", theme.bold(`$ ${this.command}`)), 1, 0);
-		this.#contentContainer.addChild(header);
+		this.#contentContainer.addChild(this.#headerText);
 
 		// Output
 		if (availableLines.length > 0) {

package/src/modes/components/python-execution.ts

@@ -72,9 +72,8 @@ export class PythonExecutionComponent extends Container {
 	}
 
 	appendOutput(chunk: string): void {
-		const clean = sanitizeText(chunk);
-
-		const newLines = clean.split("\n").map(line => this.#clampDisplayLine(line));
+		// Chunk is pre-sanitized by OutputSink.push() — no need to sanitize again.
+		const newLines = chunk.split("\n").map(line => this.#clampDisplayLine(line));
 		if (this.#outputLines.length > 0 && newLines.length > 0) {
 			this.#outputLines[this.#outputLines.length - 1] = this.#clampDisplayLine(
 				`${this.#outputLines[this.#outputLines.length - 1]}${newLines[0]}`,

package/src/modes/components/tool-execution.ts

@@ -105,17 +105,16 @@ export class ToolExecutionComponent extends Container {
 	// Cached converted images for Kitty protocol (which requires PNG), keyed by index
 	#convertedImages: Map<number, { data: string; mimeType: string }> = new Map();
 	// Spinner animation for partial task results
-	#spinnerFrame = 0;
+	#spinnerFrame?: number;
 	#spinnerInterval?: NodeJS.Timeout;
 	// Track if args are still being streamed (for edit/write spinner)
 	#argsComplete = false;
 	#renderState: {
-		spinnerFrame: number;
+		spinnerFrame?: number;
 		expanded: boolean;
 		isPartial: boolean;
 		renderContext?: Record<string, unknown>;
 	} = {
-		spinnerFrame: 0,
 		expanded: false,
 		isPartial: true,
 	};
@@ -328,10 +327,9 @@ export class ToolExecutionComponent extends Container {
 			this.#spinnerInterval = setInterval(() => {
 				const frameCount = theme.spinnerFrames.length;
 				if (frameCount === 0) return;
-				this.#spinnerFrame = (this.#spinnerFrame + 1) % frameCount;
+				this.#spinnerFrame = ((this.#spinnerFrame ?? -1) + 1) % frameCount;
 				this.#renderState.spinnerFrame = this.#spinnerFrame;
 				this.#ui.requestRender();
-				// NO updateDisplay() — existing component closures read from renderState
 			}, 80);
 		} else if (!needsSpinner && this.#spinnerInterval) {
 			clearInterval(this.#spinnerInterval);
@@ -346,6 +344,7 @@ export class ToolExecutionComponent extends Container {
 		if (this.#spinnerInterval) {
 			clearInterval(this.#spinnerInterval);
 			this.#spinnerInterval = undefined;
+			this.#spinnerFrame = undefined;
 		}
 	}
 

package/src/modes/controllers/command-controller.ts

@@ -690,7 +690,6 @@ export class CommandController {
 				chunk => {
 					if (this.ctx.bashComponent) {
 						this.ctx.bashComponent.appendOutput(chunk);
-						this.ctx.ui.requestRender();
 					}
 				},
 				{ excludeFromContext },
@@ -732,7 +731,6 @@ export class CommandController {
 				chunk => {
 					if (this.ctx.pythonComponent) {
 						this.ctx.pythonComponent.appendOutput(chunk);
-						this.ctx.ui.requestRender();
 					}
 				},
 				{ excludeFromContext },

package/src/modes/controllers/mcp-command-controller.ts

@@ -127,6 +127,9 @@ export class MCPCommandController {
 			case "smithery-logout":
 				await this.#handleSmitheryLogout();
 				break;
+			case "reconnect":
+				await this.#handleReconnect(parts[2]);
+				break;
 			case "reload":
 				await this.#handleReload();
 				break;
@@ -159,6 +162,7 @@ export class MCPCommandController {
 			"                        Search Smithery registry and deploy from picker",
 			"  /mcp smithery-login   Login to Smithery and cache API key",
 			"  /mcp smithery-logout  Remove cached Smithery API key",
+			"  /mcp reconnect <name> Reconnect to a specific MCP server",
 			"  /mcp reload           Force reload and rediscover MCP runtime tools",
 			"  /mcp resources        List available resources from connected servers",
 			"  /mcp prompts          List available prompts from connected servers",
@@ -1372,6 +1376,47 @@ export class MCPCommandController {
 		}
 	}
 
+	/**
+	 * Handle /mcp reconnect <name> - Reconnect to a specific server.
+	 */
+	async #handleReconnect(name: string | undefined): Promise<void> {
+		if (!name) {
+			this.ctx.showError("Server name required. Usage: /mcp reconnect <name>");
+			return;
+		}
+		if (!this.ctx.mcpManager) {
+			this.ctx.showError("MCP manager not available.");
+			return;
+		}
+
+		this.#showMessage(["", theme.fg("muted", `Reconnecting to "${name}"...`), ""].join("\n"));
+
+		try {
+			const connection = await this.ctx.mcpManager.reconnectServer(name);
+			if (connection) {
+				// refreshMCPTools re-registers tools and preserves the user's prior
+				// MCP tool selection. No need to call activateDiscoveredMCPTools —
+				// that would broaden the selection to all server tools.
+				await this.ctx.session.refreshMCPTools(this.ctx.mcpManager.getTools());
+				const serverTools = this.ctx.mcpManager.getTools().filter(t => t.mcpServerName === name);
+				this.#showMessage(
+					[
+						"\n",
+						theme.fg("success", `\u2713 Reconnected to "${name}"`),
+						`  Tools: ${serverTools.length}`,
+						"\n",
+					].join("\n"),
+				);
+			} else {
+				this.ctx.showError(`Failed to reconnect to "${name}". Check server status and logs.`);
+			}
+		} catch (error) {
+			this.ctx.showError(
+				`Failed to reconnect to "${name}": ${error instanceof Error ? error.message : String(error)}`,
+			);
+		}
+	}
+
 	/**
 	 * Reload MCP manager with new configs
 	 */