test: add more tests to vscode-lm.spec.ts

Author: rrewll

src/api/providers/__tests__/vscode-lm.spec.ts

@@ -12,13 +12,15 @@ vi.mock("vscode", () => {
 		constructor(
 			public callId: string,
 			public name: string,
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 			public input: any,
 		) {}
 	}
 
 	return {
 		workspace: {
 			getConfiguration: vi.fn(() => ({
+				// eslint-disable-next-line @typescript-eslint/no-explicit-any
 				get: vi.fn((key: string, defaultValue: any) => defaultValue),
 			})),
 			onDidChangeConfiguration: vi.fn((_callback) => ({
@@ -106,6 +108,14 @@ describe("VsCodeLmHandler", () => {
 			// Should reset client when config changes
 			expect(handler["client"]).toBeNull()
 		})
+
+		it("should call initializeClient during construction", () => {
+			// Constructor calls initializeClient() without await, so it starts async initialization.
+			// Verify the handler is created and initializeClient was triggered.
+			expect(handler).toBeDefined()
+			// The constructor triggers initializeClient which calls selectChatModels
+			expect(vscode.lm.selectChatModels).toHaveBeenCalled()
+		})
 	})
 
 	describe("createClient", () => {
@@ -135,6 +145,14 @@ describe("VsCodeLmHandler", () => {
 			expect(client.id).toBe("default-lm")
 			expect(client.vendor).toBe("vscode")
 		})
+
+		it("should throw a Zoo Code branded error when selectChatModels fails", async () => {
+			;(vscode.lm.selectChatModels as Mock).mockRejectedValueOnce(new Error("network down"))
+
+			await expect(handler["createClient"]({ vendor: "test" })).rejects.toThrow(
+				"Zoo Code <Language Model API>: Failed to select model: network down",
+			)
+		})
 	})
 
 	describe("createMessage", () => {
@@ -471,18 +489,264 @@ describe("VsCodeLmHandler", () => {
 				expect.stringContaining("STREAM_ERROR"),
 			)
 
+			consoleErrorSpy.mockRestore()
+		})
+		it("should log Zoo Code branded warning for unknown chunk type in stream", async () => {
+			const systemPrompt = "You are a helpful assistant"
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user" as const, content: "Hello" }]
+
+			const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					// Yield an unknown chunk type (not TextPart, not ToolCallPart)
+					// eslint-disable-next-line @typescript-eslint/no-explicit-any
+					yield { type: "unknown", foo: "bar" } as any
+					return
+				})(),
+				text: (async function* () {
+					yield ""
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages)
+			for await (const _chunk of stream) {
+				// drain
+			}
+
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Unknown chunk type received:",
+				expect.objectContaining({ type: "unknown" }),
+			)
+
+			consoleWarnSpy.mockRestore()
+		})
+
+		it("should log Zoo Code branded warning for invalid text part value", async () => {
+			const systemPrompt = "You are a helpful assistant"
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user" as const, content: "Hello" }]
+
+			const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			// Create a TextPart with a non-string value (number)
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const badTextPart = new vscode.LanguageModelTextPart(42 as any)
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					yield badTextPart
+					return
+				})(),
+				text: (async function* () {
+					yield ""
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages)
+			for await (const _chunk of stream) {
+				// drain
+			}
+
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Invalid text part value received:",
+				42,
+			)
+
+			consoleWarnSpy.mockRestore()
+		})
+
+		it("should log Zoo Code branded warning for invalid tool callId", async () => {
+			const systemPrompt = "You are a helpful assistant"
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user" as const, content: "Hello" }]
+
+			const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			// Create a ToolCallPart with a non-string callId
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const badToolCall = new vscode.LanguageModelToolCallPart(123 as any, "valid-name", {})
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					yield badToolCall
+					return
+				})(),
+				text: (async function* () {
+					yield ""
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages)
+			for await (const _chunk of stream) {
+				// drain
+			}
+
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Invalid tool callId received:",
+				123,
+			)
+
+			consoleWarnSpy.mockRestore()
+		})
+
+		it("should log Zoo Code branded warning for invalid tool input", async () => {
+			const systemPrompt = "You are a helpful assistant"
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user" as const, content: "Hello" }]
+
+			const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			// Create a ToolCallPart with a string input (not an object)
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const badToolCall = new vscode.LanguageModelToolCallPart("call-1", "valid-name", "not-an-object" as any)
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					yield badToolCall
+					return
+				})(),
+				text: (async function* () {
+					yield ""
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages)
+			for await (const _chunk of stream) {
+				// drain
+			}
+
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Invalid tool input received:",
+				"not-an-object",
+			)
+
+			consoleWarnSpy.mockRestore()
+		})
+
+		it("should log Zoo Code branded error when tool call processing fails", async () => {
+			const systemPrompt = "You are a helpful assistant"
+			const messages: Anthropic.Messages.MessageParam[] = [{ role: "user" as const, content: "Hello" }]
+
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+
+			// Create a ToolCallPart with circular input that will throw on JSON.stringify
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			const circularInput: any = { name: "circular" }
+			circularInput.self = circularInput
+
+			const badToolCall = new vscode.LanguageModelToolCallPart("call-1", "valid-name", circularInput)
+			mockLanguageModelChat.sendRequest.mockResolvedValueOnce({
+				stream: (async function* () {
+					yield badToolCall
+					return
+				})(),
+				text: (async function* () {
+					yield ""
+					return
+				})(),
+			})
+
+			const stream = handler.createMessage(systemPrompt, messages, {
+				taskId: "test-task",
+				tools: [
+					{
+						type: "function" as const,
+						function: { name: "test", description: "", parameters: { type: "object", properties: {} } },
+					},
+				],
+			})
+			for await (const _chunk of stream) {
+				// drain
+			}
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Failed to process tool call:",
+				expect.any(Error),
+			)
+
+			consoleErrorSpy.mockRestore()
+		})
+	})
+
+	describe("getClient", () => {
+		it("should log Zoo Code branded debug when creating client with selector", async () => {
+			const consoleDebugSpy = vi.spyOn(console, "debug").mockImplementation(() => {})
+			const mockModel = { ...mockLanguageModelChat }
+			;(vscode.lm.selectChatModels as Mock).mockResolvedValue([mockModel])
+			handler["client"] = null
+
+			// @ts-ignore – access private method for coverage
+			await handler["getClient"]()
+
+			expect(consoleDebugSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Creating client with selector:",
+				expect.any(Object),
+			)
+
+			consoleDebugSpy.mockRestore()
+		})
+
+		it("should throw a Zoo Code branded error when getClient fails to create client", async () => {
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+			;(vscode.lm.selectChatModels as Mock).mockRejectedValueOnce(new Error("network error"))
+			handler["client"] = null
+
+			// @ts-ignore – access private method for coverage
+			await expect(handler["getClient"]()).rejects.toThrow(
+				"Zoo Code <Language Model API>: Failed to create client:",
+			)
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Client creation failed:",
+				expect.stringContaining("network error"),
+			)
+
 			consoleErrorSpy.mockRestore()
 		})
 	})
 
 	describe("initializeClient", () => {
+		it("should log when client is already initialized", async () => {
+			const consoleDebugSpy = vi.spyOn(console, "debug").mockImplementation(() => {})
+
+			handler["client"] = mockLanguageModelChat
+			await handler.initializeClient()
+
+			expect(consoleDebugSpy).toHaveBeenCalledWith("Zoo Code <Language Model API>: Client already initialized")
+
+			consoleDebugSpy.mockRestore()
+		})
+
+		it("should log success when client is initialized", async () => {
+			const consoleDebugSpy = vi.spyOn(console, "debug").mockImplementation(() => {})
+			const mockModel = { ...mockLanguageModelChat }
+			;(vscode.lm.selectChatModels as Mock).mockResolvedValue([mockModel])
+			handler["client"] = null
+
+			await handler.initializeClient()
+
+			expect(consoleDebugSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Client initialized successfully",
+			)
+
+			consoleDebugSpy.mockRestore()
+		})
+
 		it("should throw a Zoo Code branded error when client initialization fails", async () => {
-			;(vscode.lm.selectChatModels as Mock).mockRejectedValueOnce(new Error("select failed"))
+			const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(() => {})
+			// Use mockRejectedValue (not Once) because beforeEach already called selectChatModels once
+			;(vscode.lm.selectChatModels as Mock).mockRejectedValue(new Error("select failed"))
 			handler["client"] = null
 
 			await expect(handler.initializeClient()).rejects.toThrow(
-				"Zoo Code <Language Model API>: Failed to initialize client: Zoo Code <Language Model API>: Failed to select model: select failed",
+				"Zoo Code <Language Model API>: Failed to initialize client:",
 			)
+
+			expect(consoleErrorSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Client initialization failed:",
+				expect.stringContaining("select failed"),
+			)
+
+			consoleErrorSpy.mockRestore()
 		})
 	})
 
