fix: support full endpoint URLs in OpenAI Compatible provider (#5212)

SannidhyaSah · SannidhyaSah · commit 49e775a4f18f · 2025-06-28T13:21:29.000+05:30
diff --git a/src/services/code-index/embedders/__tests__/openai-compatible.spec.ts b/src/services/code-index/embedders/__tests__/openai-compatible.spec.ts
@@ -6,6 +6,9 @@ import { MAX_ITEM_TOKENS, INITIAL_RETRY_DELAY_MS } from "../../constants"
 // Mock the OpenAI SDK
 vitest.mock("openai")
 
+// Mock global fetch
+global.fetch = vitest.fn()
+
 // Mock i18n
 vitest.mock("../../../../i18n", () => ({
 	t: (key: string, params?: Record<string, any>) => {
@@ -613,5 +616,159 @@ describe("OpenAICompatibleEmbedder", () => {
 				expect(returnedArray).toEqual([0.25, 0.5, 0.75, 1.0])
 			})
 		})
+
+		/**
+		 * Test Azure OpenAI compatibility with helper functions for conciseness
+		 */
+		describe("Azure OpenAI compatibility", () => {
+			const azureUrl =
+				"https://myresource.openai.azure.com/openai/deployments/mymodel/embeddings?api-version=2024-02-01"
+			const baseUrl = "https://api.openai.com/v1"
+
+			// Helper to create mock fetch response
+			const createMockResponse = (data: any, status = 200, ok = true) => ({
+				ok,
+				status,
+				json: vitest.fn().mockResolvedValue(data),
+				text: vitest.fn().mockResolvedValue(status === 200 ? "" : "Error message"),
+			})
+
+			// Helper to create base64 embedding
+			const createBase64Embedding = (values: number[]) => {
+				const embedding = new Float32Array(values)
+				return Buffer.from(embedding.buffer).toString("base64")
+			}
+
+			// Helper to verify embedding values with floating-point tolerance
+			const expectEmbeddingValues = (actual: number[], expected: number[]) => {
+				expect(actual).toHaveLength(expected.length)
+				expected.forEach((val, i) => expect(actual[i]).toBeCloseTo(val, 5))
+			}
+
+			beforeEach(() => {
+				vitest.clearAllMocks()
+				;(global.fetch as MockedFunction<typeof fetch>).mockReset()
+			})
+
+			describe("URL detection", () => {
+				it.each([
+					[
+						"https://myresource.openai.azure.com/openai/deployments/mymodel/embeddings?api-version=2024-02-01",
+						true,
+					],
+					["https://myresource.openai.azure.com/openai/deployments/text-embedding-ada-002/embeddings", true],
+					["https://api.openai.com/v1", false],
+					["https://api.example.com", false],
+					["http://localhost:8080", false],
+				])("should detect URL type correctly: %s -> %s", (url, expected) => {
+					const embedder = new OpenAICompatibleEmbedder(url, testApiKey, testModelId)
+					const isFullUrl = (embedder as any).isFullEndpointUrl(url)
+					expect(isFullUrl).toBe(expected)
+				})
+			})
+
+			describe("direct HTTP requests", () => {
+				it("should use direct fetch for Azure URLs and SDK for base URLs", async () => {
+					const testTexts = ["Test text"]
+					const base64String = createBase64Embedding([0.1, 0.2, 0.3])
+
+					// Test Azure URL (direct fetch)
+					const azureEmbedder = new OpenAICompatibleEmbedder(azureUrl, testApiKey, testModelId)
+					const mockFetchResponse = createMockResponse({
+						data: [{ embedding: base64String }],
+						usage: { prompt_tokens: 10, total_tokens: 15 },
+					})
+					;(global.fetch as MockedFunction<typeof fetch>).mockResolvedValue(mockFetchResponse as any)
+
+					const azureResult = await azureEmbedder.createEmbeddings(testTexts)
+					expect(global.fetch).toHaveBeenCalledWith(
+						azureUrl,
+						expect.objectContaining({
+							method: "POST",
+							headers: expect.objectContaining({
+								"api-key": testApiKey,
+								Authorization: `Bearer ${testApiKey}`,
+							}),
+						}),
+					)
+					expect(mockEmbeddingsCreate).not.toHaveBeenCalled()
+					expectEmbeddingValues(azureResult.embeddings[0], [0.1, 0.2, 0.3])
+
+					// Reset and test base URL (SDK)
+					vitest.clearAllMocks()
+					const baseEmbedder = new OpenAICompatibleEmbedder(baseUrl, testApiKey, testModelId)
+					mockEmbeddingsCreate.mockResolvedValue({
+						data: [{ embedding: [0.4, 0.5, 0.6] }],
+						usage: { prompt_tokens: 10, total_tokens: 15 },
+					})
+
+					const baseResult = await baseEmbedder.createEmbeddings(testTexts)
+					expect(mockEmbeddingsCreate).toHaveBeenCalled()
+					expect(global.fetch).not.toHaveBeenCalled()
+					expect(baseResult.embeddings[0]).toEqual([0.4, 0.5, 0.6])
+				})
+
+				it.each([
+					[401, "Authentication failed. Please check your API key."],
+					[500, "Failed to create embeddings after 3 attempts"],
+				])("should handle HTTP errors: %d", async (status, expectedMessage) => {
+					const embedder = new OpenAICompatibleEmbedder(azureUrl, testApiKey, testModelId)
+					const mockResponse = createMockResponse({}, status, false)
+					;(global.fetch as MockedFunction<typeof fetch>).mockResolvedValue(mockResponse as any)
+
+					await expect(embedder.createEmbeddings(["test"])).rejects.toThrow(expectedMessage)
+				})
+
+				it("should handle rate limiting with retries", async () => {
+					vitest.useFakeTimers()
+					const embedder = new OpenAICompatibleEmbedder(azureUrl, testApiKey, testModelId)
+					const base64String = createBase64Embedding([0.1, 0.2, 0.3])
+
+					;(global.fetch as MockedFunction<typeof fetch>)
+						.mockResolvedValueOnce(createMockResponse({}, 429, false) as any)
+						.mockResolvedValueOnce(createMockResponse({}, 429, false) as any)
+						.mockResolvedValueOnce(
+							createMockResponse({
+								data: [{ embedding: base64String }],
+								usage: { prompt_tokens: 10, total_tokens: 15 },
+							}) as any,
+						)
+
+					const resultPromise = embedder.createEmbeddings(["test"])
+					await vitest.advanceTimersByTimeAsync(INITIAL_RETRY_DELAY_MS * 3)
+					const result = await resultPromise
+
+					expect(global.fetch).toHaveBeenCalledTimes(3)
+					expect(console.warn).toHaveBeenCalledWith(expect.stringContaining("Rate limit hit"))
+					expectEmbeddingValues(result.embeddings[0], [0.1, 0.2, 0.3])
+					vitest.useRealTimers()
+				})
+
+				it("should handle multiple embeddings and network errors", async () => {
+					const embedder = new OpenAICompatibleEmbedder(azureUrl, testApiKey, testModelId)
+
+					// Test multiple embeddings
+					const base64_1 = createBase64Embedding([0.25, 0.5])
+					const base64_2 = createBase64Embedding([0.75, 1.0])
+					const mockResponse = createMockResponse({
+						data: [{ embedding: base64_1 }, { embedding: base64_2 }],
+						usage: { prompt_tokens: 20, total_tokens: 30 },
+					})
+					;(global.fetch as MockedFunction<typeof fetch>).mockResolvedValue(mockResponse as any)
+
+					const result = await embedder.createEmbeddings(["test1", "test2"])
+					expect(result.embeddings).toHaveLength(2)
+					expectEmbeddingValues(result.embeddings[0], [0.25, 0.5])
+					expectEmbeddingValues(result.embeddings[1], [0.75, 1.0])
+
+					// Test network error
+					const networkError = new Error("Network failed")
+					;(global.fetch as MockedFunction<typeof fetch>).mockRejectedValue(networkError)
+					await expect(embedder.createEmbeddings(["test"])).rejects.toThrow(
+						"Failed to create embeddings after 3 attempts",
+					)
+				})
+			})
+		})
 	})
 })
