feat: centralize API configuration in ProviderSettingsManager

- Added getCurrentProviderSettings(), getModeProviderSettings(), and updateCurrentProviderSettings() methods to ProviderSettingsManager
- Updated ClineProvider to use ProviderSettingsManager instead of ContextProxy for API configuration
- Modified Task class to fetch API configuration from ProviderSettingsManager with async initialization
- Updated webview message handlers to use the centralized source
- Removed getProviderSettings() and setProviderSettings() methods from ContextProxy
- Updated all affected test files to reflect the architectural changes
- Fixed test mocks to properly handle the new async API configuration flow

This change makes ProviderSettingsManager the sole source of truth for API configuration data within the src/ directory, eliminating the dual-source confusion and potential synchronization issues.

Author: roomote

src/core/config/ContextProxy.ts

@@ -2,16 +2,13 @@ import * as vscode from "vscode"
 import { ZodError } from "zod"
 
 import {
-	PROVIDER_SETTINGS_KEYS,
 	GLOBAL_SETTINGS_KEYS,
 	SECRET_STATE_KEYS,
 	GLOBAL_STATE_KEYS,
-	type ProviderSettings,
 	type GlobalSettings,
 	type SecretState,
 	type GlobalState,
 	type RooCodeSettings,
-	providerSettingsSchema,
 	globalSettingsSchema,
 	isSecretStateKey,
 } from "@roo-code/types"
@@ -186,48 +183,6 @@ export class ContextProxy {
 		}
 	}
 
-	/**
-	 * ProviderSettings
-	 */
-
-	public getProviderSettings(): ProviderSettings {
-		const values = this.getValues()
-
-		try {
-			return providerSettingsSchema.parse(values)
-		} catch (error) {
-			if (error instanceof ZodError) {
-				TelemetryService.instance.captureSchemaValidationError({ schemaName: "ProviderSettings", error })
-			}
-
-			return PROVIDER_SETTINGS_KEYS.reduce((acc, key) => ({ ...acc, [key]: values[key] }), {} as ProviderSettings)
-		}
-	}
-
-	public async setProviderSettings(values: ProviderSettings) {
-		// Explicitly clear out any old API configuration values before that
-		// might not be present in the new configuration.
-		// If a value is not present in the new configuration, then it is assumed
-		// that the setting's value should be `undefined` and therefore we
-		// need to remove it from the state cache if it exists.
-
-		// Ensure openAiHeaders is always an object even when empty
-		// This is critical for proper serialization/deserialization through IPC
-		if (values.openAiHeaders !== undefined) {
-			// Check if it's empty or null
-			if (!values.openAiHeaders || Object.keys(values.openAiHeaders).length === 0) {
-				values.openAiHeaders = {}
-			}
-		}
-
-		await this.setValues({
-			...PROVIDER_SETTINGS_KEYS.filter((key) => !isSecretStateKey(key))
-				.filter((key) => !!this.stateCache[key])
-				.reduce((acc, key) => ({ ...acc, [key]: undefined }), {} as ProviderSettings),
-			...values,
-		})
-	}
-
 	/**
 	 * RooCodeSettings
 	 */

src/core/config/ProviderSettingsManager.ts

@@ -3,6 +3,7 @@ import { z, ZodError } from "zod"
 
 import {
 	type ProviderSettingsEntry,
+	type ProviderSettings,
 	providerSettingsSchema,
 	providerSettingsSchemaDiscriminated,
 	DEFAULT_CONSECUTIVE_MISTAKE_LIMIT,
@@ -373,6 +374,82 @@ export class ProviderSettingsManager {
 		}
 	}
 
+	/**
+	 * Get the current active provider settings.
+	 * This combines the profile data with the actual provider settings.
+	 */
+	public async getCurrentProviderSettings(): Promise<ProviderSettings> {
+		try {
+			return await this.lock(async () => {
+				const providerProfiles = await this.load()
+				const currentName = providerProfiles.currentApiConfigName
+
+				if (!currentName || !providerProfiles.apiConfigs[currentName]) {
+					// Return default empty settings if no current config
+					return {} as ProviderSettings
+				}
+
+				const { id, ...settings } = providerProfiles.apiConfigs[currentName]
+				return settings as ProviderSettings
+			})
+		} catch (error) {
+			throw new Error(`Failed to get current provider settings: ${error}`)
+		}
+	}
+
+	/**
+	 * Get provider settings for a specific mode.
+	 * Returns the settings for the API config assigned to that mode.
+	 */
+	public async getModeProviderSettings(mode: Mode): Promise<ProviderSettings | undefined> {
+		try {
+			return await this.lock(async () => {
+				const providerProfiles = await this.load()
+				const configId = providerProfiles.modeApiConfigs?.[mode]
+
+				if (!configId) {
+					return undefined
+				}
+
+				// Find the config with this ID
+				const config = Object.values(providerProfiles.apiConfigs).find((c) => c.id === configId)
+				if (!config) {
+					return undefined
+				}
+
+				const { id, ...settings } = config
+				return settings as ProviderSettings
+			})
+		} catch (error) {
+			throw new Error(`Failed to get mode provider settings: ${error}`)
+		}
+	}
+
+	/**
+	 * Update the current active provider settings.
+	 * This updates the settings for the currently active profile.
+	 */
+	public async updateCurrentProviderSettings(settings: ProviderSettings): Promise<void> {
+		try {
+			return await this.lock(async () => {
+				const providerProfiles = await this.load()
+				const currentName = providerProfiles.currentApiConfigName
+
+				if (!currentName || !providerProfiles.apiConfigs[currentName]) {
+					throw new Error("No active configuration to update")
+				}
+
+				// Preserve the ID when updating
+				const existingId = providerProfiles.apiConfigs[currentName].id
+				providerProfiles.apiConfigs[currentName] = { ...settings, id: existingId }
+
+				await this.store(providerProfiles)
+			})
+		} catch (error) {
+			throw new Error(`Failed to update current provider settings: ${error}`)
+		}
+	}
+
 	/**
 	 * Delete a config by name.
 	 */

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

