fix: prevent silent failures in code indexing with OpenAI-compatible endpoints (#4398)

Author: hannesrudolph

src/core/webview/webviewMessageHandler.ts

@@ -1807,6 +1807,43 @@ export const webviewMessageHandler = async (
 			break
 		}
 		case "codebaseIndexConfig": {
+			// Handle test action separately
+			if (message.action === "test") {
+				try {
+					if (!provider.codeIndexManager) {
+						throw new Error("Code index manager not available")
+					}
+
+					// Get the service factory from the manager
+					const serviceFactory = provider.codeIndexManager.getServiceFactory()
+					if (!serviceFactory) {
+						throw new Error("Service factory not available")
+					}
+
+					// Test the configuration
+					const isValid = await serviceFactory.validateEmbedderConfig()
+
+					// Send test result back to webview
+					provider.postMessageToWebview({
+						type: "codebaseIndexTestResult",
+						success: isValid,
+						message: isValid ? "Configuration is valid" : "Configuration test failed",
+					})
+				} catch (error) {
+					const errorMessage = error instanceof Error ? error.message : String(error)
+					provider.log(`[CodeIndexManager] Configuration test error: ${errorMessage}`)
+
+					// Send error result back to webview
+					provider.postMessageToWebview({
+						type: "codebaseIndexTestResult",
+						success: false,
+						message: errorMessage,
+					})
+				}
+				break
+			}
+
+			// Normal configuration update flow
 			const codebaseIndexConfig = message.values ?? {
 				codebaseIndexEnabled: false,
 				codebaseIndexQdrantUrl: "http://localhost:6333",
@@ -1823,16 +1860,42 @@ export const webviewMessageHandler = async (
 					// If now configured and enabled, start indexing automatically
 					if (provider.codeIndexManager.isFeatureEnabled && provider.codeIndexManager.isFeatureConfigured) {
 						if (!provider.codeIndexManager.isInitialized) {
-							await provider.codeIndexManager.initialize(provider.contextProxy)
+							try {
+								await provider.codeIndexManager.initialize(provider.contextProxy)
+							} catch (initError) {
+								// Initialization failed - send error status to webview
+								const errorMessage = initError instanceof Error ? initError.message : String(initError)
+								provider.log(`[CodeIndexManager] Initialization error: ${errorMessage}`)
+
+								// Send error status update to webview
+								const status = provider.codeIndexManager.getCurrentStatus()
+								provider.postMessageToWebview({
+									type: "indexingStatusUpdate",
+									values: status,
+								})
+
+								// Re-throw to prevent indexing attempt
+								throw initError
+							}
 						}
 						// Start indexing in background (no await)
 						provider.codeIndexManager.startIndexing()
 					}
 				}
 			} catch (error) {
+				const errorMessage = error instanceof Error ? error.message : String(error)
 				provider.log(
-					`[CodeIndexManager] Error during background CodeIndexManager configuration/indexing: ${error.message || error}`,
+					`[CodeIndexManager] Error during background CodeIndexManager configuration/indexing: ${errorMessage}`,
 				)
+
+				// Send error notification to webview if manager exists
+				if (provider.codeIndexManager) {
+					const status = provider.codeIndexManager.getCurrentStatus()
+					provider.postMessageToWebview({
+						type: "indexingStatusUpdate",
+						values: status,
+					})
+				}
 			}
 
 			await provider.postStateToWebview()

src/services/code-index/embedders/ollama.ts

@@ -106,4 +106,46 @@ export class CodeIndexOllamaEmbedder implements IEmbedder {
 			name: "ollama",
 		}
 	}
+
+	/**
+	 * Validates the Ollama configuration by attempting to connect to the endpoint.
+	 * @param baseUrl - The base URL of the Ollama instance
+	 * @param modelId - The model ID to check
+	 * @returns A promise that resolves to true if valid, or throws an error with details
+	 */
+	static async validateEndpoint(baseUrl: string, modelId: string): Promise<boolean> {
+		const url = `${baseUrl}/api/tags`
+
+		try {
+			const response = await fetch(url, {
+				method: "GET",
+				headers: {
+					"Content-Type": "application/json",
+				},
+			})
+
+			if (!response.ok) {
+				if (response.status === 404) {
+					throw new Error(`Ollama API not found at ${baseUrl}. Is Ollama running?`)
+				}
+				throw new Error(`Failed to connect to Ollama: ${response.status} ${response.statusText}`)
+			}
+
+			const data = await response.json()
+			const models = data.models || []
+			const modelNames = models.map((m: any) => m.name)
+
+			// Check if the specified model exists
+			if (!modelNames.includes(modelId)) {
+				throw new Error(`Model '${modelId}' not found. Available models: ${modelNames.join(", ") || "none"}`)
+			}
+
+			return true
+		} catch (error: any) {
+			if (error.message.includes("fetch failed") || error.message.includes("ECONNREFUSED")) {
+				throw new Error(`Cannot connect to Ollama at ${baseUrl}. Please ensure Ollama is running.`)
+			}
+			throw error
+		}
+	}
 }

