feat: show retired-provider message for removed provider profiles

Preserve API profiles that reference removed providers instead of
silently stripping their apiProvider. When a user selects a profile
configured for a retired provider, the settings UI now shows an
empathetic message explaining the removal instead of the provider
configuration form.

- Add retiredProviderNames array and isRetiredProvider() helper to
  packages/types/src/provider-settings.ts
- Update ProviderSettingsManager sanitization to preserve retired
  providers (only strip truly unknown values)
- Update ContextProxy sanitization to preserve retired providers
- Render retired-provider message in ApiOptions.tsx when selected
  provider is in the retired list
- Add tests for sanitization, ContextProxy, and UI behavior

Author: hannesrudolph

packages/types/src/provider-settings.ts

@@ -129,14 +129,41 @@ export type ProviderName = z.infer<typeof providerNamesSchema>
 export const isProviderName = (key: unknown): key is ProviderName =>
 	typeof key === "string" && providerNames.includes(key as ProviderName)
 
+/**
+ * RetiredProviderName
+ */
+
+export const retiredProviderNames = [
+	"cerebras",
+	"chutes",
+	"deepinfra",
+	"doubao",
+	"featherless",
+	"groq",
+	"huggingface",
+	"io-intelligence",
+	"unbound",
+] as const
+
+export const retiredProviderNamesSchema = z.enum(retiredProviderNames)
+
+export type RetiredProviderName = z.infer<typeof retiredProviderNamesSchema>
+
+export const isRetiredProvider = (value: string): value is RetiredProviderName =>
+	retiredProviderNames.includes(value as RetiredProviderName)
+
+export const providerNamesWithRetiredSchema = z.union([providerNamesSchema, retiredProviderNamesSchema])
+
+export type ProviderNameWithRetired = z.infer<typeof providerNamesWithRetiredSchema>
+
 /**
  * ProviderSettingsEntry
  */
 
 export const providerSettingsEntrySchema = z.object({
 	id: z.string(),
 	name: z.string(),
-	apiProvider: providerNamesSchema.optional(),
+	apiProvider: providerNamesWithRetiredSchema.optional(),
 	modelId: z.string().optional(),
 })
 