@@ -291,67 +291,6 @@ describe("ContextProxy", () => {
 		})
 	})
 
-	describe("setProviderSettings", () => {
-		it("should clear old API configuration values and set new ones", async () => {
-			// Set up initial API configuration values
-			await proxy.updateGlobalState("apiModelId", "old-model")
-			await proxy.updateGlobalState("openAiBaseUrl", "https://old-url.com")
-			await proxy.updateGlobalState("modelTemperature", 0.7)
-
-			// Spy on setValues
-			const setValuesSpy = vi.spyOn(proxy, "setValues")
-
-			// Call setProviderSettings with new configuration
-			await proxy.setProviderSettings({
-				apiModelId: "new-model",
-				apiProvider: "anthropic",
-				// Note: openAiBaseUrl is not included in the new config
-			})
-
-			// Verify setValues was called with the correct parameters
-			// It should include undefined for openAiBaseUrl (to clear it)
-			// and the new values for apiModelId and apiProvider
-			expect(setValuesSpy).toHaveBeenCalledWith(
-				expect.objectContaining({
-					apiModelId: "new-model",
-					apiProvider: "anthropic",
-					openAiBaseUrl: undefined,
-					modelTemperature: undefined,
-				}),
-			)
-
-			// Verify the state cache has been updated correctly
-			expect(proxy.getGlobalState("apiModelId")).toBe("new-model")
-			expect(proxy.getGlobalState("apiProvider")).toBe("anthropic")
-			expect(proxy.getGlobalState("openAiBaseUrl")).toBeUndefined()
-			expect(proxy.getGlobalState("modelTemperature")).toBeUndefined()
-		})
-
-		it("should handle empty API configuration", async () => {
-			// Set up initial API configuration values
-			await proxy.updateGlobalState("apiModelId", "old-model")
-			await proxy.updateGlobalState("openAiBaseUrl", "https://old-url.com")
-
-			// Spy on setValues
-			const setValuesSpy = vi.spyOn(proxy, "setValues")
-
-			// Call setProviderSettings with empty configuration
-			await proxy.setProviderSettings({})
-
-			// Verify setValues was called with undefined for all existing API config keys
-			expect(setValuesSpy).toHaveBeenCalledWith(
-				expect.objectContaining({
-					apiModelId: undefined,
-					openAiBaseUrl: undefined,
-				}),
-			)
-
-			// Verify the state cache has been cleared
-			expect(proxy.getGlobalState("apiModelId")).toBeUndefined()
-			expect(proxy.getGlobalState("openAiBaseUrl")).toBeUndefined()
-		})
-	})
-
 	describe("resetAllState", () => {
 		it("should clear all in-memory caches", async () => {
 			// Setup initial state in caches

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

@@ -81,7 +81,6 @@ describe("importExport", () => {
 			setValues: vi.fn(),
 			setValue: vi.fn(),
 			export: vi.fn().mockImplementation(() => Promise.resolve({})),
-			setProviderSettings: vi.fn(),
 		} as unknown as ReturnType<typeof vi.mocked<ContextProxy>>
 
 		mockCustomModesManager = { updateCustomMode: vi.fn() } as unknown as ReturnType<

src/core/config/importExport.ts

@@ -74,18 +74,10 @@ export async function importSettingsFromPath(
 		await providerSettingsManager.import(providerProfiles)
 		await contextProxy.setValues(globalSettings)
 
-		// Set the current provider.
+		// Set the current provider name in context
 		const currentProviderName = providerProfiles.currentApiConfigName
-		const currentProvider = providerProfiles.apiConfigs[currentProviderName]
 		contextProxy.setValue("currentApiConfigName", currentProviderName)
 
-		// TODO: It seems like we don't need to have the provider settings in
-		// the proxy; we can just use providerSettingsManager as the source of
-		// truth.
-		if (currentProvider) {
-			contextProxy.setProviderSettings(currentProvider)
-		}
-
 		contextProxy.setValue("listApiConfigMeta", await providerSettingsManager.listConfig())
 
 		return { providerProfiles, globalSettings, success: true }