src/services/code-index/embedders/openai-compatible.ts

@@ -68,6 +68,47 @@ export class OpenAICompatibleEmbedder implements IEmbedder {
 		this.maxItemTokens = maxItemTokens || MAX_ITEM_TOKENS
 	}
 
+	/**
+	 * Validates the endpoint by attempting a minimal embedding request
+	 * @param baseUrl The base URL to validate
+	 * @param apiKey The API key to use for validation
+	 * @param modelId Optional model ID to test with
+	 * @returns Promise resolving to true if valid
+	 * @throws Error with descriptive message if validation fails
+	 */
+	static async validateEndpoint(baseUrl: string, apiKey: string, modelId?: string): Promise<boolean> {
+		try {
+			const client = new OpenAI({
+				baseURL: baseUrl,
+				apiKey: apiKey,
+			})
+
+			const testModel = modelId || getDefaultModelId("openai-compatible")
+
+			// Try a minimal embedding request
+			await client.embeddings.create({
+				input: "test",
+				model: testModel,
+			})
+
+			return true
+		} catch (error: any) {
+			let errorMessage = t("embeddings:unknownError")
+
+			if (error?.status === 401) {
+				errorMessage = t("embeddings:authenticationFailed")
+			} else if (error?.status === 404) {
+				errorMessage = `Endpoint not found: ${baseUrl}`
+			} else if (error?.code === "ECONNREFUSED" || error?.code === "ENOTFOUND") {
+				errorMessage = `Cannot connect to ${baseUrl}`
+			} else if (error?.message) {
+				errorMessage = error.message
+			}
+
+			throw new Error(errorMessage)
+		}
+	}
+
 	/**
 	 * Creates embeddings for the given texts with batching and rate limiting
 	 * @param texts Array of text strings to embed

src/services/code-index/embedders/openai.ts

@@ -193,4 +193,42 @@ export class OpenAiEmbedder extends OpenAiNativeHandler implements IEmbedder {
 			name: "openai",
 		}
 	}
+
+	/**
+	 * Validates the OpenAI configuration by attempting to list models.
+	 * @param apiKey - The OpenAI API key
+	 * @param modelId - The model ID to check
+	 * @returns A promise that resolves to true if valid, or throws an error with details
+	 */
+	static async validateEndpoint(apiKey: string, modelId: string): Promise<boolean> {
+		const client = new OpenAI({ apiKey })
+
+		try {
+			// Try to list models to validate the API key
+			const models = await client.models.list()
+			const modelIds = models.data.map((m) => m.id)
+
+			// Check if the specified embedding model exists or is a known model
+			const knownEmbeddingModels = ["text-embedding-3-small", "text-embedding-3-large", "text-embedding-ada-002"]
+
+			if (!modelIds.includes(modelId) && !knownEmbeddingModels.includes(modelId)) {
+				throw new Error(
+					`Model '${modelId}' not found. Available embedding models: ${knownEmbeddingModels.join(", ")}`,
+				)
+			}
+
+			return true
+		} catch (error: any) {
+			if (error?.status === 401) {
+				throw new Error("Invalid API key. Please check your OpenAI API key.")
+			}
+			if (error?.status === 429) {
+				throw new Error("Rate limit exceeded. Please try again later.")
+			}
+			if (error?.message?.includes("fetch failed") || error?.message?.includes("ECONNREFUSED")) {
+				throw new Error("Network error. Please check your internet connection.")
+			}
+			throw new Error(`Failed to validate OpenAI configuration: ${error?.message || "Unknown error"}`)
+		}
+	}
 }

