feat: Add OpenAI Compatible embedder for codebase indexing

packages/types/src/__tests__/index.test.ts

@@ -14,4 +14,12 @@ describe("GLOBAL_STATE_KEYS", () => {
 	it("should not contain secret state keys", () => {
 		expect(GLOBAL_STATE_KEYS).not.toContain("openRouterApiKey")
 	})
+
+	it("should contain OpenAI Compatible base URL setting", () => {
+		expect(GLOBAL_STATE_KEYS).toContain("codebaseIndexOpenAiCompatibleBaseUrl")
+	})
+
+	it("should not contain OpenAI Compatible API key (secret)", () => {
+		expect(GLOBAL_STATE_KEYS).not.toContain("codebaseIndexOpenAiCompatibleApiKey")
+	})
 })

packages/types/src/codebase-index.ts

@@ -7,7 +7,7 @@ import { z } from "zod"
 export const codebaseIndexConfigSchema = z.object({
 	codebaseIndexEnabled: z.boolean().optional(),
 	codebaseIndexQdrantUrl: z.string().optional(),
-	codebaseIndexEmbedderProvider: z.enum(["openai", "ollama"]).optional(),
+	codebaseIndexEmbedderProvider: z.enum(["openai", "ollama", "openai-compatible"]).optional(),
 	codebaseIndexEmbedderBaseUrl: z.string().optional(),
 	codebaseIndexEmbedderModelId: z.string().optional(),
 })
@@ -21,6 +21,7 @@ export type CodebaseIndexConfig = z.infer<typeof codebaseIndexConfigSchema>
 export const codebaseIndexModelsSchema = z.object({
 	openai: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 	ollama: z.record(z.string(), z.object({ dimension: z.number() })).optional(),
+	"openai-compatible": z.record(z.string(), z.object({ dimension: z.number() })).optional(),
 })
 
 export type CodebaseIndexModels = z.infer<typeof codebaseIndexModelsSchema>
@@ -32,6 +33,8 @@ export type CodebaseIndexModels = z.infer<typeof codebaseIndexModelsSchema>
 export const codebaseIndexProviderSchema = z.object({
 	codeIndexOpenAiKey: z.string().optional(),
 	codeIndexQdrantApiKey: z.string().optional(),
+	codebaseIndexOpenAiCompatibleBaseUrl: z.string().optional(),
+	codebaseIndexOpenAiCompatibleApiKey: z.string().optional(),
 })
 
 export type CodebaseIndexProvider = z.infer<typeof codebaseIndexProviderSchema>

packages/types/src/global-settings.ts

@@ -219,6 +219,7 @@ export type SecretState = Pick<
 	| "litellmApiKey"
 	| "codeIndexOpenAiKey"
 	| "codeIndexQdrantApiKey"
