@oh-my-pi/pi-coding-agent 1.338.0 → 1.341.0

package/src/core/mcp/loader.ts

@@ -17,24 +17,49 @@ export interface MCPToolsLoadResult {
 	errors: Array<{ path: string; error: string }>;
 	/** Connected server names */
 	connectedServers: string[];
+	/** Extracted Exa API keys from filtered MCP servers */
+	exaApiKeys: string[];
+}
+
+/** Options for loading MCP tools */
+export interface MCPToolsLoadOptions {
+	/** Additional environment variables for expansion */
+	extraEnv?: Record<string, string>;
+	/** Called when starting to connect to servers */
+	onConnecting?: (serverNames: string[]) => void;
+	/** Whether to load project-level config (default: true) */
+	enableProjectConfig?: boolean;
+	/** Whether to filter out Exa MCP servers (default: true) */
+	filterExa?: boolean;
 }
 
 /**
  * Discover and load MCP tools from .mcp.json files.
  *
  * @param cwd Working directory (project root)
- * @param extraEnv Additional environment variables for expansion
+ * @param options Load options including extraEnv and progress callbacks
  * @returns MCP tools in LoadedCustomTool format for integration
  */
 export async function discoverAndLoadMCPTools(
 	cwd: string,
-	extraEnv?: Record<string, string>,
+	options?: MCPToolsLoadOptions | Record<string, string>,
 ): Promise<MCPToolsLoadResult> {
+	// Support old signature: discoverAndLoadMCPTools(cwd, extraEnv)
+	const opts: MCPToolsLoadOptions =
+		options && ("extraEnv" in options || "onConnecting" in options || "enableProjectConfig" in options)
+			? (options as MCPToolsLoadOptions)
+			: { extraEnv: options as Record<string, string> | undefined };
+
 	const manager = new MCPManager(cwd);
 
 	let result: MCPLoadResult;
 	try {
-		result = await manager.discoverAndConnect(extraEnv);
+		result = await manager.discoverAndConnect({
+			extraEnv: opts.extraEnv,
+			onConnecting: opts.onConnecting,
+			enableProjectConfig: opts.enableProjectConfig,
+			filterExa: opts.filterExa,
+		});
 	} catch (error) {
 		// If discovery fails entirely, return empty result
 		const message = error instanceof Error ? error.message : String(error);
@@ -43,6 +68,7 @@ export async function discoverAndLoadMCPTools(
 			tools: [],
 			errors: [{ path: ".mcp.json", error: message }],
 			connectedServers: [],
+			exaApiKeys: [],
 		};
 	}
 
@@ -64,5 +90,6 @@ export async function discoverAndLoadMCPTools(
 		tools: loadedTools,
 		errors,
 		connectedServers: result.connectedServers,
+		exaApiKeys: result.exaApiKeys,
 	};
 }

package/src/core/mcp/manager.ts

@@ -8,7 +8,7 @@
 import type { TSchema } from "@sinclair/typebox";
 import type { CustomTool } from "../custom-tools/types.js";
 import { connectToServer, disconnectServer, listTools } from "./client.js";
-import { loadAllMCPConfigs, validateServerConfig } from "./config.js";
+import { type LoadMCPConfigsOptions, loadAllMCPConfigs, validateServerConfig } from "./config.js";
 import type { MCPToolDetails } from "./tool-bridge.js";
 import { createMCPTools } from "./tool-bridge.js";
 import type { MCPServerConfig, MCPServerConnection } from "./types.js";
@@ -21,6 +21,14 @@ export interface MCPLoadResult {
 	errors: Map<string, string>;
 	/** Connected server names */
 	connectedServers: string[];
+	/** Extracted Exa API keys from filtered MCP servers */
+	exaApiKeys: string[];
+}
+
+/** Options for discovering and connecting to MCP servers */
+export interface MCPDiscoverOptions extends LoadMCPConfigsOptions {
+	/** Called when starting to connect to servers */
+	onConnecting?: (serverNames: string[]) => void;
 }
 
 /**
@@ -38,19 +46,49 @@ export class MCPManager {
 	 * Discover and connect to all MCP servers from .mcp.json files.
 	 * Returns tools and any connection errors.
 	 */