diff --git a/src/services/code-index/embedders/openai-compatible.ts b/src/services/code-index/embedders/openai-compatible.ts
@@ -29,6 +29,8 @@ interface OpenAIEmbeddingResponse {
 export class OpenAICompatibleEmbedder implements IEmbedder {
 	private embeddingsClient: OpenAI
 	private readonly defaultModelId: string
+	private readonly baseUrl: string
+	private readonly apiKey: string
 
 	/**
 	 * Creates a new OpenAI Compatible embedder
@@ -44,6 +46,8 @@ export class OpenAICompatibleEmbedder implements IEmbedder {
 			throw new Error("API key is required for OpenAI Compatible embedder")
 		}
 
+		this.baseUrl = baseUrl
+		this.apiKey = apiKey
 		this.embeddingsClient = new OpenAI({
 			baseURL: baseUrl,
 			apiKey: apiKey,
@@ -109,6 +113,56 @@ export class OpenAICompatibleEmbedder implements IEmbedder {
 		return { embeddings: allEmbeddings, usage }
 	}
 
+	/**
+	 * Determines if the provided URL is a full endpoint URL (contains /embeddings or /deployments/)
+	 * or a base URL that needs the endpoint appended by the SDK
+	 * @param url The URL to check
+	 * @returns true if it's a full endpoint URL, false if it's a base URL
+	 */
+	private isFullEndpointUrl(url: string): boolean {
+		// Check if the URL contains common embedding endpoint patterns
+		return url.includes("/embeddings") || url.includes("/deployments/")
+	}
+
+	/**
+	 * Makes a direct HTTP request to the embeddings endpoint
+	 * Used when the user provides a full endpoint URL (e.g., Azure OpenAI with query parameters)
+	 * @param url The full endpoint URL
+	 * @param batchTexts Array of texts to embed
+	 * @param model Model identifier to use
+	 * @returns Promise resolving to OpenAI-compatible response
+	 */
+	private async makeDirectEmbeddingRequest(
+		url: string,
+		batchTexts: string[],
+		model: string,
+	): Promise<OpenAIEmbeddingResponse> {
+		const response = await fetch(url, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				// Azure OpenAI uses 'api-key' header, while OpenAI uses 'Authorization'
+				// We'll try 'api-key' first for Azure compatibility
+				"api-key": this.apiKey,
+				Authorization: `Bearer ${this.apiKey}`,
+			},
+			body: JSON.stringify({
+				input: batchTexts,
+				model: model,
+				encoding_format: "base64",
+			}),
+		})
+
+		if (!response.ok) {
+			const errorText = await response.text()
+			const error: any = new Error(`HTTP ${response.status}: ${errorText}`)
+			error.status = response.status
+			throw error
+		}
+
+		return await response.json()
+	}
+
 	/**
 	 * Helper method to handle batch embedding with retries and exponential backoff
 	 * @param batchTexts Array of texts to embed in this batch
@@ -119,16 +173,26 @@ export class OpenAICompatibleEmbedder implements IEmbedder {
 		batchTexts: string[],
 		model: string,
 	): Promise<{ embeddings: number[][]; usage: { promptTokens: number; totalTokens: number } }> {
+		const isFullUrl = this.isFullEndpointUrl(this.baseUrl)
+
 		for (let attempts = 0; attempts < MAX_RETRIES; attempts++) {
 			try {
-				const response = (await this.embeddingsClient.embeddings.create({
-					input: batchTexts,
-					model: model,
-					// OpenAI package (as of v4.78.1) has a parsing issue that truncates embedding dimensions to 256
-					// when processing numeric arrays, which breaks compatibility with models using larger dimensions.
-					// By requesting base64 encoding, we bypass the package's parser and handle decoding ourselves.
-					encoding_format: "base64",
-				})) as OpenAIEmbeddingResponse
+				let response: OpenAIEmbeddingResponse
+
+				if (isFullUrl) {
+					// Use direct HTTP request for full endpoint URLs
+					response = await this.makeDirectEmbeddingRequest(this.baseUrl, batchTexts, model)
+				} else {
+					// Use OpenAI SDK for base URLs
+					response = (await this.embeddingsClient.embeddings.create({
+						input: batchTexts,
+						model: model,
+						// OpenAI package (as of v4.78.1) has a parsing issue that truncates embedding dimensions to 256
+						// when processing numeric arrays, which breaks compatibility with models using larger dimensions.
+						// By requesting base64 encoding, we bypass the package's parser and handle decoding ourselves.
+						encoding_format: "base64",
+					})) as OpenAIEmbeddingResponse
+				}
 
 				// Convert base64 embeddings to float32 arrays
 				const processedEmbeddings = response.data.map((item: EmbeddingItem) => {
