@oh-my-pi/pi-coding-agent 4.2.1 → 4.2.2

package/src/core/agent-storage.ts

@@ -118,6 +118,9 @@ export class AgentStorage {
 	private listSettingsStmt: Statement;
 	private insertSettingStmt: Statement;
 	private deleteSettingsStmt: Statement;
+	private getCacheStmt: Statement;
+	private upsertCacheStmt: Statement;
+	private deleteExpiredCacheStmt: Statement;
 	private listAuthStmt: Statement;
 	private listAuthByProviderStmt: Statement;
 	private insertAuthStmt: Statement;
@@ -139,6 +142,12 @@ export class AgentStorage {
 		);
 		this.deleteSettingsStmt = this.db.prepare("DELETE FROM settings");
 
+		this.getCacheStmt = this.db.prepare("SELECT value FROM cache WHERE key = ? AND expires_at > unixepoch()");
+		this.upsertCacheStmt = this.db.prepare(
+			"INSERT INTO cache (key, value, expires_at) VALUES (?, ?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value, expires_at = excluded.expires_at",
+		);
+		this.deleteExpiredCacheStmt = this.db.prepare("DELETE FROM cache WHERE expires_at <= unixepoch()");
+
 		this.listAuthStmt = this.db.prepare(
 			"SELECT id, provider, credential_type, data FROM auth_credentials ORDER BY id ASC",
 		);
@@ -175,6 +184,13 @@ CREATE TABLE IF NOT EXISTS auth_credentials (
 );
 CREATE INDEX IF NOT EXISTS idx_auth_provider ON auth_credentials(provider);
 
+CREATE TABLE IF NOT EXISTS cache (
+	key TEXT PRIMARY KEY,
+	value TEXT NOT NULL,
+	expires_at INTEGER NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_cache_expires ON cache(expires_at);
+
 CREATE TABLE IF NOT EXISTS schema_version (version INTEGER PRIMARY KEY);
 `);
 
@@ -302,6 +318,40 @@ CREATE TABLE settings (
 		}
 	}
 
+	/**
+	 * Gets a cached value by key. Returns null if not found or expired.
+	 */
+	getCache(key: string): string | null {
+		try {
+			const row = this.getCacheStmt.get(key) as { value?: string } | undefined;
+			return row?.value ?? null;
+		} catch {
+			return null;
+		}
+	}
+
+	/**
+	 * Sets a cached value with expiry time (unix seconds).
+	 */
+	setCache(key: string, value: string, expiresAtSec: number): void {
+		try {
+			this.upsertCacheStmt.run(key, value, expiresAtSec);
+		} catch (error) {
+			logger.warn("AgentStorage failed to set cache", { key, error: String(error) });
+		}
+	}
+
+	/**
+	 * Deletes expired cache entries. Call periodically for cleanup.
+	 */
+	cleanExpiredCache(): void {
+		try {
+			this.deleteExpiredCacheStmt.run();
+		} catch {
+			// Ignore cleanup errors
+		}
+	}
+
 	/**
 	 * Checks if any auth credentials exist in storage.
 	 * @returns True if at least one credential is stored

package/src/core/auth-storage.ts

@@ -35,6 +35,22 @@ export type AuthCredentialEntry = AuthCredential | AuthCredential[];
 
 export type AuthStorageData = Record<string, AuthCredentialEntry>;
 
+/**
+ * Serialized representation of AuthStorage for passing to subagent workers.
+ * Contains only the essential credential data, not runtime state.
+ */
+export interface SerializedAuthStorage {
+	credentials: Record<
+		string,
+		Array<{
+			id: number;
+			type: "api_key" | "oauth";
+			data: Record<string, unknown>;
+		}>
+	>;
+	runtimeOverrides?: Record<string, string>;
+}
+
 /**
  * In-memory representation pairing DB row ID with credential.
  * The ID is required for update/delete operations against agent.db.
@@ -116,6 +132,63 @@ export class AuthStorage {
 		this.storage = AgentStorage.open(this.dbPath);
 	}
 
+	/**
+	 * Create an in-memory AuthStorage instance from serialized data.
+	 * Used by subagent workers to bypass discovery and use parent's credentials.
+	 */
+	static fromSerialized(data: SerializedAuthStorage): AuthStorage {
+		const instance = Object.create(AuthStorage.prototype) as AuthStorage;
+		instance.data = new Map();
+		instance.runtimeOverrides = new Map();
+		instance.providerRoundRobinIndex = new Map();
+		instance.sessionLastCredential = new Map();
+		instance.credentialBackoff = new Map();
+		instance.codexUsageCache = new Map();
+
+		for (const [provider, creds] of Object.entries(data.credentials)) {
+			instance.data.set(
+				provider,
+				creds.map((c) => ({
+					id: c.id,
+					credential:
+						c.type === "api_key"
+							? ({ type: "api_key", key: c.data.key as string } satisfies ApiKeyCredential)
+							: ({ type: "oauth", ...c.data } as OAuthCredential),
+				})),
+			);
+		}
+		if (data.runtimeOverrides) {
+			for (const [k, v] of Object.entries(data.runtimeOverrides)) {
+				instance.runtimeOverrides.set(k, v);
+			}
+		}
+
+		return instance;
+	}
+
+	/**
+	 * Serialize AuthStorage for passing to subagent workers.
+	 * Excludes runtime state (round-robin, backoff, usage cache).
+	 */
+	serialize(): SerializedAuthStorage {
+		const credentials: SerializedAuthStorage["credentials"] = {};
+		for (const [provider, creds] of this.data.entries()) {
+			credentials[provider] = creds.map((c) => ({
+				id: c.id,
+				type: c.credential.type,
+				data: c.credential.type === "api_key" ? { key: c.credential.key } : { ...c.credential },
+			}));
+		}
+		const runtimeOverrides: Record<string, string> = {};
+		for (const [k, v] of this.runtimeOverrides.entries()) {
+			runtimeOverrides[k] = v;
+		}
+		return {
+			credentials,
+			runtimeOverrides: Object.keys(runtimeOverrides).length > 0 ? runtimeOverrides : undefined,
+		};
+	}
+
 	/**
 	 * Converts legacy auth.json path to agent.db path, or returns .db path as-is.
 	 * @param authPath - Path to auth.json or agent.db
@@ -668,15 +741,41 @@ export class AuthStorage {
 		const normalizedBase = this.normalizeCodexBaseUrl(baseUrl);
 		const cacheKey = this.getCodexUsageCacheKey(accountId, normalizedBase);
 		const now = Date.now();
-		const cached = this.codexUsageCache.get(cacheKey);
-		if (cached && cached.expiresAt > now) {
-			return cached.usage;
+
+		// Check in-memory cache first (fastest)
+		const memCached = this.codexUsageCache.get(cacheKey);
+		if (memCached && memCached.expiresAt > now) {
+			return memCached.usage;
+		}
+
+		// Check DB cache (survives restarts)
+		const dbCached = this.storage.getCache(`codex_usage:${cacheKey}`);
+		if (dbCached) {
+			try {
+				const parsed = JSON.parse(dbCached) as CodexUsage;
+				// Store in memory for faster subsequent access
+				this.codexUsageCache.set(cacheKey, {
+					fetchedAt: now,
+					expiresAt: now + AuthStorage.codexUsageCacheTtlMs,
+					usage: parsed,
+				});
+				return parsed;
+			} catch {
+				// Invalid cache, continue to fetch
+			}
 		}
 
+		// Fetch from API
 		const usage = await this.fetchCodexUsage(credential, normalizedBase);
 		if (usage) {
 			const expiresAt = this.getCodexUsageExpiryMs(usage, now);
 			this.codexUsageCache.set(cacheKey, { fetchedAt: now, expiresAt, usage });
+			// Store in DB with 60s TTL
+			this.storage.setCache(
+				`codex_usage:${cacheKey}`,
+				JSON.stringify(usage),
+				Math.floor((now + AuthStorage.codexUsageCacheTtlMs) / 1000),
+			);
 			return usage;
 		}
 

package/src/core/bash-executor.ts

@@ -142,7 +142,7 @@ function createOutputSink(
  * @returns Promise resolving to execution result
  */
 export async function executeBash(command: string, options?: BashExecutorOptions): Promise<BashResult> {
-	const { shell, args, env, prefix } = getShellConfig();
+	const { shell, args, env, prefix } = await getShellConfig();
 
 	// Get or create shell snapshot (for aliases, functions, options)
 	const snapshotPath = await getOrCreateSnapshot(shell, env);

package/src/core/custom-tools/loader.ts

@@ -9,7 +9,7 @@ import * as os from "node:os";
 import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
 import { toolCapability } from "../../capability/tool";
-import { type CustomTool, loadSync } from "../../discovery";
+import { type CustomTool, loadCapability } from "../../discovery";
 import * as piCodingAgent from "../../index";
 import { theme } from "../../modes/interactive/theme/theme";
 import type { ExecOptions } from "../exec";
@@ -225,7 +225,7 @@ export async function discoverAndLoadCustomTools(
 	};
 
 	// 1. Discover tools via capability system (user + project from all providers)
-	const discoveredTools = loadSync<CustomTool>(toolCapability.id, { cwd });
+	const discoveredTools = await loadCapability<CustomTool>(toolCapability.id, { cwd });
 	for (const tool of discoveredTools.items) {
 		addPath(tool.path, {
 			provider: tool._source.provider,

package/src/core/extensions/loader.ts

@@ -8,7 +8,7 @@ import * as path from "node:path";
 import type { KeyId } from "@oh-my-pi/pi-tui";
 import * as TypeBox from "@sinclair/typebox";
 import { type ExtensionModule, extensionModuleCapability } from "../../capability/extension-module";
-import { loadSync } from "../../discovery";
+import { loadCapability } from "../../discovery";
 import { getExtensionNameFromPath } from "../../discovery/helpers";
 import * as piCodingAgent from "../../index";
 import { createEventBus, type EventBus } from "../event-bus";
@@ -408,7 +408,7 @@ export async function discoverAndLoadExtensions(
 	};
 
 	// 1. Discover extension modules via capability API (native .omp/.pi only)
-	const discovered = loadSync<ExtensionModule>(extensionModuleCapability.id, { cwd });
+	const discovered = await loadCapability<ExtensionModule>(extensionModuleCapability.id, { cwd });
 	for (const ext of discovered.items) {
 		if (ext._source.provider !== "native") continue;
 		if (isDisabledName(ext.name)) continue;

package/src/core/extensions/types.ts

@@ -756,7 +756,7 @@ export type GetActiveToolsHandler = () => string[];
 
 export type GetAllToolsHandler = () => string[];
 
-export type SetActiveToolsHandler = (toolNames: string[]) => void;
+export type SetActiveToolsHandler = (toolNames: string[]) => Promise<void>;
 
 export type SetModelHandler = (model: Model<any>) => Promise<boolean>;
 

package/src/core/hooks/loader.ts

@@ -7,7 +7,7 @@ import * as path from "node:path";
 import * as typebox from "@sinclair/typebox";
 import { hookCapability } from "../../capability/hook";
 import type { Hook } from "../../discovery";
-import { loadSync } from "../../discovery";
+import { loadCapability } from "../../discovery";
 import * as piCodingAgent from "../../index";
 import { logger } from "../logger";
 import type { HookMessage } from "../messages";
@@ -278,7 +278,7 @@ export async function discoverAndLoadHooks(configuredPaths: string[], cwd: strin
 	};
 
 	// 1. Discover hooks via capability API
-	const discovered = loadSync<Hook>(hookCapability.id, { cwd });
+	const discovered = await loadCapability<Hook>(hookCapability.id, { cwd });
 	addPaths(discovered.items.map((hook) => hook.path));
 
 	// 2. Explicitly configured paths (can override/add)

package/src/core/mcp/config.ts

@@ -6,7 +6,7 @@
 
 import { mcpCapability } from "../../capability/mcp";
 import type { MCPServer } from "../../discovery";
-import { load } from "../../discovery";
+import { loadCapability } from "../../discovery";
 import type { MCPServerConfig } from "./types";
 
 /** Options for loading MCP configs */
@@ -81,7 +81,7 @@ export async function loadAllMCPConfigs(cwd: string, options?: LoadMCPConfigsOpt
 	const filterExa = options?.filterExa ?? true;
 
 	// Load MCP servers via capability system
-	const result = await load<MCPServer>(mcpCapability.id, { cwd });
+	const result = await loadCapability<MCPServer>(mcpCapability.id, { cwd });
 
 	// Filter out project-level configs if disabled
 	const servers = enableProjectConfig

package/src/core/model-registry.ts

@@ -86,6 +86,15 @@ interface ProviderOverride {
 	apiKey?: string;
 }
 
+/**
+ * Serialized representation of ModelRegistry for passing to subagent workers.
+ */
+export interface SerializedModelRegistry {
+	models: Model<Api>[];
+	customProviderApiKeys?: Record<string, string>;
+	loadError?: string;
+}
+
 /** Result of loading custom models from models.json */
 interface CustomModelsResult {
 	models: Model<Api>[];
@@ -140,6 +149,43 @@ export class ModelRegistry {
 		this.loadModels();
 	}
 
+	/**
+	 * Create an in-memory ModelRegistry instance from serialized data.
+	 * Used by subagent workers to bypass discovery and use parent's models.
+	 */
+	static fromSerialized(data: SerializedModelRegistry, authStorage: AuthStorage): ModelRegistry {
+		const instance = Object.create(ModelRegistry.prototype) as ModelRegistry;
+		(instance as any).authStorage = authStorage;
+		instance.models = data.models;
+		instance.customProviderApiKeys = new Map(Object.entries(data.customProviderApiKeys ?? {}));
+		instance.loadError = data.loadError;
+
+		authStorage.setFallbackResolver((provider) => {
+			const keyConfig = instance.customProviderApiKeys.get(provider);
+			if (keyConfig) {
+				return resolveApiKeyConfig(keyConfig);
+			}
+			return undefined;
+		});
+
+		return instance;
+	}
+
+	/**
+	 * Serialize ModelRegistry for passing to subagent workers.
+	 */
+	serialize(): SerializedModelRegistry {
+		const customProviderApiKeys: Record<string, string> = {};
+		for (const [k, v] of this.customProviderApiKeys.entries()) {
+			customProviderApiKeys[k] = v;
+		}
+		return {
+			models: this.models,
+			customProviderApiKeys: Object.keys(customProviderApiKeys).length > 0 ? customProviderApiKeys : undefined,
+			loadError: this.loadError,
+		};
+	}
+
 	/**
 	 * Reload models from disk (built-in + custom from models.json).
 	 */

package/src/core/sdk.ts

@@ -33,7 +33,7 @@ import type { Component } from "@oh-my-pi/pi-tui";
 import chalk from "chalk";
 // Import discovery to register all providers on startup
 import "../discovery";
-import { loadSync as loadCapability } from "../capability/index";
+import { loadCapability } from "../capability/index";
 import { type Rule, ruleCapability } from "../capability/rule";
 import { getAgentDir, getConfigDirPaths } from "../config";
 import { initializeWithSettings } from "../discovery";
@@ -153,6 +153,9 @@ export interface CreateAgentSessionOptions {
 	/** Enable MCP server discovery from .mcp.json files. Default: true */
 	enableMCP?: boolean;
 
+	/** Enable LSP integration (tool, formatting, diagnostics, warmup). Default: true */
+	enableLsp?: boolean;
+
 	/** Tool names explicitly requested (enables disabled-by-default tools) */
 	toolNames?: string[];
 
@@ -286,12 +289,12 @@ export async function discoverExtensions(cwd?: string): Promise<LoadExtensionsRe
 /**
  * Discover skills from cwd and agentDir.
  */
-export function discoverSkills(
+export async function discoverSkills(
 	cwd?: string,
 	_agentDir?: string,
 	settings?: SkillsSettings,
-): { skills: Skill[]; warnings: SkillWarning[] } {
-	return loadSkillsInternal({
+): Promise<{ skills: Skill[]; warnings: SkillWarning[] }> {
+	return await loadSkillsInternal({
 		...settings,
 		cwd: cwd ?? process.cwd(),
 	});
@@ -301,11 +304,11 @@ export function discoverSkills(
  * Discover context files (AGENTS.md) walking up from cwd.
  * Returns files sorted by depth (farther from cwd first, so closer files appear last/more prominent).
  */
-export function discoverContextFiles(
+export async function discoverContextFiles(
 	cwd?: string,
 	_agentDir?: string,
-): Array<{ path: string; content: string; depth?: number }> {
-	return loadContextFilesInternal({
+): Promise<Array<{ path: string; content: string; depth?: number }>> {
+	return await loadContextFilesInternal({
 		cwd: cwd ?? process.cwd(),
 	});
 }
@@ -323,7 +326,7 @@ export async function discoverPromptTemplates(cwd?: string, agentDir?: string):
 /**
  * Discover file-based slash commands from commands/ directories.
  */
-export function discoverSlashCommands(cwd?: string): FileSlashCommand[] {
+export async function discoverSlashCommands(cwd?: string): Promise<FileSlashCommand[]> {
 	return loadSlashCommandsInternal({ cwd: cwd ?? process.cwd() });
 }
 
@@ -364,8 +367,8 @@ export interface BuildSystemPromptOptions {
 /**
  * Build the default system prompt.
  */
-export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): string {
-	return buildSystemPromptInternal({
+export async function buildSystemPrompt(options: BuildSystemPromptOptions = {}): Promise<string> {
+	return await buildSystemPromptInternal({
 		cwd: options.cwd,
 		skills: options.skills,
 		contextFiles: options.contextFiles,
@@ -378,8 +381,8 @@ export function buildSystemPrompt(options: BuildSystemPromptOptions = {}): strin
 /**
  * Load settings from agentDir/settings.json merged with cwd/.omp/settings.json.
  */
-export function loadSettings(cwd?: string, agentDir?: string): Settings {
-	const manager = SettingsManager.create(cwd ?? process.cwd(), agentDir ?? getDefaultAgentDir());
+export async function loadSettings(cwd?: string, agentDir?: string): Promise<Settings> {
+	const manager = await SettingsManager.create(cwd ?? process.cwd(), agentDir ?? getDefaultAgentDir());
 	return {
 		modelRoles: manager.getModelRoles(),
 		defaultThinkingLevel: manager.getDefaultThinkingLevel(),
@@ -543,7 +546,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	const modelRegistry = options.modelRegistry ?? (await discoverModels(authStorage, agentDir));
 	time("discoverModels");
 
-	const settingsManager = options.settingsManager ?? SettingsManager.create(cwd, agentDir);
+	const settingsManager = options.settingsManager ?? (await SettingsManager.create(cwd, agentDir));
 	time("settingsManager");
 	initializeWithSettings(settingsManager);
 	time("initializeWithSettings");
@@ -596,12 +599,11 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Fall back to first available model with a valid API key
 	if (!model) {
-		for (const m of modelRegistry.getAll()) {
-			if (await modelRegistry.getApiKey(m, sessionId)) {
-				model = m;
-				break;
-			}
-		}
+		const allModels = modelRegistry.getAll();
+		const keyResults = await Promise.all(
+			allModels.map(async (m) => ({ model: m, hasKey: !!(await modelRegistry.getApiKey(m, sessionId)) })),
+		);
+		model = keyResults.find((r) => r.hasKey)?.model;
 		time("findAvailableModel");
 		if (model) {
 			if (modelFallbackMessage) {
@@ -636,7 +638,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		skills = options.skills;
 		skillWarnings = [];
 	} else {
-		const discovered = discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
+		const discovered = await discoverSkills(cwd, agentDir, settingsManager.getSkillsSettings());
 		skills = discovered.skills;
 		skillWarnings = discovered.warnings;
 	}
@@ -644,7 +646,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Discover rules
 	const ttsrManager = createTtsrManager(settingsManager.getTtsrSettings());
-	const rulesResult = loadCapability<Rule>(ruleCapability.id, { cwd });
+	const rulesResult = await loadCapability<Rule>(ruleCapability.id, { cwd });
 	for (const rule of rulesResult.items) {
 		if (rule.ttsrTrigger) {
 			ttsrManager.addRule(rule);
@@ -653,7 +655,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	time("discoverTtsrRules");
 
 	// Filter rules for the rulebook (non-TTSR, non-alwaysApply, with descriptions)
-	const rulebookRules = rulesResult.items.filter((rule) => {
+	const rulebookRules = rulesResult.items.filter((rule: Rule) => {
 		if (rule.ttsrTrigger) return false;
 		if (rule.alwaysApply) return false;
 		if (!rule.description) return false;
@@ -661,15 +663,18 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	});
 	time("filterRulebookRules");
 
-	const contextFiles = options.contextFiles ?? discoverContextFiles(cwd, agentDir);
+	const contextFiles = options.contextFiles ?? (await discoverContextFiles(cwd, agentDir));
 	time("discoverContextFiles");
 
 	let agent: Agent;
 	let session: AgentSession;
 
+	const enableLsp = options.enableLsp ?? true;
+
 	const toolSession: ToolSession = {
 		cwd,
 		hasUI: options.hasUI ?? false,
+		enableLsp,
 		eventBus,
 		outputSchema: options.outputSchema,
 		requireCompleteTool: options.requireCompleteTool,
@@ -681,6 +686,8 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return activeModel ? formatModelString(activeModel) : undefined;
 		},
 		settings: settingsManager,
+		authStorage,
+		modelRegistry,
 	};
 
 	const builtinTools = await createTools(toolSession, options.toolNames);
@@ -706,6 +713,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		});
 		time("discoverAndLoadMCPTools");
 		mcpManager = mcpResult.manager;
+		toolSession.mcpManager = mcpManager;
 
 		// 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) {
@@ -846,9 +854,9 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 	}
 	time("combineTools");
 
-	const rebuildSystemPrompt = (toolNames: string[], tools: Map<string, AgentTool>): string => {
+	const rebuildSystemPrompt = async (toolNames: string[], tools: Map<string, AgentTool>): Promise<string> => {
 		toolContextStore.setToolNames(toolNames);
-		const defaultPrompt = buildSystemPromptInternal({
+		const defaultPrompt = await buildSystemPromptInternal({
 			cwd,
 			skills,
 			contextFiles,
@@ -862,7 +870,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 			return defaultPrompt;
 		}
 		if (typeof options.systemPrompt === "string") {
-			return buildSystemPromptInternal({
+			return await buildSystemPromptInternal({
 				cwd,
 				skills,
 				contextFiles,
@@ -876,13 +884,13 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 		return options.systemPrompt(defaultPrompt);
 	};
 
-	const systemPrompt = rebuildSystemPrompt(Array.from(toolRegistry.keys()), toolRegistry);
+	const systemPrompt = await rebuildSystemPrompt(Array.from(toolRegistry.keys()), toolRegistry);
 	time("buildSystemPrompt");
 
 	const promptTemplates = options.promptTemplates ?? (await discoverPromptTemplates(cwd, agentDir));
 	time("discoverPromptTemplates");
 
-	const slashCommands = options.slashCommands ?? discoverSlashCommands(cwd);
+	const slashCommands = options.slashCommands ?? (await discoverSlashCommands(cwd));
 	time("discoverSlashCommands");
 
 	// Create convertToLlm wrapper that filters images if blockImages is enabled (defense-in-depth)
@@ -991,7 +999,7 @@ export async function createAgentSession(options: CreateAgentSessionOptions = {}
 
 	// Warm up LSP servers (connects to detected servers)
 	let lspServers: CreateAgentSessionResult["lspServers"];
-	if (settingsManager.getLspDiagnosticsOnWrite()) {
+	if (enableLsp && settingsManager.getLspDiagnosticsOnWrite()) {
 		try {
 			const result = await warmupLspServers(cwd, {
 				onConnecting: (serverNames) => {