-	async discoverAndConnect(extraEnv?: Record<string, string>): Promise<MCPLoadResult> {
-		const configs = loadAllMCPConfigs(this.cwd, extraEnv);
-		return this.connectServers(configs);
+	async discoverAndConnect(
+		extraEnvOrOptions?: Record<string, string> | MCPDiscoverOptions,
+		onConnecting?: (serverNames: string[]) => void,
+	): Promise<MCPLoadResult> {
+		// Support old signature: discoverAndConnect(extraEnv, onConnecting)
+		const opts: MCPDiscoverOptions =
+			extraEnvOrOptions &&
+			("extraEnv" in extraEnvOrOptions ||
+				"enableProjectConfig" in extraEnvOrOptions ||
+				"filterExa" in extraEnvOrOptions ||
+				"onConnecting" in extraEnvOrOptions)
+				? (extraEnvOrOptions as MCPDiscoverOptions)
+				: { extraEnv: extraEnvOrOptions as Record<string, string> | undefined, onConnecting };
+
+		const { configs, exaApiKeys } = loadAllMCPConfigs(this.cwd, {
+			extraEnv: opts.extraEnv,
+			enableProjectConfig: opts.enableProjectConfig,
+			filterExa: opts.filterExa,
+		});
+		const result = await this.connectServers(configs, opts.onConnecting);
+		result.exaApiKeys = exaApiKeys;
+		return result;
 	}
 
 	/**
 	 * Connect to specific MCP servers.
+	 * Connections are made in parallel for faster startup.
 	 */
-	async connectServers(configs: Record<string, MCPServerConfig>): Promise<MCPLoadResult> {
+	async connectServers(
+		configs: Record<string, MCPServerConfig>,
+		onConnecting?: (serverNames: string[]) => void,
+	): Promise<MCPLoadResult> {
 		const errors = new Map<string, string>();
 		const connectedServers: string[] = [];
 		const allTools: CustomTool<TSchema, MCPToolDetails>[] = [];
 
+		// Prepare connection tasks
+		const connectionTasks: Array<{
+			name: string;
+			config: MCPServerConfig;
+			validationErrors: string[];
+		}> = [];
+
 		for (const [name, config] of Object.entries(configs)) {
 			// Skip if already connected
 			if (this.connections.has(name)) {
@@ -65,17 +103,37 @@ export class MCPManager {
 				continue;
 			}
 
-			try {
+			connectionTasks.push({ name, config, validationErrors });
+		}
+
+		// Notify about servers we're connecting to
+		if (connectionTasks.length > 0 && onConnecting) {
+			onConnecting(connectionTasks.map((t) => t.name));
+		}
+
+		// Connect to all servers in parallel
+		const results = await Promise.allSettled(
+			connectionTasks.map(async ({ name, config }) => {
 				const connection = await connectToServer(name, config);
+				const serverTools = await listTools(connection);
+				return { name, connection, serverTools };
+			}),
+		);
+
+		// Process results
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			const { name } = connectionTasks[i];
+
+			if (result.status === "fulfilled") {
+				const { connection, serverTools } = result.value;
 				this.connections.set(name, connection);
 				connectedServers.push(name);
 
-				// Load tools from this server
-				const serverTools = await listTools(connection);
 				const customTools = createMCPTools(connection, serverTools);
 				allTools.push(...customTools);
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
+			} else {
+				const message = result.reason instanceof Error ? result.reason.message : String(result.reason);
 				errors.set(name, message);
 			}
 		}
@@ -87,6 +145,7 @@ export class MCPManager {
 			tools: allTools,
 			errors,
 			connectedServers,
+			exaApiKeys: [], // Will be populated by discoverAndConnect
 		};
 	}
 

package/src/core/mcp/types.ts

@@ -41,8 +41,14 @@ export type JsonRpcMessage = JsonRpcRequest | JsonRpcNotification | JsonRpcRespo
 // MCP Server Configuration (.mcp.json format)
 // =============================================================================
 
+/** Base server config with shared options */
+interface MCPServerConfigBase {
+	/** Connection timeout in milliseconds (default: 30000) */
+	timeout?: number;
+}
+
 /** Stdio server configuration */
-export interface MCPStdioServerConfig {
+export interface MCPStdioServerConfig extends MCPServerConfigBase {
 	type?: "stdio"; // Default if not specified
 	command: string;
 	args?: string[];
@@ -51,14 +57,14 @@ export interface MCPStdioServerConfig {
 }
 
 /** HTTP server configuration (Streamable HTTP transport) */
-export interface MCPHttpServerConfig {
+export interface MCPHttpServerConfig extends MCPServerConfigBase {
 	type: "http";
 	url: string;
 	headers?: Record<string, string>;
 }
 
 /** SSE server configuration (deprecated, use HTTP) */
-export interface MCPSseServerConfig {
+export interface MCPSseServerConfig extends MCPServerConfigBase {
 	type: "sse";
 	url: string;
 	headers?: Record<string, string>;

package/src/core/model-resolver.ts

@@ -30,6 +30,29 @@ export interface ScopedModel {
 	thinkingLevel: ThinkingLevel;
 }
 
+/** Priority chain for auto-discovering smol/fast models */
+export const SMOL_MODEL_PRIORITY = ["claude-haiku-4-5", "haiku", "flash", "mini"];
+
+/** Priority chain for auto-discovering slow/comprehensive models (reasoning, codex) */
+export const SLOW_MODEL_PRIORITY = ["gpt-5.2-codex", "gpt-5.2", "codex", "gpt", "opus", "pro"];
+
+/**
+ * Parse a model string in "provider/modelId" format.
+ * Returns undefined if the format is invalid.
+ */
+export function parseModelString(modelStr: string): { provider: string; id: string } | undefined {
+	const slashIdx = modelStr.indexOf("/");
+	if (slashIdx <= 0) return undefined;
+	return { provider: modelStr.slice(0, slashIdx), id: modelStr.slice(slashIdx + 1) };
+}
+
+/**
+ * Format a model as "provider/modelId" string.
+ */
+export function formatModelString(model: Model<Api>): string {
+	return `${model.provider}/${model.id}`;
+}
+
 /**
  * Helper to check if a model ID looks like an alias (no date suffix)
  * Dates are typically in format: -20241022 or -20250929
@@ -391,3 +414,81 @@ export async function restoreModelFromSession(
 	// No models available
 	return { model: undefined, fallbackMessage: undefined };
 }
+
+/**
+ * Find a smol/fast model using the priority chain.
+ * Tries exact matches first, then fuzzy matches.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available smol model, or undefined if none found
+ */
+export async function findSmolModel(
+	modelRegistry: ModelRegistry,
+	savedModel?: string,
+): Promise<Model<Api> | undefined> {
+	const availableModels = await modelRegistry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	// 1. Try saved model from settings
+	if (savedModel) {
+		const parsed = parseModelString(savedModel);
+		if (parsed) {
+			const match = availableModels.find((m) => m.provider === parsed.provider && m.id === parsed.id);
+			if (match) return match;
+		}
+	}
+
+	// 2. Try priority chain
+	for (const pattern of SMOL_MODEL_PRIORITY) {
+		// Try exact match first
+		const exactMatch = availableModels.find((m) => m.id.toLowerCase() === pattern.toLowerCase());
+		if (exactMatch) return exactMatch;
+
+		// Try fuzzy match (substring)
+		const fuzzyMatch = availableModels.find((m) => m.id.toLowerCase().includes(pattern.toLowerCase()));
+		if (fuzzyMatch) return fuzzyMatch;
+	}
+
+	// 3. Fallback to first available (same as default)
+	return availableModels[0];
+}
+
+/**
+ * Find a slow/comprehensive model using the priority chain.
+ * Prioritizes reasoning and codex models for thorough analysis.
+ *
+ * @param modelRegistry The model registry to search
+ * @param savedModel Optional saved model string from settings (provider/modelId)
+ * @returns The best available slow model, or undefined if none found
+ */
+export async function findSlowModel(
+	modelRegistry: ModelRegistry,
+	savedModel?: string,
+): Promise<Model<Api> | undefined> {
+	const availableModels = await modelRegistry.getAvailable();
+	if (availableModels.length === 0) return undefined;
+
+	// 1. Try saved model from settings
+	if (savedModel) {
+		const parsed = parseModelString(savedModel);
+		if (parsed) {
+			const match = availableModels.find((m) => m.provider === parsed.provider && m.id === parsed.id);
+			if (match) return match;
+		}
+	}
+
+	// 2. Try priority chain
+	for (const pattern of SLOW_MODEL_PRIORITY) {
+		// Try exact match first
+		const exactMatch = availableModels.find((m) => m.id.toLowerCase() === pattern.toLowerCase());
+		if (exactMatch) return exactMatch;
+
+		// Try fuzzy match (substring)
+		const fuzzyMatch = availableModels.find((m) => m.id.toLowerCase().includes(pattern.toLowerCase()));
+		if (fuzzyMatch) return fuzzyMatch;
+	}
+
+	// 3. Fallback to first available (same as default)
+	return availableModels[0];
+}

package/src/core/sdk.ts

@@ -78,6 +78,7 @@ import {
 	readOnlyTools,
 	readTool,
 	type Tool,
+	warmupLspServers,
 	writeTool,
 } from "./tools/index.js";
 
@@ -146,6 +147,8 @@ export interface CreateAgentSessionResult {
 	mcpManager?: MCPManager;
 	/** Warning if session was restored with a different model than saved */
 	modelFallbackMessage?: string;
+	/** LSP servers that were warmed up at startup */
+	lspServers?: Array<{ name: string; status: "ready" | "error"; fileTypes: string[] }>;
 }
 
 // Re-exports
@@ -323,8 +326,7 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 export function loadSettings(cwd?: string, agentDir?: string): Settings {
 	const manager = SettingsManager.create(cwd ?? process.cwd(), agentDir ?? getDefaultAgentDir());
 	return {
-		defaultProvider: manager.getDefaultProvider(),
-		defaultModel: manager.getDefaultModel(),
+		modelRoles: manager.getModelRoles(),
 		defaultThinkingLevel: manager.getDefaultThinkingLevel(),
 		queueMode: manager.getQueueMode(),
 		theme: manager.getTheme(),
@@ -479,24 +481,34 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let modelFallbackMessage: string | undefined;
 
 	// If session has data, try to restore model from it
-	if (!model && hasExistingSession && existingSession.model) {
-		const restoredModel = modelRegistry.find(existingSession.model.provider, existingSession.model.modelId);
-		if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
-			model = restoredModel;
-		}
-		if (!model) {
-			modelFallbackMessage = `Could not restore model ${existingSession.model.provider}/${existingSession.model.modelId}`;
+	const defaultModelStr = existingSession.models.default;
+	if (!model && hasExistingSession && defaultModelStr) {
+		const slashIdx = defaultModelStr.indexOf("/");
+		if (slashIdx > 0) {
+			const provider = defaultModelStr.slice(0, slashIdx);
+			const modelId = defaultModelStr.slice(slashIdx + 1);
+			const restoredModel = modelRegistry.find(provider, modelId);
+			if (restoredModel && (await modelRegistry.getApiKey(restoredModel))) {
+				model = restoredModel;
+			}
+			if (!model) {
+				modelFallbackMessage = `Could not restore model ${defaultModelStr}`;
+			}
 		}
 	}
 
 	// If still no model, try settings default
 	if (!model) {
-		const defaultProvider = settingsManager.getDefaultProvider();
-		const defaultModelId = settingsManager.getDefaultModel();
-		if (defaultProvider && defaultModelId) {
-			const settingsModel = modelRegistry.find(defaultProvider, defaultModelId);
-			if (settingsModel && (await modelRegistry.getApiKey(settingsModel))) {
-				model = settingsModel;
+		const settingsDefaultModel = settingsManager.getModelRole("default");
+		if (settingsDefaultModel) {
+			const slashIdx = settingsDefaultModel.indexOf("/");
+			if (slashIdx > 0) {
+				const provider = settingsDefaultModel.slice(0, slashIdx);
+				const modelId = settingsDefaultModel.slice(slashIdx + 1);
+				const settingsModel = modelRegistry.find(provider, modelId);
+				if (settingsModel && (await modelRegistry.getApiKey(settingsModel))) {
+					model = settingsModel;
+				}
 			}
 		}
 	}
@@ -566,7 +578,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const sessionContext = {
 		getSessionFile: () => sessionManager.getSessionFile() ?? null,
 	};
-	const builtInTools = options.tools ?? createCodingTools(cwd, options.hasUI ?? false, sessionContext);
+	const builtInTools =
+		options.tools ??
+		createCodingTools(cwd, options.hasUI ?? false, sessionContext, {
+			lspFormatOnWrite: settingsManager.getLspFormatOnWrite(),
+			lspDiagnosticsOnWrite: settingsManager.getLspDiagnosticsOnWrite(),
+			lspDiagnosticsOnEdit: settingsManager.getLspDiagnosticsOnEdit(),
+			editFuzzyMatch: settingsManager.getEditFuzzyMatch(),
+		});
 	time("createCodingTools");
 
 	let customToolsResult: CustomToolsLoadResult;
@@ -596,10 +615,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let mcpManager: MCPManager | undefined;
 	const enableMCP = options.enableMCP ?? true;
 	if (enableMCP) {
-		const mcpResult = await discoverAndLoadMCPTools(cwd);
+		const mcpResult = await discoverAndLoadMCPTools(cwd, {
+			onConnecting: (serverNames) => {
+				if (options.hasUI && serverNames.length > 0) {
+					process.stderr.write(`\x1b[90mConnecting to MCP servers: ${serverNames.join(", ")}...\x1b[0m\n`);
+				}
+			},
+			enableProjectConfig: settingsManager.getMCPProjectConfigEnabled(),
+			// Always filter Exa - we have native integration
+			filterExa: true,
+		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
 
+		// If we extracted Exa API keys from MCP configs and EXA_API_KEY isn't set, use the first one
+		if (mcpResult.exaApiKeys.length > 0 && !process.env.EXA_API_KEY) {
+			process.env.EXA_API_KEY = mcpResult.exaApiKeys[0];
+		}
+
 		// Log MCP errors
 		for (const { path, error } of mcpResult.errors) {
 			console.error(`MCP "${path}": ${error}`);
@@ -714,6 +747,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				}
 			: undefined,
 		queueMode: settingsManager.getQueueMode(),
+		interruptMode: settingsManager.getInterruptMode(),
 		getToolContext: toolContextStore.getContext,
 		getApiKey: async () => {
 			const currentModel = agent.state.model;
@@ -735,7 +769,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	} else {
 		// Save initial model and thinking level for new sessions so they can be restored on resume
 		if (model) {
-			sessionManager.appendModelChange(model.provider, model.id);
+			sessionManager.appendModelChange(`${model.provider}/${model.id}`);
 		}
 		sessionManager.appendThinkingLevelChange(thinkingLevel);
 	}
@@ -753,10 +787,23 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	});
 	time("createAgentSession");
 
+	// Warm up LSP servers (connects to detected servers)
+	let lspServers: CreateAgentSessionResult["lspServers"];
+	if (settingsManager.getLspDiagnosticsOnWrite()) {
+		try {
+			const result = await warmupLspServers(cwd);
+			lspServers = result.servers;
+			time("warmupLspServers");
+		} catch {
+			// Ignore warmup errors
+		}
+	}
+
 	return {
 		session,
 		customToolsResult,
 		mcpManager,
 		modelFallbackMessage,
+		lspServers,
 	};
 }