src/services/code-index/interfaces/manager.ts

@@ -72,6 +72,21 @@ export interface ICodeIndexManager {
 export type IndexingState = "Standby" | "Indexing" | "Indexed" | "Error"
 export type EmbedderProvider = "openai" | "ollama" | "openai-compatible" | "gemini"
 
+export interface IndexingStatus {
+	systemStatus: IndexingState
+	message?: string
+	processedItems?: number
+	totalItems?: number
+	currentItemUnit?: string
+	errorDetails?: {
+		type: "configuration" | "authentication" | "network" | "validation" | "unknown"
+		message: string
+		suggestion?: string
+		endpoint?: string
+		timestamp: number
+	}
+}
+
 export interface IndexProgressUpdate {
 	systemStatus: IndexingState
 	message?: string

src/services/code-index/manager.ts

@@ -229,31 +229,66 @@ export class CodeIndexManager {
 			console.error("Unexpected error loading .gitignore:", error)
 		}
 
-		// (Re)Create shared service instances
-		const { embedder, vectorStore, scanner, fileWatcher } = this._serviceFactory.createServices(
-			this.context,
-			this._cacheManager!,
-			ignoreInstance,
-		)
+		try {
+			// (Re)Create shared service instances
+			const { embedder, vectorStore, scanner, fileWatcher } = this._serviceFactory.createServices(
+				this.context,
+				this._cacheManager!,
+				ignoreInstance,
+			)
+
+			// (Re)Initialize orchestrator
+			this._orchestrator = new CodeIndexOrchestrator(
+				this._configManager!,
+				this._stateManager,
+				this.workspacePath,
+				this._cacheManager!,
+				vectorStore,
+				scanner,
+				fileWatcher,
+			)
+
+			// (Re)Initialize search service
+			this._searchService = new CodeIndexSearchService(
+				this._configManager!,
+				this._stateManager,
+				embedder,
+				vectorStore,
+			)
+		} catch (error) {
+			// Handle service creation errors
+			console.error("Failed to create code index services:", error)
+
+			// Determine error type and create appropriate error details
+			let errorType: "configuration" | "authentication" | "network" | "validation" | "unknown" = "unknown"
+			let errorMessage = error instanceof Error ? error.message : String(error)
+			let suggestion: string | undefined
+
+			if (errorMessage.includes("configuration missing") || errorMessage.includes("missing for")) {
+				errorType = "configuration"
+				suggestion = "Please check your embedder configuration in the settings."
+			} else if (errorMessage.includes("authentication") || errorMessage.includes("API key")) {
+				errorType = "authentication"
+				suggestion = "Please verify your API key is correct and has the necessary permissions."
+			} else if (errorMessage.includes("network") || errorMessage.includes("connect")) {
+				errorType = "network"
+				suggestion = "Please check your network connection and ensure the service endpoints are accessible."
+			} else if (errorMessage.includes("dimension") || errorMessage.includes("model")) {
+				errorType = "validation"
+				suggestion = "Please ensure your model configuration is compatible with the selected provider."
+			}
 
-		// (Re)Initialize orchestrator
-		this._orchestrator = new CodeIndexOrchestrator(
-			this._configManager!,
-			this._stateManager,
-			this.workspacePath,
-			this._cacheManager!,
-			vectorStore,
-			scanner,
-			fileWatcher,
-		)
+			// Set error state with details
+			this._stateManager.setSystemState("Error", errorMessage, {
+				type: errorType,
+				message: errorMessage,
+				suggestion,
+				timestamp: Date.now(),
+			})
 
-		// (Re)Initialize search service
-		this._searchService = new CodeIndexSearchService(
-			this._configManager!,
-			this._stateManager,
-			embedder,
-			vectorStore,
-		)
+			// Re-throw to be handled by caller
+			throw error
+		}
 	}
 
 	/**
@@ -279,4 +314,12 @@ export class CodeIndexManager {
 			}
 		}
 	}
+
+	/**
+	 * Gets the service factory instance for testing configurations.
+	 * @returns The service factory instance or undefined if not initialized
+	 */
+	public getServiceFactory(): CodeIndexServiceFactory | undefined {
+		return this._serviceFactory
+	}
 }