also show in the autocomplete settings when no provider is available

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

@@ -1,7 +1,7 @@
 // npx vitest run src/__tests__/kilocode.test.ts
 
-import { describe, it, expect } from "vitest"
-import { ghostServiceSettingsSchema } from "../kilocode/kilocode.js"
+import { describe, it, expect, vi, beforeEach, afterEach } from "vitest"
+import { ghostServiceSettingsSchema, checkKilocodeBalance } from "../kilocode/kilocode.js"
 
 describe("ghostServiceSettingsSchema", () => {
 	describe("autoTriggerDelay", () => {
@@ -93,3 +93,115 @@ describe("ghostServiceSettingsSchema", () => {
 		})
 	})
 })
+
+describe("checkKilocodeBalance", () => {
+	const mockToken = "eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9.eyJlbnYiOiJwcm9kdWN0aW9uIn0.test"
+	const mockOrgId = "org-123"
+
+	beforeEach(() => {
+		global.fetch = vi.fn()
+	})
+
+	afterEach(() => {
+		vi.restoreAllMocks()
+	})
+
+	it("should return true when balance is positive", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: true,
+			json: async () => ({ balance: 100 }),
+		} as Response)
+
+		const result = await checkKilocodeBalance(mockToken)
+		expect(result).toBe(true)
+		expect(global.fetch).toHaveBeenCalledWith(
+			"https://api.kilocode.ai/api/profile/balance",
+			expect.objectContaining({
+				headers: expect.objectContaining({
+					Authorization: `Bearer ${mockToken}`,
+				}),
+			}),
+		)
+	})
+
+	it("should return false when balance is zero", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: true,
+			json: async () => ({ balance: 0 }),
+		} as Response)
+
+		const result = await checkKilocodeBalance(mockToken)
+		expect(result).toBe(false)
+	})
+
+	it("should return false when balance is negative", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: true,
+			json: async () => ({ balance: -10 }),
+		} as Response)
+
+		const result = await checkKilocodeBalance(mockToken)
+		expect(result).toBe(false)
+	})
+
+	it("should include organization ID in headers when provided", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: true,
+			json: async () => ({ balance: 100 }),
+		} as Response)
+
+		const result = await checkKilocodeBalance(mockToken, mockOrgId)
+		expect(result).toBe(true)
+		expect(global.fetch).toHaveBeenCalledWith(
+			"https://api.kilocode.ai/api/profile/balance",
+			expect.objectContaining({
+				headers: expect.objectContaining({
+					Authorization: `Bearer ${mockToken}`,
+					"X-KiloCode-OrganizationId": mockOrgId,
+				}),
+			}),
+		)
+	})
+
+	it("should not include organization ID in headers when not provided", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: true,
+			json: async () => ({ balance: 100 }),
+		} as Response)
+
+		await checkKilocodeBalance(mockToken)
+
+		const fetchCall = vi.mocked(global.fetch).mock.calls[0]
+		expect(fetchCall).toBeDefined()
+		const headers = (fetchCall![1] as RequestInit)?.headers as Record<string, string>
+
+		expect(headers).toHaveProperty("Authorization")
+		expect(headers).not.toHaveProperty("X-KiloCode-OrganizationId")
+	})
+
+	it("should return false when API request fails", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: false,
+		} as Response)
+
+		const result = await checkKilocodeBalance(mockToken)
+		expect(result).toBe(false)
+	})
+
+	it("should return false when fetch throws an error", async () => {
+		vi.mocked(global.fetch).mockRejectedValueOnce(new Error("Network error"))
+
+		const result = await checkKilocodeBalance(mockToken)
+		expect(result).toBe(false)
+	})
+
+	it("should handle missing balance field in response", async () => {
+		vi.mocked(global.fetch).mockResolvedValueOnce({
+			ok: true,
+			json: async () => ({}),
+		} as Response)
+
+		const result = await checkKilocodeBalance(mockToken)
+		expect(result).toBe(false)
+	})
+})

packages/types/src/kilocode/kilocode.ts

@@ -1,4 +1,5 @@
 import { z } from "zod"
+import { ProviderSettings, ProviderSettingsEntry } from "../provider-settings.js"
 
 export const ghostServiceSettingsSchema = z
 	.object({
@@ -7,6 +8,8 @@ export const ghostServiceSettingsSchema = z
 		enableQuickInlineTaskKeybinding: z.boolean().optional(),
 		enableSmartInlineTaskKeybinding: z.boolean().optional(),
 		showGutterAnimation: z.boolean().optional(),
+		provider: z.string().optional(),
+		model: z.string().optional(),
 	})
 	.optional()
 
