refactor(code-index): move default model ID logic to embedders

Author: daniel-lxs

src/services/code-index/__tests__/service-factory.spec.ts

@@ -584,4 +584,189 @@ describe("CodeIndexServiceFactory", () => {
 			expect(() => factory.createVectorStore()).toThrow("Qdrant URL missing for vector store creation")
 		})
 	})
+
+	describe("validateEmbedderConfig", () => {
+		beforeEach(() => {
+			vitest.clearAllMocks()
+			// Mock the static validation methods
+			MockedOpenAiEmbedder.validateEndpoint = vitest.fn().mockResolvedValue(true)
+			MockedCodeIndexOllamaEmbedder.validateEndpoint = vitest.fn().mockResolvedValue(true)
+			MockedOpenAICompatibleEmbedder.validateEndpoint = vitest.fn().mockResolvedValue(true)
+		})
+
+		it("should validate OpenAI configuration with provided config", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "openai",
+				modelId: "text-embedding-3-large",
+				openAiOptions: {
+					openAiNativeApiKey: "test-api-key",
+				},
+			}
+
+			// Act
+			const result = await factory.validateEmbedderConfig(providedConfig)
+
+			// Assert
+			expect(result).toBe(true)
+			expect(MockedOpenAiEmbedder.validateEndpoint).toHaveBeenCalledWith("test-api-key", "text-embedding-3-large")
+		})
+
+		it("should validate Ollama configuration with provided config", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "ollama",
+				modelId: "nomic-embed-text:latest",
+				ollamaOptions: {
+					ollamaBaseUrl: "http://localhost:11434",
+				},
+			}
+
+			// Act
+			const result = await factory.validateEmbedderConfig(providedConfig)
+
+			// Assert
+			expect(result).toBe(true)
+			expect(MockedCodeIndexOllamaEmbedder.validateEndpoint).toHaveBeenCalledWith(
+				"http://localhost:11434",
+				"nomic-embed-text:latest",
+			)
+		})
+
+		it("should validate OpenAI-compatible configuration with provided config", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "openai-compatible",
+				modelId: "custom-model",
+				openAiCompatibleOptions: {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "test-api-key",
+				},
+			}
+
+			// Act
+			const result = await factory.validateEmbedderConfig(providedConfig)
+
+			// Assert
+			expect(result).toBe(true)
+			expect(MockedOpenAICompatibleEmbedder.validateEndpoint).toHaveBeenCalledWith(
+				"https://api.example.com/v1",
+				"test-api-key",
+				"custom-model",
+			)
+		})
+
+		it("should use current config when no config is provided", async () => {
+			// Arrange
+			const currentConfig = {
+				embedderProvider: "openai",
+				modelId: "text-embedding-3-small",
+				openAiOptions: {
+					openAiNativeApiKey: "current-api-key",
+				},
+			}
+			mockConfigManager.getConfig.mockReturnValue(currentConfig as any)
+
+			// Act
+			const result = await factory.validateEmbedderConfig()
+
+			// Assert
+			expect(result).toBe(true)
+			expect(mockConfigManager.getConfig).toHaveBeenCalled()
+			expect(MockedOpenAiEmbedder.validateEndpoint).toHaveBeenCalledWith(
+				"current-api-key",
+				"text-embedding-3-small",
+			)
+		})
+
+		it("should throw error for missing OpenAI API key", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "openai",
+				modelId: "text-embedding-3-large",
+				openAiOptions: {
+					openAiNativeApiKey: undefined,
+				},
+			}
+
+			// Act & Assert
+			await expect(factory.validateEmbedderConfig(providedConfig)).rejects.toThrow("OpenAI API key is required")
+		})
+
+		it("should throw error for missing Ollama base URL", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "ollama",
+				modelId: "nomic-embed-text:latest",
+				ollamaOptions: {
+					ollamaBaseUrl: undefined,
+				},
+			}
+
+			// Act & Assert
+			await expect(factory.validateEmbedderConfig(providedConfig)).rejects.toThrow("Ollama base URL is required")
+		})
+
+		it("should throw error for missing OpenAI-compatible credentials", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "openai-compatible",
+				modelId: "custom-model",
+				openAiCompatibleOptions: {
+					baseUrl: undefined,
+					apiKey: "test-api-key",
+				},
+			}
+
+			// Act & Assert
+			await expect(factory.validateEmbedderConfig(providedConfig)).rejects.toThrow(
+				"OpenAI-compatible base URL and API key are required",
+			)
+		})
+
+		it("should throw error for invalid embedder type", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "invalid-provider",
+				modelId: "some-model",
+			}
+
+			// Act & Assert
+			await expect(factory.validateEmbedderConfig(providedConfig)).rejects.toThrow(
+				"Invalid embedder type: invalid-provider",
+			)
+		})
+
+		it("should propagate validation errors from embedder", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "openai",
+				modelId: "text-embedding-3-large",
+				openAiOptions: {
+					openAiNativeApiKey: "invalid-key",
+				},
+			}
+			MockedOpenAiEmbedder.validateEndpoint = vitest.fn().mockRejectedValue(new Error("Invalid API key"))
+
+			// Act & Assert
+			await expect(factory.validateEmbedderConfig(providedConfig)).rejects.toThrow("Invalid API key")
+		})
+
+		it("should use default model ID when not provided", async () => {
+			// Arrange
+			const providedConfig = {
+				embedderProvider: "openai",
+				openAiOptions: {
+					openAiNativeApiKey: "test-api-key",
+				},
+			}
+
+			// Act
+			const result = await factory.validateEmbedderConfig(providedConfig)
+
+			// Assert
+			expect(result).toBe(true)
+			expect(MockedOpenAiEmbedder.validateEndpoint).toHaveBeenCalledWith("test-api-key", undefined)
+		})
+	})
 })

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

