Fix tests

Author: cte

src/api/providers/__tests__/unbound.test.ts

@@ -21,12 +21,7 @@ jest.mock("openai", () => {
 							[Symbol.asyncIterator]: async function* () {
 								// First chunk with content
 								yield {
-									choices: [
-										{
-											delta: { content: "Test response" },
-											index: 0,
-										},
-									],
+									choices: [{ delta: { content: "Test response" }, index: 0 }],
 								}
 								// Second chunk with usage data
 								yield {
@@ -52,15 +47,14 @@ jest.mock("openai", () => {
 						}
 
 						const result = mockCreate(...args)
+
 						if (args[0].stream) {
 							mockWithResponse.mockReturnValue(
-								Promise.resolve({
-									data: stream,
-									response: { headers: new Map() },
-								}),
+								Promise.resolve({ data: stream, response: { headers: new Map() } }),
 							)
 							result.withResponse = mockWithResponse
 						}
+
 						return result
 					},
 				},
@@ -75,10 +69,10 @@ describe("UnboundHandler", () => {
 
 	beforeEach(() => {
 		mockOptions = {
-			apiModelId: "anthropic/claude-3-5-sonnet-20241022",
 			unboundApiKey: "test-api-key",
 			unboundModelId: "anthropic/claude-3-5-sonnet-20241022",
 		}
+
 		handler = new UnboundHandler(mockOptions)
 		mockCreate.mockClear()
 		mockWithResponse.mockClear()
@@ -97,9 +91,9 @@ describe("UnboundHandler", () => {
 	})
 
 	describe("constructor", () => {
-		it("should initialize with provided options", () => {
+		it("should initialize with provided options", async () => {
 			expect(handler).toBeInstanceOf(UnboundHandler)
-			expect(handler.getModel().id).toBe(mockOptions.apiModelId)
+			expect((await handler.fetchModel()).id).toBe(mockOptions.unboundModelId)
 		})
 	})
 
@@ -115,24 +109,18 @@ describe("UnboundHandler", () => {
 		it("should handle streaming responses with text and usage data", async () => {
 			const stream = handler.createMessage(systemPrompt, messages)
 			const chunks: Array<{ type: string } & Record<string, any>> = []
+
 			for await (const chunk of stream) {
 				chunks.push(chunk)
 			}
 
 			expect(chunks.length).toBe(3)
 
 			// Verify text chunk
-			expect(chunks[0]).toEqual({
-				type: "text",
-				text: "Test response",
-			})
+			expect(chunks[0]).toEqual({ type: "text", text: "Test response" })
 
 			// Verify regular usage data
-			expect(chunks[1]).toEqual({
-				type: "usage",
-				inputTokens: 10,
-				outputTokens: 5,
-			})
+			expect(chunks[1]).toEqual({ type: "usage", inputTokens: 10, outputTokens: 5 })
 
 			// Verify usage data with cache information
 			expect(chunks[2]).toEqual({
@@ -149,6 +137,7 @@ describe("UnboundHandler", () => {
 					messages: expect.any(Array),
 					stream: true,
 				}),
+
 				expect.objectContaining({
 					headers: {
 						"X-Unbound-Metadata": expect.stringContaining("roo-code"),
@@ -169,6 +158,7 @@ describe("UnboundHandler", () => {
 				for await (const chunk of stream) {
 					chunks.push(chunk)
 				}
+
 				fail("Expected error to be thrown")
 			} catch (error) {
 				expect(error).toBeInstanceOf(Error)
@@ -181,6 +171,7 @@ describe("UnboundHandler", () => {
 		it("should complete prompt successfully", async () => {
 			const result = await handler.completePrompt("Test prompt")
 			expect(result).toBe("Test response")
+
 			expect(mockCreate).toHaveBeenCalledWith(
 				expect.objectContaining({
 					model: "claude-3-5-sonnet-20241022",
@@ -202,24 +193,22 @@ describe("UnboundHandler", () => {
 		})
 
 		it("should handle empty response", async () => {
-			mockCreate.mockResolvedValueOnce({
-				choices: [{ message: { content: "" } }],
-			})
+			mockCreate.mockResolvedValueOnce({ choices: [{ message: { content: "" } }] })
 			const result = await handler.completePrompt("Test prompt")
 			expect(result).toBe("")
 		})
 
 		it("should not set max_tokens for non-Anthropic models", async () => {
 			mockCreate.mockClear()
 
-			const nonAnthropicOptions = {
+			const nonAnthropicHandler = new UnboundHandler({
 				apiModelId: "openai/gpt-4o",
 				unboundApiKey: "test-key",
 				unboundModelId: "openai/gpt-4o",
-			}
-			const nonAnthropicHandler = new UnboundHandler(nonAnthropicOptions)
+			})
 
 			await nonAnthropicHandler.completePrompt("Test prompt")
+
 			expect(mockCreate).toHaveBeenCalledWith(
 				expect.objectContaining({
 					model: "gpt-4o",
@@ -232,20 +221,21 @@ describe("UnboundHandler", () => {
 					}),
 				}),
 			)
+
 			expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("max_tokens")
 		})
 
 		it("should not set temperature for openai/o3-mini", async () => {
 			mockCreate.mockClear()
 
-			const openaiOptions = {
+			const openaiHandler = new UnboundHandler({
 				apiModelId: "openai/o3-mini",
 				unboundApiKey: "test-key",
 				unboundModelId: "openai/o3-mini",
-			}
-			const openaiHandler = new UnboundHandler(openaiOptions)
+			})
 
 			await openaiHandler.completePrompt("Test prompt")
+
 			expect(mockCreate).toHaveBeenCalledWith(
 				expect.objectContaining({
 					model: "o3-mini",
@@ -257,24 +247,22 @@ describe("UnboundHandler", () => {
 					}),
 				}),
 			)
+
 			expect(mockCreate.mock.calls[0][0]).not.toHaveProperty("temperature")
 		})
 	})
 
-	describe("getModel", () => {
-		it("should return model info", () => {
-			const modelInfo = handler.getModel()
-			expect(modelInfo.id).toBe(mockOptions.apiModelId)
+	describe("fetchModel", () => {
+		it("should return model info", async () => {
+			const modelInfo = await handler.fetchModel()
+			expect(modelInfo.id).toBe(mockOptions.unboundModelId)
 			expect(modelInfo.info).toBeDefined()
 		})
 
-		it("should return default model when invalid model provided", () => {
-			const handlerWithInvalidModel = new UnboundHandler({
-				...mockOptions,
-				unboundModelId: "invalid/model",
-			})
-			const modelInfo = handlerWithInvalidModel.getModel()
-			expect(modelInfo.id).toBe("anthropic/claude-3-5-sonnet-20241022") // Default model
+		it("should return default model when invalid model provided", async () => {
+			const handlerWithInvalidModel = new UnboundHandler({ ...mockOptions, unboundModelId: "invalid/model" })
+			const modelInfo = await handlerWithInvalidModel.fetchModel()
+			expect(modelInfo.id).toBe("anthropic/claude-3-7-sonnet-20250219")
 			expect(modelInfo.info).toBeDefined()
 		})
 	})

src/api/providers/router-provider.ts

@@ -43,7 +43,7 @@ export abstract class RouterProvider extends BaseProvider {
 		this.client = new OpenAI({ baseURL, apiKey })
 	}
 
-	protected async fetchModel() {
+	public async fetchModel() {
 		this.models = await getModels(this.name)
 		return this.getModel()
 	}

src/shared/api.ts

@@ -1087,7 +1087,7 @@ export const mistralModels = {
 
 // Unbound Security
 // https://www.unboundsecurity.ai/ai-gateway
-export const unboundDefaultModelId = "anthropic/claude-3-5-sonnet-20241022"
+export const unboundDefaultModelId = "anthropic/claude-3-7-sonnet-20250219"
 export const unboundDefaultModelInfo: ModelInfo = {
 	maxTokens: 8192,
 	contextWindow: 200_000,