@@ -52,3 +55,84 @@ export function getKiloBaseUriFromToken(kilocodeToken?: string) {
 	}
 	return "https://api.kilocode.ai"
 }
+
+/**
+ * Check if the Kilocode account has a positive balance
+ * @param kilocodeToken - The Kilocode JWT token
+ * @param kilocodeOrganizationId - Optional organization ID to include in headers
+ * @returns Promise<boolean> - True if balance > 0, false otherwise
+ */
+export async function checkKilocodeBalance(kilocodeToken: string, kilocodeOrganizationId?: string): Promise<boolean> {
+	try {
+		const baseUrl = getKiloBaseUriFromToken(kilocodeToken)
+
+		const headers: Record<string, string> = {
+			Authorization: `Bearer ${kilocodeToken}`,
+		}
+
+		if (kilocodeOrganizationId) {
+			headers["X-KiloCode-OrganizationId"] = kilocodeOrganizationId
+		}
+
+		const response = await fetch(`${baseUrl}/api/profile/balance`, {
+			headers,
+		})
+
+		if (!response.ok) {
+			return false
+		}
+
+		const data = await response.json()
+		const balance = data.balance ?? 0
+		return balance > 0
+	} catch (error) {
+		console.error("Error checking kilocode balance:", error)
+		return false
+	}
+}
+
+export const AUTOCOMPLETE_PROVIDER_MODELS = {
+	mistral: "codestral-latest",
+	kilocode: "mistralai/codestral-2508",
+	openrouter: "mistralai/codestral-2508",
+} as const
+export type AutocompleteProviderKey = keyof typeof AUTOCOMPLETE_PROVIDER_MODELS
+
+interface ProviderSettingsManager {
+	listConfig(): Promise<ProviderSettingsEntry[]>
+	getProfile(params: { id: string }): Promise<ProviderSettings>
+}
+
+export type ProviderUsabilityChecker = (
+	provider: AutocompleteProviderKey,
+	providerSettingsManager: ProviderSettingsManager,
+) => Promise<boolean>
+
+export const defaultProviderUsabilityChecker: ProviderUsabilityChecker = async (provider, providerSettingsManager) => {
+	if (provider === "kilocode") {
+		try {
+			const profiles = await providerSettingsManager.listConfig()
+			const kilocodeProfile = profiles.find((p) => p.apiProvider === "kilocode")
+
+			if (!kilocodeProfile) {
+				return false
+			}
+
+			const profile = await providerSettingsManager.getProfile({ id: kilocodeProfile.id })
+			const kilocodeToken = profile.kilocodeToken
+			const kilocodeOrgId = profile.kilocodeOrganizationId
+
+			if (!kilocodeToken) {
+				return false
+			}
+
+			return await checkKilocodeBalance(kilocodeToken, kilocodeOrgId)
+		} catch (error) {
+			console.error("Error checking kilocode balance:", error)
+			return false
+		}
+	}
+
+	// For all other providers, assume they are usable
+	return true
+}

src/core/webview/__tests__/webviewMessageHandler.autoSwitch.spec.ts

@@ -27,6 +27,9 @@ vi.mock("vscode", () => ({
 		uriScheme: "vscode",
 		openExternal: vi.fn(),
 	},
+	commands: {
+		executeCommand: vi.fn(),
+	},
 }))
 
 vi.mock("axios")

src/core/webview/webviewMessageHandler.ts

@@ -2032,6 +2032,7 @@ export const webviewMessageHandler = async (
 					await provider.providerSettingsManager.saveConfig(message.text, message.apiConfiguration)
 					const listApiConfig = await provider.providerSettingsManager.listConfig()
 					await updateGlobalState("listApiConfigMeta", listApiConfig)
+					vscode.commands.executeCommand("kilo-code.ghost.reload") // kilocode_change: Reload ghost model when API provider settings change
 				} catch (error) {
 					provider.log(
 						`Error save api configuration: ${JSON.stringify(error, Object.getOwnPropertyNames(error), 2)}`,

src/i18n/locales/en/kilocode.json

@@ -73,6 +73,7 @@
 				"tokenError": "A valid token must be set to use Autocomplete",
 				"lastCompletion": "Last suggestion:",
 				"sessionTotal": "Session total cost:",
+				"provider": "Provider:",
 				"model": "Model:"
 			},
 			"cost": {