pi-free 2.2.5 → 2.2.6

package/provider-helper.ts

@@ -12,6 +12,12 @@ import type {
 	ProviderModelConfig,
 } from "@earendil-works/pi-coding-agent";
 import { saveConfig } from "./config.ts";
+import {
+	DEFAULT_PROVIDER_CACHE_TTL_MS,
+	isProviderCacheFresh,
+	loadProviderCache,
+	saveProviderCacheGuarded,
+} from "./lib/provider-cache.ts";
 import { createLogger } from "./lib/logger.ts";
 import type { ModelsDevEnrichedMetadata } from "./lib/types.ts";
 import { enhanceModelNameWithCodingIndex } from "./provider-failover/benchmark-lookup.ts";
@@ -101,6 +107,64 @@ export function enhanceWithCI(
 	}));
 }
 
+/**
+ * Cache-first model loader for network-fetching providers.
+ *
+ * - If a fresh, non-empty disk cache exists, return it immediately (no network).
+ * - Otherwise fetch; persist the result unless it looks like a degenerate /
+ *   transiently-shrunk response (poisoning guard), so a flaky API can't wipe a
+ *   good cached list for the TTL window.
+ * - On fetch error, fall back to a stale cache entry if one exists.
+ */
+export async function loadCachedOrFetchModels(
+	providerId: string,
+	fetcher: () => Promise<ProviderModelConfig[]>,
+	options?: { ttlMs?: number },
+): Promise<ProviderModelConfig[]> {
+	const ttlMs = options?.ttlMs ?? DEFAULT_PROVIDER_CACHE_TTL_MS;
+	const cached = loadProviderCache(providerId);
+
+	if (
+		cached &&
+		cached.length > 0 &&
+		isProviderCacheFresh(providerId, ttlMs)
+	) {
+		return cached;
+	}
+
+	let fetched: ProviderModelConfig[] = [];
+	try {
+		fetched = await fetcher();
+	} catch (err) {
+		// Network/discovery failure: keep serving whatever cache we have so the
+		// provider still registers models instead of going empty.
+		if (cached && cached.length > 0) {
+			_logger.info(
+				`[${providerId}] fetch failed; serving ${cached.length} cached models`,
+				{ error: err instanceof Error ? err.message : String(err) },
+			);
+			return cached;
+		}
+		return [];
+	}
+
+	// Persist the fresh list unless it looks like a degenerate /
+	// transiently-shrunk response (poisoning guard, centralized in provider-cache),
+	// so a flaky API can't wipe a good cached list for the TTL window.
+	if (fetched.length > 0) {
+		saveProviderCacheGuarded(providerId, fetched).catch((err) => {
+			_logger.error(`[${providerId}] failed to persist provider cache`, {
+				error: err instanceof Error ? err.message : String(err),
+			});
+		});
+	} else if (cached && cached.length > 0) {
+		// Empty fetch but we have a cache: keep serving cache.
+		return cached;
+	}
+
+	return fetched;
+}
+
 /**
  * Register an OpenAI-compatible provider with standard headers.
  * Reduces boilerplate across providers that use the OpenAI API format.

package/providers/bai/bai.ts

@@ -40,7 +40,11 @@ import {
 } from "../../lib/provider-compat.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("bai");
 
@@ -176,7 +180,9 @@ export default async function baiProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	const allModels = await fetchBaiModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_BAI, () =>
+		fetchBaiModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		// Either the API failed (already logged inside fetchBaiModels) or

package/providers/crofai/crofai.ts

@@ -35,7 +35,11 @@ import {
 } from "../../lib/provider-compat.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchWithRetry } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("crofai");
 
@@ -147,7 +151,9 @@ export default async function crofaiProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models
-	const allModels = await fetchCrofaiModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_CROFAI, () =>
+		fetchCrofaiModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[crofai] No models available");

package/providers/deepinfra/deepinfra.ts

@@ -49,7 +49,11 @@ import { createProviderProbe } from "../../lib/provider-probe.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { fetchWithRetry, fetchWithTimeout } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("deepinfra");
 
@@ -163,7 +167,9 @@ export default async function deepinfraProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models
-	const allModels = await fetchDeepinfraModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_DEEPINFRA, () =>
+		fetchDeepinfraModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[deepinfra] No chat models available");

package/providers/dynamic-built-in/index.ts

@@ -55,7 +55,7 @@ import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { fetchWithTimeout } from "../../lib/util.ts";
 import { fetchOpenRouterCompatibleModels } from "../model-fetcher.ts";
 import { createToggleState } from "../../lib/toggle-state.ts";
-import { enhanceWithCI } from "../../provider-helper.ts";
+import { enhanceWithCI, loadCachedOrFetchModels } from "../../provider-helper.ts";
 import {
 	OPENCODE_DYNAMIC_API,
 	createOpenCodeSessionTracker,
@@ -311,38 +311,48 @@ async function discoverAndRegister(
 	config: DynamicProviderDef,
 	apiKey: string,
 ): Promise<void> {
-	let allModels: ProviderModelConfig[];
+	// Use the shared cache-first loader so dynamic providers (e.g. always-discovered
+	// FastRouter) don't block startup on a network fetch. The helper serves a fresh
+	// cache, falls back to stale cache on failure/empty fetch, and persists the
+	// result for next startup.
+	const models = await loadCachedOrFetchModels(
+		config.providerId,
+		async () => {
+			let allModels: ProviderModelConfig[];
+			if (config.fetchModels) {
+				allModels = await config.fetchModels(apiKey);
+			} else {
+				allModels = await fetchModelsFromEndpoint({
+					providerId: config.providerId,
+					baseUrl: config.baseUrl,
+					apiKey,
+					compat: config.compat,
+					modelDefaults: config.modelDefaults,
+					timeoutMs: DEFAULT_FETCH_TIMEOUT_MS,
+				});
+			}
 
-	try {
-		if (config.fetchModels) {
-			allModels = await config.fetchModels(apiKey);
-		} else {
-			allModels = await fetchModelsFromEndpoint({
-				providerId: config.providerId,
-				baseUrl: config.baseUrl,
-				apiKey,
-				compat: config.compat,
-				modelDefaults: config.modelDefaults,
-				timeoutMs: DEFAULT_FETCH_TIMEOUT_MS,
-			});
-		}
+			// Apply DeepSeek proxy compat to matching models. OpenCode headers are
+			// injected per request by createOpenCodeStreamSimple(), not stored here.
+			return allModels.map((m) => ({
+				...m,
+				api: isOpenCodeProvider(config.providerId)
+					? OPENCODE_DYNAMIC_API
+					: m.api,
+				compat: getProxyModelCompat(m) ?? m.compat,
+			}));
+		},
+	);
 
-		// Apply DeepSeek proxy compat to matching models. OpenCode headers are
-		// injected per request by createOpenCodeStreamSimple(), not stored here.
-		allModels = allModels.map((m) => ({
-			...m,
-			api: isOpenCodeProvider(config.providerId) ? OPENCODE_DYNAMIC_API : m.api,
-			compat: getProxyModelCompat(m) ?? m.compat,
-		}));
-	} catch (error) {
+	if (models.length === 0) {
+		// No usable models and no fallback cache: leave Pi's built-in defaults.
 		_logger.info(
-			`[dynamic] ${config.providerId}: discovery failed, Pi keeps its defaults`,
-			{ error: error instanceof Error ? error.message : String(error) },
+			`[dynamic] ${config.providerId}: no models available; Pi keeps its defaults`,
 		);
 		return;
 	}
 
-	await registerProvider(pi, config, allModels, apiKey);
+	await registerProvider(pi, config, models, apiKey);
 }
 
 // =============================================================================

package/providers/kilo/kilo.ts

@@ -26,12 +26,14 @@ import {
 } from "../../config.ts";
 import { URL_KILO_TOS } from "../../constants.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
+import { saveProviderCacheGuarded } from "../../lib/provider-cache.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { cleanModelName, logWarning } from "../../lib/util.ts";
 import {
 	createCtxReRegister,
 	createReRegister,
 	enhanceWithCI,
+	loadCachedOrFetchModels,
 	type StoredModels,
 } from "../../provider-helper.ts";
 import { loginKilo, refreshKiloToken } from "./kilo-auth.ts";
@@ -176,27 +178,27 @@ export default async function kiloProvider(pi: ExtensionAPI) {
 	// Resolve API key (env var or ~/.pi/free.json)
 	const kiloApiKey = getKiloApiKey();
 
-	// Try to fetch ALL models at startup (like Cline/OpenRouter)
-	// With API key: returns all models; without: returns free-only
-	let allModels: ProviderModelConfig[] = [];
-	let freeModels: ProviderModelConfig[] = [];
-
-	try {
-		// Fetch all models (returns free-only if no auth, all if auth available)
-		allModels = await fetchKiloModels({ token: kiloApiKey, freeOnly: false });
-		// Derive free list using isFreeModel with allModels for detection
-		freeModels = allModels.filter((m) =>
-			isFreeModel({ ...m, provider: PROVIDER_KILO }, allModels),
-		);
-	} catch (error) {
-		logWarning("kilo", "Failed to fetch models at startup", error);
-		// Fallback: try to fetch just free models
-		try {
-			freeModels = await fetchKiloModels({ freeOnly: true });
-		} catch (e) {
-			logWarning("kilo", "Failed to fetch free models", e);
-		}
-	}
+	// Cache-first at startup via the shared helper (mirrors the other fetchers):
+	// serve a fresh cache instantly, else fetch (full → free-only fallback),
+	// else fall back to a stale cache. The session_start handler below keeps
+	// the cache fresh.
+	let allModels: ProviderModelConfig[] = await loadCachedOrFetchModels(
+		PROVIDER_KILO,
+		async () => {
+			try {
+				return await fetchKiloModels({ token: kiloApiKey, freeOnly: false });
+			} catch (error) {
+				logWarning("kilo", "Failed to fetch models at startup", error);
+				return fetchKiloModels({ freeOnly: true }).catch((err) => {
+					logWarning("kilo", "Failed to fetch free models at startup", err);
+					return [];
+				});
+			}
+		},
+	);
+	let freeModels: ProviderModelConfig[] = allModels.filter((m) =>
+		isFreeModel({ ...m, provider: PROVIDER_KILO }, allModels),
+	);
 
 	// State tracking
 	const kiloShowPaid = getKiloShowPaid();
@@ -204,6 +206,14 @@ export default async function kiloProvider(pi: ExtensionAPI) {
 	let showPaidModels = kiloShowPaid;
 	let currentModels = kiloShowPaid && !kiloFreeOnly ? allModels : freeModels;
 
+	if (currentModels.length === 0) {
+		logWarning(
+			"kilo",
+			"No Kilo models available at startup; provider will be empty until models can be fetched",
+			undefined,
+		);
+	}
+
 	// Shared model storage for global toggle
 	const stored: StoredModels = { free: freeModels, all: allModels };
 
@@ -295,7 +305,7 @@ export default async function kiloProvider(pi: ExtensionAPI) {
 			"User-Agent": "pi-free-providers",
 		},
 		models: enhanceWithCI(modelsWithCompat),
-		...(!!kiloApiKey ? {} : { oauth: oauthConfig }),
+		...(kiloApiKey ? {} : { oauth: oauthConfig }),
 	});
 
 	// Registration complete - models registered silently (use LOG_LEVEL=info to see details)
@@ -449,6 +459,15 @@ export default async function kiloProvider(pi: ExtensionAPI) {
 					);
 					stored.free = freeModels;
 
+					// Persist refreshed models to disk cache for fast next startup
+					saveProviderCacheGuarded(PROVIDER_KILO, allModels).catch((err) => {
+						logWarning(
+							"kilo",
+							"Failed to persist refreshed models to cache",
+							err,
+						);
+					});
+
 					// Update global toggle registration
 					const baseCtxReRegister = createCtxReRegister(ctx as any, {
 						...KILO_PROVIDER_CONFIG,

package/providers/novita/novita.ts

@@ -41,7 +41,11 @@ import { createProviderProbe } from "../../lib/provider-probe.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { fetchWithRetry, fetchWithTimeout } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("novita");
 
@@ -157,7 +161,9 @@ export default async function novitaProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models
-	const allModels = await fetchNovitaModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_NOVITA, () =>
+		fetchNovitaModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[novita] No chat models available");

package/providers/openmodel/openmodel.ts

@@ -45,7 +45,11 @@ import { safeEnrichModelsWithModelsDev } from "../../lib/model-metadata.ts";
 import { isLikelyReasoningModel } from "../../lib/provider-compat.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchWithRetry } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("openmodel");
 
@@ -465,7 +469,9 @@ export default async function openmodelProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	const allModels = await fetchOpenModelModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_OPENMODEL, () =>
+		fetchOpenModelModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn(

package/providers/routeway/routeway.ts

@@ -45,7 +45,11 @@ import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
 import { fetchWithTimeout } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("routeway");
 
@@ -303,7 +307,9 @@ export default async function routewayProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	const allModels = await fetchRoutewayModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_ROUTEWAY, () =>
+		fetchRoutewayModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[routeway] No chat models available");

package/providers/sambanova/sambanova.ts

@@ -38,7 +38,11 @@ import {
 	fetchOpenAICompatibleModels,
 	fetchWithTimeout,
 } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("sambanova");
 
@@ -57,11 +61,13 @@ export default async function sambanovaProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models via shared OpenAI-compatible helper
-	const allModels = await fetchOpenAICompatibleModels(
-		"sambanova",
-		BASE_URL_SAMBANOVA,
-		apiKey,
-		{ maxTokens: 8_192 },
+	const allModels = await loadCachedOrFetchModels(PROVIDER_SAMBANOVA, () =>
+		fetchOpenAICompatibleModels(
+			"sambanova",
+			BASE_URL_SAMBANOVA,
+			apiKey,
+			{ maxTokens: 8_192 },
+		),
 	);
 
 	if (allModels.length === 0) {

package/providers/together/together.ts

@@ -50,7 +50,11 @@ import { createProviderProbe } from "../../lib/provider-probe.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { wrapSessionStartHandler } from "../../lib/session-start-metrics.ts";
 import { fetchWithRetry, fetchWithTimeout } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("together");
 
@@ -150,7 +154,9 @@ export default async function togetherProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models
-	const allModels = await fetchTogetherModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_TOGETHER, () =>
+		fetchTogetherModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[together] No chat models available");

package/providers/tokenrouter/tokenrouter.ts

@@ -49,7 +49,11 @@ import {
 } from "../../lib/provider-compat.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { cleanModelName, fetchWithRetry } from "../../lib/util.ts";
-import { enhanceWithCI, setupProvider } from "../../provider-helper.ts";
+import {
+	enhanceWithCI,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("tokenrouter");
 
@@ -564,7 +568,9 @@ export default async function tokenRouterProvider(pi: ExtensionAPI) {
 		return;
 	}
 
-	const allModels = await fetchTokenRouterModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_TOKENROUTER, () =>
+		fetchTokenRouterModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[tokenrouter] No text chat models available");

package/providers/zenmux/zenmux.ts

@@ -31,7 +31,11 @@ import { safeEnrichModelsWithModelsDev } from "../../lib/model-metadata.ts";
 import { getProxyModelCompat } from "../../lib/provider-compat.ts";
 import { isFreeModel, registerWithGlobalToggle } from "../../lib/registry.ts";
 import { fetchWithRetry } from "../../lib/util.ts";
-import { createReRegister, setupProvider } from "../../provider-helper.ts";
+import {
+	createReRegister,
+	loadCachedOrFetchModels,
+	setupProvider,
+} from "../../provider-helper.ts";
 
 const _logger = createLogger("zenmux");
 
@@ -146,7 +150,9 @@ export default async function zenmuxProvider(pi: ExtensionAPI) {
 	}
 
 	// Fetch models
-	const allModels = await fetchZenmuxModels(apiKey);
+	const allModels = await loadCachedOrFetchModels(PROVIDER_ZENMUX, () =>
+		fetchZenmuxModels(apiKey),
+	);
 
 	if (allModels.length === 0) {
 		_logger.warn("[zenmux] No models available");

package/providers/codestral/codestral.ts

@@ -1,128 +0,0 @@
-/**
- * Codestral Provider Extension
- *
- * Codestral is Mistral AI's code-focused model. This provider registers it
- * through the Codestral-specific endpoint (codestral.mistral.ai) using
- * the Mistral SDK (api: "mistral-conversations") — separate from the built-in
- * "mistral" provider which uses api.mistral.ai.
- *
- * NOTE: Do NOT use api: "openai-completions" here. Codestral's API is
- * Mistral-format (camelCase fields, maxTokens, no stream_options/store).
- * The OpenAI completions adapter sends OpenAI-specific fields that Mistral
- * rejects with HTTP 422 "Extra inputs are not permitted".
- *
- * Free tier (Experiment plan):
- *   - 2 req/min, 500K tokens/min, 1B tokens/month
- *   - No credit card — phone verification only
- *   - Sign up at https://console.mistral.ai/codestral
- *
- * Endpoints:
- *   Chat:  https://codestral.mistral.ai/v1/chat/completions
- *   FIM:   https://codestral.mistral.ai/v1/fim/completions (not used by pi)
- *
- * Setup:
- *   1. Get API key from https://console.mistral.ai/codestral
- *   2. Set CODESTRAL_API_KEY env var (or MISTRAL_API_KEY as fallback)
- *
- * Usage:
- *   pi install git:github.com/apmantza/pi-free
- *   # Set CODESTRAL_API_KEY env var
- *   # Models appear in /model selector as "codestral/codestral-latest"
- */
-
-import type {
-	ExtensionAPI,
-	ProviderModelConfig,
-} from "@earendil-works/pi-coding-agent";
-import {
-	getCodestralApiKey,
-	getCodestralShowPaid,
-	getMistralApiKey,
-} from "../../config.ts";
-import { BASE_URL_CODESTRAL, PROVIDER_CODESTRAL } from "../../constants.ts";
-import { createLogger } from "../../lib/logger.ts";
-import { registerWithGlobalToggle } from "../../lib/registry.ts";
-import { enhanceWithCI, setupProvider } from "../../provider-helper.ts";
-
-const _logger = createLogger("codestral");
-
-// =============================================================================
-// Model Definition
-// =============================================================================
-
-const CODESTRAL_MODEL: ProviderModelConfig = {
-	id: "codestral-latest",
-	name: "Codestral",
-	reasoning: false,
-	input: ["text"],
-	cost: {
-		input: 0.3,
-		output: 0.9,
-		cacheRead: 0,
-		cacheWrite: 0,
-	},
-	contextWindow: 256_000,
-	maxTokens: 4_096,
-};
-
-// =============================================================================
-// Extension Entry Point
-// =============================================================================
-
-export default async function codestralProvider(pi: ExtensionAPI) {
-	// Try CODESTRAL_API_KEY first, fall back to MISTRAL_API_KEY
-	const apiKey = getCodestralApiKey() || getMistralApiKey();
-
-	if (!apiKey) {
-		_logger.info(
-			"[codestral] Skipping — neither CODESTRAL_API_KEY nor MISTRAL_API_KEY set",
-		);
-		return;
-	}
-
-	const keySource = getCodestralApiKey()
-		? "CODESTRAL_API_KEY"
-		: "MISTRAL_API_KEY";
-	_logger.info(`[codestral] Using key from ${keySource}`);
-
-	const allModels = [CODESTRAL_MODEL];
-	const freeModels = allModels; // All $0.30/$0.90 — still accessible via Experiment free tier
-	const stored = { free: freeModels, all: allModels };
-
-	// Re-register function — uses mistral-conversations API (Mistral SDK)
-	// NOT openai-completions: Codestral uses the same API format as Mistral
-	// and rejects OpenAI-specific fields (stream_options, store, max_completion_tokens) with 422.
-	const reRegister = (models: typeof freeModels) => {
-		pi.registerProvider(PROVIDER_CODESTRAL, {
-			baseUrl: BASE_URL_CODESTRAL,
-			apiKey,
-			api: "mistral-conversations" as const,
-			models: enhanceWithCI(models, PROVIDER_CODESTRAL),
-		});
-	};
-
-	// Register with global toggle
-	registerWithGlobalToggle(PROVIDER_CODESTRAL, stored, reRegister, true);
-
-	// Setup provider (toggle command, status bar, error handling)
-	setupProvider(
-		pi,
-		{
-			providerId: PROVIDER_CODESTRAL,
-			initialShowPaid: getCodestralShowPaid(),
-			skipToggle: true, // Only one model, no toggle needed
-			reRegister: (models) => {
-				stored.free = models;
-				stored.all = models;
-				reRegister(models);
-			},
-		},
-		stored,
-	);
-
-	// Initial registration — uses mistral-conversations API (Mistral SDK)
-	reRegister(freeModels);
-
-	_logger.info(`[codestral] Registered codestral-latest via ${keySource}`);
-
-}