@@ -386,7 +413,7 @@ export const providerSettingsSchemaDiscriminated = z.discriminatedUnion("apiProv
 ])
 
 export const providerSettingsSchema = z.object({
-	apiProvider: providerNamesSchema.optional(),
+	apiProvider: providerNamesWithRetiredSchema.optional(),
 	...anthropicSchema.shape,
 	...openRouterSchema.shape,
 	...bedrockSchema.shape,

src/core/config/ContextProxy.ts

@@ -16,6 +16,7 @@ import {
 	globalSettingsSchema,
 	isSecretStateKey,
 	isProviderName,
+	isRetiredProvider,
 } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
@@ -223,14 +224,16 @@ export class ContextProxy {
 	}
 
 	/**
-	 * Migrates invalid/removed apiProvider values by clearing them from storage.
-	 * This handles cases where a user had a provider selected that was later removed
-	 * from the extension (e.g., "glama").
+	 * Migrates unknown apiProvider values by clearing them from storage.
+	 * Retired providers are preserved so users can keep historical configuration.
 	 */
 	private async migrateInvalidApiProvider() {
 		try {
 			const apiProvider = this.stateCache.apiProvider
-			if (apiProvider !== undefined && !isProviderName(apiProvider)) {
+			const isKnownProvider =
+				typeof apiProvider === "string" && (isProviderName(apiProvider) || isRetiredProvider(apiProvider))
+
+			if (apiProvider !== undefined && !isKnownProvider) {
 				logger.info(`[ContextProxy] Found invalid provider "${apiProvider}" in storage - clearing it`)
 				// Clear the invalid provider from both cache and storage
 				this.stateCache.apiProvider = undefined
@@ -439,8 +442,8 @@ export class ContextProxy {
 	}
 
 	/**
-	 * Sanitizes provider values by resetting invalid/removed apiProvider values.
-	 * This prevents schema validation errors for removed providers.
+	 * Sanitizes provider values by resetting unknown apiProvider values.
+	 * Active and retired providers are preserved.
 	 */
 	private sanitizeProviderValues(values: RooCodeSettings): RooCodeSettings {
 		// Remove legacy Claude Code CLI wrapper keys that may still exist in global state.
@@ -456,7 +459,11 @@ export class ContextProxy {
 			}
 		}
 
-		if (values.apiProvider !== undefined && !isProviderName(values.apiProvider)) {
+		const isKnownProvider =
+			typeof values.apiProvider === "string" &&
+			(isProviderName(values.apiProvider) || isRetiredProvider(values.apiProvider))
+
+		if (values.apiProvider !== undefined && !isKnownProvider) {
 			logger.info(`[ContextProxy] Sanitizing invalid provider "${values.apiProvider}" - resetting to undefined`)
 			// Return a new values object without the invalid apiProvider
 			const { apiProvider, ...restValues } = sanitizedValues

src/core/config/ProviderSettingsManager.ts

@@ -12,6 +12,7 @@ import {
 	getModelId,
 	type ProviderName,
 	isProviderName,
+	isRetiredProvider,
 } from "@roo-code/types"
 import { TelemetryService } from "@roo-code/telemetry"
 
@@ -359,8 +360,12 @@ export class ProviderSettingsManager {
 				const existingId = providerProfiles.apiConfigs[name]?.id
 				const id = config.id || existingId || this.generateId()
 
-				// Filter out settings from other providers.
-				const filteredConfig = discriminatedProviderSettingsWithIdSchema.parse(config)
+				// For active providers, filter out settings from other providers.
+				// For retired providers, preserve full profile fields to avoid data loss.
+				const filteredConfig =
+					typeof config.apiProvider === "string" && isRetiredProvider(config.apiProvider)
+						? providerSettingsWithIdSchema.parse(config)
+						: discriminatedProviderSettingsWithIdSchema.parse(config)
 				providerProfiles.apiConfigs[name] = { ...filteredConfig, id }
 				await this.store(providerProfiles)
 				return id
@@ -507,7 +512,14 @@ export class ProviderSettingsManager {
 				const profiles = providerProfilesSchema.parse(await this.load())
 				const configs = profiles.apiConfigs
 				for (const name in configs) {
-					// Avoid leaking properties from other providers.
+					const apiProvider = configs[name].apiProvider
+
+					if (typeof apiProvider === "string" && isRetiredProvider(apiProvider)) {
+						// Preserve retired-provider profiles as-is to prevent dropping legacy fields.
+						continue
+					}
+
+					// Avoid leaking properties from other active providers.
 					configs[name] = discriminatedProviderSettingsWithIdSchema.parse(configs[name])
 
 					// If it has no apiProvider, skip filtering
@@ -607,7 +619,8 @@ export class ProviderSettingsManager {
 	}
 
 	/**
-	 * Sanitizes a provider config by resetting invalid/removed apiProvider values.
+	 * Sanitizes a provider config by resetting unknown apiProvider values.
+	 * Retired providers are preserved.
 	 * This handles cases where a user had a provider selected that was later removed
 	 * from the extension (e.g., "glama").
 	 */
@@ -618,10 +631,15 @@ export class ProviderSettingsManager {
 
 		const config = apiConfig as Record<string, unknown>
 
-		// Check if apiProvider is set and if it's still valid
-		if (config.apiProvider !== undefined && !isProviderName(config.apiProvider)) {
+		const apiProvider = config.apiProvider
+
+		// Check if apiProvider is set and if it's still recognized (active or retired)
+		if (
+			apiProvider !== undefined &&
+			(typeof apiProvider !== "string" || (!isProviderName(apiProvider) && !isRetiredProvider(apiProvider)))
+		) {
 			console.log(
-				`[ProviderSettingsManager] Sanitizing invalid provider "${config.apiProvider}" - resetting to undefined`,
+				`[ProviderSettingsManager] Sanitizing unknown provider "${config.apiProvider}" - resetting to undefined`,
 			)
 			// Return a new config object without the invalid apiProvider
 			// This effectively resets the profile so the user can select a valid provider

src/core/config/__tests__/ContextProxy.spec.ts

@@ -424,7 +424,7 @@ describe("ContextProxy", () => {
 
 		it("should reinitialize caches after reset", async () => {
 			// Spy on initialization methods
-			const initializeSpy = vi.spyOn(proxy as any, "initialize")
+			const initializeSpy = vi.spyOn(proxy, "initialize")
 
 			// Reset all state
 			await proxy.resetAllState()
@@ -452,6 +452,25 @@ describe("ContextProxy", () => {
 			expect(mockGlobalState.update).toHaveBeenCalledWith("apiProvider", undefined)
 		})
 
+		it("should not clear retired apiProvider from storage during initialization", async () => {
+			// Reset and create a new proxy with retired provider in state
+			vi.clearAllMocks()
+			mockGlobalState.get.mockImplementation((key: string) => {
+				if (key === "apiProvider") {
+					return "groq" // Retired provider
+				}
+				return undefined
+			})
+
+			const proxyWithRetiredProvider = new ContextProxy(mockContext)
+			await proxyWithRetiredProvider.initialize()
+
+			// Should NOT have called update for apiProvider (retired should be preserved)
+			const updateCalls = mockGlobalState.update.mock.calls
+			const apiProviderUpdateCalls = updateCalls.filter((call: unknown[]) => call[0] === "apiProvider")
+			expect(apiProviderUpdateCalls).toHaveLength(0)
+		})
+
 		it("should not modify valid apiProvider during initialization", async () => {
 			// Reset and create a new proxy with valid provider in state
 			vi.clearAllMocks()
@@ -467,25 +486,52 @@ describe("ContextProxy", () => {
 
 			// Should NOT have called update for apiProvider (it's valid)
 			const updateCalls = mockGlobalState.update.mock.calls
-			const apiProviderUpdateCalls = updateCalls.filter((call: any[]) => call[0] === "apiProvider")
+			const apiProviderUpdateCalls = updateCalls.filter((call: unknown[]) => call[0] === "apiProvider")
 			expect(apiProviderUpdateCalls.length).toBe(0)
 		})
 	})
 
 	describe("getProviderSettings", () => {
 		it("should sanitize invalid apiProvider before parsing", async () => {
-			// Set an invalid provider in state
-			await proxy.updateGlobalState("apiProvider", "invalid-removed-provider" as any)
-			await proxy.updateGlobalState("apiModelId", "some-model")
+			// Reset and create a new proxy with an unknown provider in state
+			vi.clearAllMocks()
+			mockGlobalState.get.mockImplementation((key: string) => {
+				if (key === "apiProvider") {
+					return "invalid-removed-provider"
+				}
+				if (key === "apiModelId") {
+					return "some-model"
+				}
+				return undefined
+			})
 
-			const settings = proxy.getProviderSettings()
+			const proxyWithInvalidProvider = new ContextProxy(mockContext)
+			await proxyWithInvalidProvider.initialize()
+
+			const settings = proxyWithInvalidProvider.getProviderSettings()
 
 			// The invalid apiProvider should be sanitized (removed)
 			expect(settings.apiProvider).toBeUndefined()
 			// Other settings should still be present
 			expect(settings.apiModelId).toBe("some-model")
 		})
 
+		it("should preserve retired apiProvider and provider fields", async () => {
+			await proxy.setValues({
+				apiProvider: "groq",
+				apiModelId: "llama3-70b",
+				openAiBaseUrl: "https://api.retired-provider.example/v1",
+				apiKey: "retired-provider-key",
+			})
+
+			const settings = proxy.getProviderSettings()
+
+			expect(settings.apiProvider).toBe("groq")
+			expect(settings.apiModelId).toBe("llama3-70b")
+			expect(settings.openAiBaseUrl).toBe("https://api.retired-provider.example/v1")
+			expect(settings.apiKey).toBe("retired-provider-key")
+		})
+
 		it("should pass through valid apiProvider", async () => {
 			// Set a valid provider in state
 			await proxy.updateGlobalState("apiProvider", "anthropic")