@@ -642,6 +906,7 @@ describe("VsCodeLmHandler", () => {
 				cancel: vi.fn(),
 				dispose: vi.fn(),
 			}
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
 			handler["currentRequestCancellation"] = mockCancellation as any
 
 			mockLanguageModelChat.countTokens.mockResolvedValueOnce(50)
@@ -682,6 +947,58 @@ describe("VsCodeLmHandler", () => {
 			expect(result).toBe(5)
 			expect(mockLanguageModelChat.countTokens).toHaveBeenCalledWith("[IMAGE]", expect.any(Object))
 		})
+
+		it("should return 0 and log when empty text is provided to internalCountTokens", async () => {
+			handler["currentRequestCancellation"] = null
+			const consoleDebugSpy = vi.spyOn(console, "debug").mockImplementation(() => {})
+
+			// @ts-ignore – access private method for coverage of line 234
+			const result = await handler["internalCountTokens"]("")
+
+			expect(result).toBe(0)
+			expect(consoleDebugSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Empty text provided for token counting",
+			)
+
+			consoleDebugSpy.mockRestore()
+		})
+
+		it("should return 0 and log when non-numeric token count is received", async () => {
+			handler["currentRequestCancellation"] = null
+			const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			mockLanguageModelChat.countTokens.mockResolvedValueOnce("not-a-number" as any)
+
+			const content: Anthropic.Messages.ContentBlockParam[] = [{ type: "text", text: "test" }]
+			const result = await handler.countTokens(content)
+
+			expect(result).toBe(0)
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Non-numeric token count received:",
+				"not-a-number",
+			)
+
+			consoleWarnSpy.mockRestore()
+		})
+
+		it("should return 0 and log when negative token count is received", async () => {
+			handler["currentRequestCancellation"] = null
+			const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {})
+
+			mockLanguageModelChat.countTokens.mockResolvedValueOnce(-5)
+
+			const content: Anthropic.Messages.ContentBlockParam[] = [{ type: "text", text: "test" }]
+			const result = await handler.countTokens(content)
+
+			expect(result).toBe(0)
+			expect(consoleWarnSpy).toHaveBeenCalledWith(
+				"Zoo Code <Language Model API>: Negative token count received:",
+				-5,
+			)
+
+			consoleWarnSpy.mockRestore()
+		})
 	})
 
 	describe("completePrompt", () => {

src/eslint-suppressions.json

@@ -289,11 +289,6 @@
 			"count": 5
 		}
 	},
-	"api/providers/__tests__/vscode-lm.spec.ts": {
-		"@typescript-eslint/no-explicit-any": {
-			"count": 3
-		}
-	},
 	"api/providers/__tests__/xai.spec.ts": {
 		"@typescript-eslint/no-explicit-any": {
 			"count": 1