@@ -1,8 +1,9 @@
 import { ApiHandlerOptions } from "../../../shared/api"
 import { EmbedderInfo, EmbeddingResponse, IEmbedder } from "../interfaces"
-import { getModelQueryPrefix } from "../../../shared/embeddingModels"
+import { getModelQueryPrefix, getDefaultModelId } from "../../../shared/embeddingModels"
 import { MAX_ITEM_TOKENS } from "../constants"
 import { t } from "../../../i18n"
+import { serializeError } from "serialize-error"
 
 /**
  * Implements the IEmbedder interface using a local Ollama instance.
@@ -113,7 +114,8 @@ export class CodeIndexOllamaEmbedder implements IEmbedder {
 	 * @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> {
+	static async validateEndpoint(baseUrl: string, modelId: string | undefined): Promise<boolean> {
+		const effectiveModelId = modelId || getDefaultModelId("ollama")
 		const url = `${baseUrl}/api/tags`
 
 		try {
@@ -126,26 +128,63 @@ export class CodeIndexOllamaEmbedder implements IEmbedder {
 
 			if (!response.ok) {
 				if (response.status === 404) {
-					throw new Error(`Ollama API not found at ${baseUrl}. Is Ollama running?`)
+					throw new Error(t("embeddings:validation.apiNotFound", { provider: "Ollama", baseUrl }))
 				}
-				throw new Error(`Failed to connect to Ollama: ${response.status} ${response.statusText}`)
+				throw new Error(
+					t("embeddings:validation.connectionFailed", {
+						provider: "Ollama",
+						status: response.status,
+						statusText: 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"}`)
+			if (!modelNames.includes(effectiveModelId)) {
+				throw new Error(
+					t("embeddings:validation.modelNotFound", {
+						modelId: effectiveModelId,
+						availableModels: 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.`)
+			// If it's already a translated error, re-throw it
+			if (
+				error?.message?.includes(
+					t("embeddings:validation.modelNotFound", { modelId: "", availableModels: "" }).split(":")[0],
+				) ||
+				error?.message?.includes(
+					t("embeddings:validation.apiNotFound", { provider: "", baseUrl: "" }).split(":")[0],
+				) ||
+				error?.message?.includes(
+					t("embeddings:validation.connectionFailed", { provider: "", status: "", statusText: "" }).split(
+						":",
+					)[0],
+				)
+			) {
+				throw error
 			}
-			throw error
+
+			const serialized = serializeError(error)
+
+			if (error.message?.includes("fetch failed") || error.message?.includes("ECONNREFUSED")) {
+				throw new Error(t("embeddings:validation.cannotConnect", { provider: "Ollama", baseUrl }))
+			}
+
+			const errorDetails = serialized.message || t("embeddings:unknownError")
+			throw new Error(
+				t("embeddings:genericError", {
+					provider: "Ollama",
+					errorDetails,
+				}),
+			)
 		}
 	}
 }

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

@@ -8,6 +8,7 @@ import {
 } from "../constants"
 import { getDefaultModelId, getModelQueryPrefix } from "../../../shared/embeddingModels"
 import { t } from "../../../i18n"
+import { serializeError } from "serialize-error"
 
 interface EmbeddingItem {
 	embedding: string | number[]
@@ -50,10 +51,10 @@ export class OpenAICompatibleEmbedder implements IEmbedder {
 	 */
 	constructor(baseUrl: string, apiKey: string, modelId?: string, maxItemTokens?: number) {
 		if (!baseUrl) {
-			throw new Error("Base URL is required for OpenAI Compatible embedder")
+			throw new Error(t("embeddings:validation.baseUrlRequired", { provider: "OpenAI Compatible" }))
 		}
 		if (!apiKey) {
-			throw new Error("API key is required for OpenAI Compatible embedder")
+			throw new Error(t("embeddings:validation.apiKeyRequired", { provider: "OpenAI Compatible" }))
 		}
 
 		this.baseUrl = baseUrl
@@ -76,36 +77,40 @@ export class OpenAICompatibleEmbedder implements IEmbedder {
 	 * @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> {
+	static async validateEndpoint(baseUrl: string, apiKey: string, modelId: string | undefined): Promise<boolean> {
 		try {
 			const client = new OpenAI({
 				baseURL: baseUrl,
 				apiKey: apiKey,
 			})
 
-			const testModel = modelId || getDefaultModelId("openai-compatible")
+			const effectiveModelId = modelId || getDefaultModelId("openai-compatible")
 
 			// Try a minimal embedding request
 			await client.embeddings.create({
 				input: "test",
-				model: testModel,
+				model: effectiveModelId,
 			})
 
 			return true
 		} catch (error: any) {
-			let errorMessage = t("embeddings:unknownError")
+			const serialized = serializeError(error)
 
 			if (error?.status === 401) {
-				errorMessage = t("embeddings:authenticationFailed")
+				throw new Error(t("embeddings:authenticationFailed"))
 			} else if (error?.status === 404) {
-				errorMessage = `Endpoint not found: ${baseUrl}`
+				throw new Error(t("embeddings:validation.endpointNotFound", { baseUrl }))
 			} else if (error?.code === "ECONNREFUSED" || error?.code === "ENOTFOUND") {
-				errorMessage = `Cannot connect to ${baseUrl}`
-			} else if (error?.message) {
-				errorMessage = error.message
+				throw new Error(t("embeddings:validation.cannotConnect", { provider: "OpenAI Compatible", baseUrl }))
 			}
 
-			throw new Error(errorMessage)
+			const errorDetails = serialized.message || t("embeddings:unknownError")
+			throw new Error(
+				t("embeddings:genericError", {
+					provider: "OpenAI Compatible",
+					errorDetails,
+				}),
+			)
 		}
 	}