+	| "codebaseIndexOpenAiCompatibleApiKey"
 >
 
 export const SECRET_STATE_KEYS = keysOf<SecretState>()([
@@ -241,6 +242,7 @@ export const SECRET_STATE_KEYS = keysOf<SecretState>()([
 	"litellmApiKey",
 	"codeIndexOpenAiKey",
 	"codeIndexQdrantApiKey",
+	"codebaseIndexOpenAiCompatibleApiKey",
 ])
 
 export const isSecretStateKey = (key: string): key is Keys<SecretState> =>

packages/types/src/provider-settings.ts

@@ -330,6 +330,8 @@ export const PROVIDER_SETTINGS_KEYS = keysOf<ProviderSettings>()([
 	// Code Index
 	"codeIndexOpenAiKey",
 	"codeIndexQdrantApiKey",
+	"codebaseIndexOpenAiCompatibleBaseUrl",
+	"codebaseIndexOpenAiCompatibleApiKey",
 	// Reasoning
 	"enableReasoningEffort",
 	"reasoningEffort",

src/services/code-index/__tests__/config-manager.test.ts

@@ -74,6 +74,44 @@ describe("CodeIndexConfigManager", () => {
 			})
 		})
 
+		it("should load OpenAI Compatible configuration from globalState and secrets", async () => {
+			const mockGlobalState = {
+				codebaseIndexEnabled: true,
+				codebaseIndexQdrantUrl: "http://qdrant.local",
+				codebaseIndexEmbedderProvider: "openai-compatible",
+				codebaseIndexEmbedderBaseUrl: "",
+				codebaseIndexEmbedderModelId: "text-embedding-3-large",
+			}
+			mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+				if (key === "codebaseIndexConfig") return mockGlobalState
+				if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return "https://api.example.com/v1"
+				return undefined
+			})
+			mockContextProxy.getSecret.mockImplementation((key: string) => {
+				if (key === "codeIndexQdrantApiKey") return "test-qdrant-key"
+				if (key === "codebaseIndexOpenAiCompatibleApiKey") return "test-openai-compatible-key"
+				return undefined
+			})
+
+			const result = await configManager.loadConfiguration()
+
+			expect(result.currentConfig).toEqual({
+				isEnabled: true,
+				isConfigured: true,
+				embedderProvider: "openai-compatible",
+				modelId: "text-embedding-3-large",
+				openAiOptions: { openAiNativeApiKey: "" },
+				ollamaOptions: { ollamaBaseUrl: "" },
+				openAiCompatibleOptions: {
+					baseUrl: "https://api.example.com/v1",
+					apiKey: "test-openai-compatible-key",
+				},
+				qdrantUrl: "http://qdrant.local",
+				qdrantApiKey: "test-qdrant-key",
+				searchMinScore: 0.4,
+			})
+		})
+
 		it("should detect restart requirement when provider changes", async () => {
 			// Initial state - properly configured
 			mockContextProxy.getGlobalState.mockReturnValue({
@@ -270,6 +308,76 @@ describe("CodeIndexConfigManager", () => {
 				expect(result.requiresRestart).toBe(true)
 			})
 
+			it("should handle OpenAI Compatible configuration changes", async () => {
+				// Initial state
+				mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+					if (key === "codebaseIndexConfig") {
+						return {
+							codebaseIndexEnabled: true,
+							codebaseIndexQdrantUrl: "http://qdrant.local",
+							codebaseIndexEmbedderProvider: "openai-compatible",
+							codebaseIndexEmbedderModelId: "text-embedding-3-small",
+						}
+					}
+					if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return "https://old-api.example.com/v1"
+					return undefined
+				})
+				mockContextProxy.getSecret.mockImplementation((key: string) => {
+					if (key === "codebaseIndexOpenAiCompatibleApiKey") return "old-api-key"
+					return undefined
+				})
+
+				await configManager.loadConfiguration()
+
+				// Change OpenAI Compatible base URL
+				mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+					if (key === "codebaseIndexConfig") {
+						return {
+							codebaseIndexEnabled: true,
+							codebaseIndexQdrantUrl: "http://qdrant.local",
+							codebaseIndexEmbedderProvider: "openai-compatible",
+							codebaseIndexEmbedderModelId: "text-embedding-3-small",
+						}
+					}
+					if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return "https://new-api.example.com/v1"
+					return undefined
+				})
+
+				const result = await configManager.loadConfiguration()
+				expect(result.requiresRestart).toBe(true)
+			})
+
+			it("should handle OpenAI Compatible API key changes", async () => {
+				// Initial state
+				mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+					if (key === "codebaseIndexConfig") {
+						return {
+							codebaseIndexEnabled: true,
+							codebaseIndexQdrantUrl: "http://qdrant.local",
+							codebaseIndexEmbedderProvider: "openai-compatible",
+							codebaseIndexEmbedderModelId: "text-embedding-3-small",
+						}
+					}
+					if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return "https://api.example.com/v1"
+					return undefined
+				})
+				mockContextProxy.getSecret.mockImplementation((key: string) => {
+					if (key === "codebaseIndexOpenAiCompatibleApiKey") return "old-api-key"
+					return undefined
+				})
+
+				await configManager.loadConfiguration()
+
+				// Change OpenAI Compatible API key
+				mockContextProxy.getSecret.mockImplementation((key: string) => {
+					if (key === "codebaseIndexOpenAiCompatibleApiKey") return "new-api-key"
+					return undefined
+				})
+
+				const result = await configManager.loadConfiguration()
+				expect(result.requiresRestart).toBe(true)
+			})
+
 			it("should not require restart when disabled remains disabled", async () => {
 				// Initial state - disabled but configured
 				mockContextProxy.getGlobalState.mockReturnValue({
@@ -448,6 +556,69 @@ describe("CodeIndexConfigManager", () => {
 			expect(configManager.isFeatureConfigured).toBe(true)
 		})
 
+		it("should validate OpenAI Compatible configuration correctly", async () => {
+			mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+				if (key === "codebaseIndexConfig") {
+					return {
+						codebaseIndexEnabled: true,
+						codebaseIndexQdrantUrl: "http://qdrant.local",
+						codebaseIndexEmbedderProvider: "openai-compatible",
+					}
+				}
+				if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return "https://api.example.com/v1"
+				return undefined
+			})
+			mockContextProxy.getSecret.mockImplementation((key: string) => {
+				if (key === "codebaseIndexOpenAiCompatibleApiKey") return "test-api-key"
+				return undefined
+			})
+
+			await configManager.loadConfiguration()
+			expect(configManager.isFeatureConfigured).toBe(true)
+		})
+
+		it("should return false when OpenAI Compatible base URL is missing", async () => {
+			mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+				if (key === "codebaseIndexConfig") {
+					return {
+						codebaseIndexEnabled: true,
+						codebaseIndexQdrantUrl: "http://qdrant.local",
+						codebaseIndexEmbedderProvider: "openai-compatible",
+					}
+				}
+				if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return ""
+				return undefined
+			})
+			mockContextProxy.getSecret.mockImplementation((key: string) => {
+				if (key === "codebaseIndexOpenAiCompatibleApiKey") return "test-api-key"
+				return undefined
+			})
+
+			await configManager.loadConfiguration()
+			expect(configManager.isFeatureConfigured).toBe(false)
+		})
+
+		it("should return false when OpenAI Compatible API key is missing", async () => {
+			mockContextProxy.getGlobalState.mockImplementation((key: string) => {
+				if (key === "codebaseIndexConfig") {
+					return {
+						codebaseIndexEnabled: true,
+						codebaseIndexQdrantUrl: "http://qdrant.local",
+						codebaseIndexEmbedderProvider: "openai-compatible",
+					}
+				}
+				if (key === "codebaseIndexOpenAiCompatibleBaseUrl") return "https://api.example.com/v1"
+				return undefined
+			})
+			mockContextProxy.getSecret.mockImplementation((key: string) => {
+				if (key === "codebaseIndexOpenAiCompatibleApiKey") return ""
+				return undefined
+			})
+
+			await configManager.loadConfiguration()
+			expect(configManager.isFeatureConfigured).toBe(false)
+		})
+
 		it("should return false when required values are missing", async () => {
 			mockContextProxy.getGlobalState.mockReturnValue({
 				codebaseIndexEnabled: true,