@oh-my-pi/pi-coding-agent 13.18.0 → 14.0.2

package/src/sdk.ts

@@ -7,8 +7,10 @@ import {
 	type ThinkingLevel,
 } from "@oh-my-pi/pi-agent-core";
 import type { Message, Model } from "@oh-my-pi/pi-ai";
-
-import { prewarmOpenAICodexResponses } from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
+import {
+	getOpenAICodexTransportDetails,
+	prewarmOpenAICodexResponses,
+} from "@oh-my-pi/pi-ai/providers/openai-codex-responses";
 import { SearchDb } from "@oh-my-pi/pi-natives";
 import type { Component } from "@oh-my-pi/pi-tui";
 import {
@@ -19,6 +21,7 @@ import {
 	getSearchDbDir,
 	logger,
 	postmortem,
+	prompt,
 } from "@oh-my-pi/pi-utils";
 import chalk from "chalk";
 import { AsyncJobManager } from "./async";
@@ -27,11 +30,7 @@ import { loadCapability } from "./capability";
 import { type Rule, ruleCapability } from "./capability/rule";
 import { ModelRegistry } from "./config/model-registry";
 import { formatModelString, parseModelPattern, parseModelString, resolveModelRoleValue } from "./config/model-resolver";
-import {
-	loadPromptTemplates as loadPromptTemplatesInternal,
-	type PromptTemplate,
-	renderPromptTemplate,
-} from "./config/prompt-templates";
+import { loadPromptTemplates as loadPromptTemplatesInternal, type PromptTemplate } from "./config/prompt-templates";
 import { Settings, type SkillsSettings } from "./config/settings";
 import { CursorExecHandlers } from "./cursor";
 import "./discovery";
@@ -74,6 +73,7 @@ import {
 	SkillProtocolHandler,
 } from "./internal-urls";
 import { disposeAllKernelSessions } from "./ipy/executor";
+import { LSP_STARTUP_EVENT_CHANNEL, type LspStartupEvent } from "./lsp/startup-events";
 import { discoverAndLoadMCPTools, type MCPManager, type MCPToolsLoadResult } from "./mcp";
 import {
 	collectDiscoverableMCPTools,
@@ -83,7 +83,13 @@ import {
 } from "./mcp/discoverable-tool-metadata";
 import { buildMemoryToolDeveloperInstructions, getMemoryRoot, startMemoryStartupTask } from "./memories";
 import asyncResultTemplate from "./prompts/tools/async-result.md" with { type: "text" };
-import { collectEnvSecrets, loadSecrets, obfuscateMessages, SecretObfuscator } from "./secrets";
+import {
+	collectEnvSecrets,
+	deobfuscateSessionContext,
+	loadSecrets,
+	obfuscateMessages,
+	SecretObfuscator,
+} from "./secrets";
 import { AgentSession } from "./session/agent-session";
 import { AuthStorage } from "./session/auth-storage";
 import { convertToLlm } from "./session/messages";
@@ -101,12 +107,14 @@ import {
 	BashTool,
 	BUILTIN_TOOLS,
 	createTools,
+	discoverStartupLspServers,
 	EditTool,
 	FindTool,
 	GrepTool,
 	getSearchTools,
 	HIDDEN_TOOLS,
 	isSearchProviderPreference,
+	type LspStartupServerInfo,
 	loadSshTool,
 	PythonTool,
 	ReadTool,
@@ -122,8 +130,9 @@ import {
 import { ToolContextStore } from "./tools/context";
 import { getGeminiImageTools } from "./tools/gemini-image";
 import { wrapToolWithMetaNotice } from "./tools/output-meta";
-import { PendingActionStore } from "./tools/pending-action";
+import { queueResolveHandler } from "./tools/resolve";
 import { EventBus } from "./utils/event-bus";
+import { buildNamedToolChoice } from "./utils/tool-choice";
 
 // Types
 export interface CreateAgentSessionOptions {
@@ -227,8 +236,10 @@ 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[]; error?: string }>;
+	/** LSP servers detected for startup; warmup may continue in the background */
+	lspServers?: LspStartupServerInfo[];
+	/** Shared event bus for tool/extension communication */
+	eventBus: EventBus;
 }
 
 // Re-exports
@@ -638,17 +649,12 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	registerPythonCleanup();
 
 	// Use provided or create AuthStorage and ModelRegistry
-	const { authStorage, modelRegistry } = await logger.timeAsync("discoverModels", async () => {
-		const authStorage = options.authStorage ?? (await discoverAuthStorage(agentDir));
-		const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
-		return { authStorage, modelRegistry };
-	});
+	const authStorage = options.authStorage ?? (await logger.time("discoverModels", discoverAuthStorage, agentDir));
+	const modelRegistry = options.modelRegistry ?? new ModelRegistry(authStorage);
 
-	const settings = await logger.timeAsync(
-		"settings",
-		async () => options.settings ?? (await Settings.init({ cwd, agentDir })),
-	);
-	logger.time("initializeWithSettings", initializeWithSettings, settings);
+	const settings = options.settings ?? (await logger.time("settings", Settings.init, { cwd, agentDir }));
+	logger.time("initializeWithSettings");
+	initializeWithSettings(settings);
 	if (!options.modelRegistry) {
 		modelRegistry.refreshInBackground();
 	}
@@ -691,9 +697,24 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		return hasKey;
 	};
 
+	// Load and create secret obfuscator early so resumed session state and prompt warnings
+	// reflect actual loaded secrets, not just the setting toggle.
+	let obfuscator: SecretObfuscator | undefined;
+	if (settings.get("secrets.enabled")) {
+		const fileEntries = await logger.time("loadSecrets", loadSecrets, cwd, agentDir);
+		const envEntries = collectEnvSecrets();
+		const allEntries = [...envEntries, ...fileEntries];
+		if (allEntries.length > 0) {
+			obfuscator = new SecretObfuscator(allEntries);
+		}
+	}
+	const secretsEnabled = obfuscator?.hasSecrets() === true;
+
 	// Check if session has existing data to restore
-	const existingSession = logger.time("loadSession", () => sessionManager.buildSessionContext());
-	const existingBranch = sessionManager.getBranch();
+	const existingSession = logger.time("loadSessionContext", () =>
+		deobfuscateSessionContext(sessionManager.buildSessionContext(), obfuscator),
+	);
+	const existingBranch = logger.time("getSessionBranch", () => sessionManager.getBranch());
 	const hasExistingSession = existingBranch.length > 0;
 	const hasThinkingEntry = existingBranch.some(entry => entry.type === "thinking_level_change");
 	const hasServiceTierEntry = existingBranch.some(entry => entry.type === "service_tier_change");
@@ -702,34 +723,41 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const modelMatchPreferences = {
 		usageOrder: settings.getStorage()?.getModelUsageOrder(),
 	};
-	const defaultRoleSpec = resolveModelRoleValue(settings.getModelRole("default"), modelRegistry.getAvailable(), {
-		settings,
-		matchPreferences: modelMatchPreferences,
-	});
+	const defaultRoleSpec = logger.time("resolveDefaultModelRole", () =>
+		resolveModelRoleValue(settings.getModelRole("default"), modelRegistry.getAvailable(), {
+			settings,
+			matchPreferences: modelMatchPreferences,
+		}),
+	);
 	let model = options.model;
 	let modelFallbackMessage: string | undefined;
 	// If session has data, try to restore model from it.
 	// Skip restore when an explicit model was requested.
 	const defaultModelStr = existingSession.models.default;
 	if (!hasExplicitModel && !model && hasExistingSession && defaultModelStr) {
-		const parsedModel = parseModelString(defaultModelStr);
-		if (parsedModel) {
-			const restoredModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
-			if (restoredModel && (await hasModelApiKey(restoredModel))) {
-				model = restoredModel;
+		await logger.time("restoreSessionModel", async () => {
+			const parsedModel = parseModelString(defaultModelStr);
+			if (parsedModel) {
+				const restoredModel = modelRegistry.find(parsedModel.provider, parsedModel.id);
+				if (restoredModel && (await hasModelApiKey(restoredModel))) {
+					model = restoredModel;
+				}
 			}
-		}
-		if (!model) {
-			modelFallbackMessage = `Could not restore model ${defaultModelStr}`;
-		}
+			if (!model) {
+				modelFallbackMessage = `Could not restore model ${defaultModelStr}`;
+			}
+		});
 	}
 
 	// If still no model, try settings default.
 	// Skip settings fallback when an explicit model was requested.
 	if (!hasExplicitModel && !model && defaultRoleSpec.model) {
-		if (await hasModelApiKey(defaultRoleSpec.model)) {
-			model = defaultRoleSpec.model;
-		}
+		const settingsDefaultModel = defaultRoleSpec.model;
+		logger.time("resolveSettingsDefaultModel", () => {
+			// defaultRoleSpec.model already comes from modelRegistry.getAvailable(),
+			// so re-validating auth here just repeats the expensive lookup path.
+			model = settingsDefaultModel;
+		});
 	}
 
 	const taskDepth = options.taskDepth ?? 0;
@@ -750,7 +778,10 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		thinkingLevel = settings.get("defaultThinkingLevel");
 	}
 	if (model) {
-		thinkingLevel = resolveThinkingLevelForModel(model, thinkingLevel);
+		const resolvedModel = model;
+		thinkingLevel = logger.time("resolveThinkingLevelForModel", () =>
+			resolveThinkingLevelForModel(resolvedModel, thinkingLevel),
+		);
 	}
 
 	let skills: Skill[];
@@ -759,55 +790,44 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		skills = options.skills;
 		skillWarnings = [];
 	} else {
-		const discovered = await logger.timeAsync("discoverSkills", async () =>
-			discoveredSkillsPromise ? await discoveredSkillsPromise : { skills: [], warnings: [] },
+		const discovered = await logger.time(
+			"discoverSkills",
+			() => discoveredSkillsPromise ?? Promise.resolve({ skills: [], warnings: [] }),
 		);
 		skills = discovered.skills;
 		skillWarnings = discovered.warnings;
 	}
 
-	// Discover rules
-	const { ttsrManager, rulesResult, registeredTtsrRuleNames } = await logger.timeAsync(
-		"discoverTtsrRules",
-		async () => {
-			const ttsrSettings = settings.getGroup("ttsr");
-			const ttsrManager = new TtsrManager(ttsrSettings);
-			const rulesResult =
-				options.rules !== undefined
-					? { items: options.rules, warnings: undefined }
-					: await loadCapability<Rule>(ruleCapability.id, { cwd });
-			const registeredTtsrRuleNames = new Set<string>();
-			for (const rule of rulesResult.items) {
-				if (rule.condition && rule.condition.length > 0) {
-					if (ttsrManager.addRule(rule)) {
-						registeredTtsrRuleNames.add(rule.name);
-					}
-				}
+	// Discover rules and bucket them in one pass to avoid repeated scans over large rule sets.
+	const { ttsrManager, rulebookRules, alwaysApplyRules } = await logger.time("discoverTtsrRules", async () => {
+		const ttsrSettings = settings.getGroup("ttsr");
+		const ttsrManager = new TtsrManager(ttsrSettings);
+		const rulesResult =
+			options.rules !== undefined
+				? { items: options.rules, warnings: undefined }
+				: await loadCapability<Rule>(ruleCapability.id, { cwd });
+		const rulebookRules: Rule[] = [];
+		const alwaysApplyRules: Rule[] = [];
+		for (const rule of rulesResult.items) {
+			const isTtsrRule = rule.condition && rule.condition.length > 0 ? ttsrManager.addRule(rule) : false;
+			if (isTtsrRule) {
+				continue;
 			}
-			if (existingSession.injectedTtsrRules.length > 0) {
-				ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
+			if (rule.alwaysApply === true) {
+				alwaysApplyRules.push(rule);
+				continue;
 			}
-			return { ttsrManager, rulesResult, registeredTtsrRuleNames };
-		},
-	);
-
-	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
-	const rulebookRules = logger.time("filterRulebookRules", () =>
-		rulesResult.items.filter((rule: Rule) => {
-			if (registeredTtsrRuleNames.has(rule.name)) return false;
-			if (rule.alwaysApply) return false;
-			if (!rule.description) return false;
-			return true;
-		}),
-	);
-
-	// collect alwaysApply rules — full content injected into system prompt
-	const alwaysApplyRules = rulesResult.items.filter((rule: Rule) => {
-		if (registeredTtsrRuleNames.has(rule.name)) return false;
-		return rule.alwaysApply === true;
+			if (rule.description) {
+				rulebookRules.push(rule);
+			}
+		}
+		if (existingSession.injectedTtsrRules.length > 0) {
+			ttsrManager.restoreInjected(existingSession.injectedTtsrRules);
+		}
+		return { ttsrManager, rulebookRules, alwaysApplyRules };
 	});
 
-	const contextFiles = await logger.timeAsync(
+	const contextFiles = await logger.time(
 		"discoverContextFiles",
 		async () => options.contextFiles ?? (await discoverContextFiles(cwd, agentDir)),
 	);
@@ -846,7 +866,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				onJobComplete: async (jobId, result, job) => {
 					if (!session) return;
 					const formattedResult = await formatAsyncResultForFollowUp(result);
-					const message = renderPromptTemplate(asyncResultTemplate, { jobId, result: formattedResult });
+					const message = prompt.render(asyncResultTemplate, { jobId, result: formattedResult });
 					const durationMs = job ? Math.max(0, Date.now() - job.startTime) : undefined;
 					await session.sendCustomMessage(
 						{
@@ -868,7 +888,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		: undefined;
 
 	const searchDb = options.searchDb ?? new SearchDb(getSearchDbDir(agentDir));
-	const pendingActionStore = new PendingActionStore();
 	const toolSession: ToolSession = {
 		cwd,
 		hasUI: options.hasUI ?? false,
@@ -905,6 +924,22 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		activateDiscoveredMCPTools: toolNames => session.activateDiscoveredMCPTools(toolNames),
 		getCheckpointState: () => session.getCheckpointState(),
 		setCheckpointState: state => session.setCheckpointState(state ?? undefined),
+		getToolChoiceQueue: () => session.toolChoiceQueue,
+		buildToolChoice: name => {
+			const m = session.model;
+			return m ? buildNamedToolChoice(name, m) : undefined;
+		},
+		steer: msg =>
+			session.agent.steer({
+				role: "custom",
+				customType: msg.customType,
+				content: msg.content,
+				display: false,
+				details: msg.details,
+				attribution: "agent",
+				timestamp: Date.now(),
+			}),
+		peekQueueInvoker: () => session.peekQueueInvoker(),
 		allocateOutputArtifact: async toolType => {
 			try {
 				return await sessionManager.allocateArtifactPath(toolType);
@@ -916,7 +951,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		authStorage,
 		modelRegistry,
 		asyncJobManager,
-		pendingActionStore,
 		searchDb,
 	};
 
@@ -957,29 +991,27 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	);
 
 	// Create built-in tools (already wrapped with meta notice formatting)
-	const builtinTools = await logger.timeAsync("createAllTools", () => createTools(toolSession, options.toolNames));
+	const builtinTools = await logger.time("createAllTools", createTools, toolSession, options.toolNames);
 
 	// Discover MCP tools from .mcp.json files
 	let mcpManager: MCPManager | undefined;
 	const enableMCP = options.enableMCP ?? true;
 	const customTools: CustomTool[] = [];
 	if (enableMCP) {
-		const mcpResult = await logger.timeAsync("discoverAndLoadMCPTools", () =>
-			discoverAndLoadMCPTools(cwd, {
-				onConnecting: serverNames => {
-					if (options.hasUI && serverNames.length > 0) {
-						process.stderr.write(`${chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}…`)}\n`);
-					}
-				},
-				enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
-				// Always filter Exa - we have native integration
-				filterExa: true,
-				// Filter browser MCP servers when builtin browser tool is active
-				filterBrowser: settings.get("browser.enabled") ?? false,
-				cacheStorage: settings.getStorage(),
-				authStorage,
-			}),
-		);
+		const mcpResult = await logger.time("discoverAndLoadMCPTools", discoverAndLoadMCPTools, cwd, {
+			onConnecting: serverNames => {
+				if (options.hasUI && serverNames.length > 0) {
+					process.stderr.write(`${chalk.gray(`Connecting to MCP servers: ${serverNames.join(", ")}…`)}\n`);
+				}
+			},
+			enableProjectConfig: settings.get("mcp.enableProjectConfig") ?? true,
+			// Always filter Exa - we have native integration
+			filterExa: true,
+			// Filter browser MCP servers when builtin browser tool is active
+			filterBrowser: settings.get("browser.enabled") ?? false,
+			cacheStorage: settings.getStorage(),
+			authStorage,
+		});
 		mcpManager = mcpResult.manager;
 		toolSession.mcpManager = mcpManager;
 
@@ -1003,7 +1035,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 
 	// Add Gemini image tools if GEMINI_API_KEY (or GOOGLE_API_KEY) is available
-	const geminiImageTools = await logger.timeAsync("getGeminiImageTools", getGeminiImageTools);
+	const geminiImageTools = await logger.time("getGeminiImageTools", getGeminiImageTools);
 	if (geminiImageTools.length > 0) {
 		customTools.push(...(geminiImageTools as unknown as CustomTool[]));
 	}
@@ -1015,13 +1047,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Discover and load custom tools from .omp/tools/, .claude/tools/, etc.
 	const builtInToolNames = builtinTools.map(t => t.name);
-	const discoveredCustomTools = await logger.timeAsync(
+	const discoveredCustomTools = await logger.time(
 		"discoverAndLoadCustomTools",
 		discoverAndLoadCustomTools,
 		[],
 		cwd,
 		builtInToolNames,
-		pendingActionStore,
+		action => queueResolveHandler(toolSession, action),
 	);
 	for (const { path, error } of discoveredCustomTools.errors) {
 		logger.error("Custom tool load failed", { path, error });
@@ -1040,7 +1072,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	let extensionsResult: LoadExtensionsResult;
 	if (options.disableExtensionDiscovery) {
 		const configuredPaths = options.additionalExtensionPaths ?? [];
-		extensionsResult = await logger.timeAsync("loadExtensions", loadExtensions, configuredPaths, cwd, eventBus);
+		extensionsResult = await logger.time("loadExtensions", loadExtensions, configuredPaths, cwd, eventBus);
 		for (const { path, error } of extensionsResult.errors) {
 			logger.error("Failed to load extension", { path, error });
 		}
@@ -1050,7 +1082,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		// Merge CLI extension paths with settings extension paths
 		const configuredPaths = [...(options.additionalExtensionPaths ?? []), ...(settings.get("extensions") ?? [])];
 		const disabledExtensionIds = settings.get("disabledExtensions") ?? [];
-		extensionsResult = await logger.timeAsync(
+		extensionsResult = await logger.time(
 			"discoverAndLoadExtensions",
 			discoverAndLoadExtensions,
 			configuredPaths,
@@ -1131,7 +1163,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	// Discover custom commands (TypeScript slash commands)
 	const customCommandsResult: CustomCommandsLoadResult = options.disableExtensionDiscovery
 		? { commands: [], errors: [] }
-		: await logger.timeAsync("discoverCustomCommands", loadCustomCommandsInternal, { cwd, agentDir });
+		: await logger.time("discoverCustomCommands", loadCustomCommandsInternal, { cwd, agentDir });
 	if (!options.disableExtensionDiscovery) {
 		for (const { path, error } of customCommandsResult.errors) {
 			logger.error("Failed to load custom command", { path, error });
@@ -1214,7 +1246,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	if (!hasDeferrableTools) {
 		toolRegistry.delete("resolve");
 	} else if (!toolRegistry.has("resolve")) {
-		const resolveTool = await logger.timeAsync("createTools:resolve:session", HIDDEN_TOOLS.resolve, toolSession);
+		const resolveTool = await logger.time("createTools:resolve:session", HIDDEN_TOOLS.resolve, toolSession);
 		if (resolveTool) {
 			toolRegistry.set(resolveTool.name, wrapToolWithMetaNotice(resolveTool));
 		}
@@ -1276,6 +1308,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			mcpDiscoveryMode: hasDiscoverableMCPTools,
 			mcpDiscoveryServerSummaries: discoverableMCPSummary.servers.map(formatDiscoverableMCPToolServerSummary),
 			eagerTasks,
+			secretsEnabled,
 		});
 
 		if (options.systemPrompt === undefined) {
@@ -1298,6 +1331,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 				mcpDiscoveryMode: hasDiscoverableMCPTools,
 				mcpDiscoveryServerSummaries: discoverableMCPSummary.servers.map(formatDiscoverableMCPToolServerSummary),
 				eagerTasks,
+				secretsEnabled,
 			});
 		}
 		return options.systemPrompt(defaultPrompt);
@@ -1362,20 +1396,14 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		}
 	}
 
-	const systemPrompt = await logger.timeAsync(
-		"buildSystemPrompt",
-		rebuildSystemPrompt,
-		initialToolNames,
-		toolRegistry,
-	);
+	const systemPrompt = await logger.time("buildSystemPrompt", rebuildSystemPrompt, initialToolNames, toolRegistry);
 
 	const promptTemplates =
-		options.promptTemplates ??
-		(await logger.timeAsync("discoverPromptTemplates", discoverPromptTemplates, cwd, agentDir));
+		options.promptTemplates ?? (await logger.time("discoverPromptTemplates", discoverPromptTemplates, cwd, agentDir));
 	toolSession.promptTemplates = promptTemplates;
 
 	const slashCommands =
-		options.slashCommands ?? (await logger.timeAsync("discoverSlashCommands", discoverSlashCommands, cwd));
+		options.slashCommands ?? (await logger.time("discoverSlashCommands", discoverSlashCommands, cwd));
 
 	// Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
 	const convertToLlmWithBlockImages = (messages: AgentMessage[]): Message[] => {
@@ -1407,17 +1435,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		});
 	};
 
-	// Load and create secret obfuscator if secrets are enabled
-	let obfuscator: SecretObfuscator | undefined;
-	if (settings.get("secrets.enabled")) {
-		const fileEntries = await logger.timeAsync("loadSecrets", loadSecrets, cwd, agentDir);
-		const envEntries = collectEnvSecrets();
-		const allEntries = [...envEntries, ...fileEntries];
-		if (allEntries.length > 0) {
-			obfuscator = new SecretObfuscator(allEntries);
-		}
-	}
-
 	// Final convertToLlm: chain block-images filter with secret obfuscation
 	const convertToLlmFinal = (messages: AgentMessage[]): Message[] => {
 		const converted = convertToLlmWithBlockImages(messages);
@@ -1501,13 +1518,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return result;
 		},
 		intentTracing: !!intentField,
-		getToolChoice: () => {
-			if (pendingActionStore.hasPending) {
-				return { type: "function", name: "resolve" };
-			}
-			return session?.consumeNextToolChoiceOverride();
-		},
+		getToolChoice: () => session?.nextToolChoice(),
 	});
+
 	cursorEventEmitter = event => agent.emitExternalEvent(event);
 
 	// Restore messages if session has existing data
@@ -1548,51 +1561,87 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		ttsrManager,
 		obfuscator,
 		asyncJobManager,
-		pendingActionStore,
 		searchDb,
 	});
 
 	if (model?.api === "openai-codex-responses") {
-		try {
-			await logger.timeAsync("prewarmCodexWebsocket", prewarmOpenAICodexResponses, model, {
-				apiKey: await modelRegistry.getApiKey(model, providerSessionId),
-				sessionId: providerSessionId,
-				preferWebsockets: preferOpenAICodexWebsockets,
-				providerSessionState: session.providerSessionState,
-			});
-		} catch (error) {
-			logger.debug("Codex websocket prewarm failed", {
-				error: error instanceof Error ? error.message : String(error),
-				provider: model.provider,
-				model: model.id,
-			});
+		const codexModel = model;
+		const codexTransport = getOpenAICodexTransportDetails(codexModel, {
+			sessionId: providerSessionId,
+			baseUrl: codexModel.baseUrl,
+			preferWebsockets: preferOpenAICodexWebsockets,
+			providerSessionState: session.providerSessionState,
+		});
+		if (codexTransport.websocketPreferred) {
+			void (async () => {
+				try {
+					const codexPrewarmApiKey = await modelRegistry.getApiKey(codexModel, providerSessionId);
+					if (!codexPrewarmApiKey) return;
+					await logger.time("prewarmOpenAICodexResponses", prewarmOpenAICodexResponses, codexModel, {
+						apiKey: codexPrewarmApiKey,
+						sessionId: providerSessionId,
+						preferWebsockets: preferOpenAICodexWebsockets,
+						providerSessionState: session.providerSessionState,
+					});
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					logger.debug("Codex websocket prewarm failed", {
+						error: errorMessage,
+						provider: codexModel.provider,
+						model: codexModel.id,
+					});
+				}
+			})();
 		}
 	}
 
-	// Warm up LSP servers (connects to detected servers)
+	// Start LSP warmup in the background so startup does not block on language server initialization.
 	let lspServers: CreateAgentSessionResult["lspServers"];
 	if (enableLsp && settings.get("lsp.diagnosticsOnWrite")) {
-		try {
-			const result = await logger.timeAsync("warmupLspServers", warmupLspServers, cwd, {
-				onConnecting: serverNames => {
-					if (options.hasUI && serverNames.length > 0) {
-						process.stderr.write(chalk.gray(`Starting LSP servers: ${serverNames.join(", ")}…\n`));
+		lspServers = discoverStartupLspServers(cwd);
+		if (lspServers.length > 0) {
+			void (async () => {
+				try {
+					const result = await logger.time("warmupLspServers", warmupLspServers, cwd);
+					const serversByName = new Map(result.servers.map(server => [server.name, server] as const));
+					for (const server of lspServers ?? []) {
+						const next = serversByName.get(server.name);
+						if (!next) continue;
+						server.status = next.status;
+						server.fileTypes = next.fileTypes;
+						server.error = next.error;
 					}
-				},
-			});
-			lspServers = result.servers;
-		} catch (error) {
-			logger.warn("LSP server warmup failed", { cwd, error: String(error) });
+					const event: LspStartupEvent = {
+						type: "completed",
+						servers: result.servers,
+					};
+					eventBus.emit(LSP_STARTUP_EVENT_CHANNEL, event);
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error);
+					logger.warn("LSP server warmup failed", { cwd, error: errorMessage });
+					for (const server of lspServers ?? []) {
+						server.status = "error";
+						server.error = errorMessage;
+					}
+					const event: LspStartupEvent = {
+						type: "failed",
+						error: errorMessage,
+					};
+					eventBus.emit(LSP_STARTUP_EVENT_CHANNEL, event);
+				}
+			})();
 		}
 	}
 
-	startMemoryStartupTask({
-		session,
-		settings,
-		modelRegistry,
-		agentDir,
-		taskDepth,
-	});
+	logger.time("startMemoryStartupTask", () =>
+		startMemoryStartupTask({
+			session,
+			settings,
+			modelRegistry,
+			agentDir,
+			taskDepth,
+		}),
+	);
 
 	// Wire MCP manager callbacks to session for reactive tool updates
 	if (mcpManager) {
@@ -1632,6 +1681,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		});
 	}
 
+	logger.time("createAgentSession:return");
 	return {
 		session,
 		extensionsResult,
@@ -1639,5 +1689,6 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		mcpManager,
 		modelFallbackMessage,
 		lspServers,
+		eventBus,
 	};
 }

package/src/secrets/index.ts

@@ -4,7 +4,7 @@ import { YAML } from "bun";
 import type { SecretEntry } from "./obfuscator";
 import { compileSecretRegex } from "./regex";
 
-export { obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
+export { deobfuscateSessionContext, obfuscateMessages, type SecretEntry, SecretObfuscator } from "./obfuscator";
 
 /**
  * Load secrets from project-local and global secrets.yml files.