fix(firmware): update quota response format to match API (used/reset)

The Firmware.ai /api/v1/quota endpoint returns:
- used: Amount used in current window (0 to 1 scale, 1 = limit reached)
- reset: ISO timestamp when quota resets

Updated:
- getFirmwareQuota fetcher to return {used, reset}
- Message handler to send used/reset fields
- useFirmwareQuota hook interface
- FirmwareQuotaDisplay to show percentage and time until reset
- Tests for new response format

Display now shows:
- Normal: '52% used · resets in 2h 30m'
- Warning (>80%): yellow styling
- At limit (100%): 'Limit reached · resets in Xm' with red styling

Author: xavieroyj

src/api/providers/__tests__/firmware.spec.ts

@@ -483,8 +483,8 @@ describe("Firmware fetchers", () => {
 			mockFetch.mockResolvedValueOnce({
 				ok: true,
 				json: async () => ({
-					remaining: 42.5,
-					window_hours: 5,
+					used: 0.5217,
+					reset: "2026-01-25T11:02:14.242Z",
 				}),
 			})
 
@@ -499,23 +499,20 @@ describe("Firmware fetchers", () => {
 				}),
 			)
 
-			expect(quota.remaining).toBe(42.5)
-			expect(quota.windowHours).toBe(5)
+			expect(quota.used).toBe(0.5217)
+			expect(quota.reset).toBe("2026-01-25T11:02:14.242Z")
 		})
 
-		it("should handle alternative response fields", async () => {
+		it("should handle missing fields with defaults", async () => {
 			mockFetch.mockResolvedValueOnce({
 				ok: true,
-				json: async () => ({
-					balance: 100,
-					windowHours: 3,
-				}),
+				json: async () => ({}),
 			})
 
 			const quota = await getFirmwareQuota("test-key")
 
-			expect(quota.remaining).toBe(100)
-			expect(quota.windowHours).toBe(3)
+			expect(quota.used).toBe(0)
+			expect(quota.reset).toBeDefined()
 		})
 
 		it("should throw error on HTTP failure", async () => {

src/api/providers/fetchers/firmware.ts

@@ -117,14 +117,23 @@ export async function getFirmwareModels(apiKey?: string): Promise<ModelRecord> {
 	}
 }
 
+export interface FirmwareQuotaResponse {
+	used: number // 0 to 1 scale (1 = limit reached)
+	reset: string // ISO timestamp when quota resets
+}
+
 /**
  * Fetches quota information from the Firmware.ai API
  *
+ * Response format: { "used": 0.5217, "reset": "2026-01-25T11:02:14.242Z" }
+ * - used: Amount used in the current window (0 to 1, where 1 = limit reached)
+ * - reset: ISO timestamp when the quota resets
+ *
  * @param apiKey The API key for the Firmware.ai provider
  * @returns A promise that resolves to quota information
  * @throws Will throw an error if the request fails
  */
-export async function getFirmwareQuota(apiKey: string): Promise<{ remaining: number; windowHours: number }> {
+export async function getFirmwareQuota(apiKey: string): Promise<FirmwareQuotaResponse> {
 	const url = `${FIRMWARE_BASE_URL}/quota`
 
 	try {
@@ -150,8 +159,8 @@ export async function getFirmwareQuota(apiKey: string): Promise<{ remaining: num
 			const data = await response.json()
 
 			return {
-				remaining: data.remaining ?? data.balance ?? 0,
-				windowHours: data.window_hours ?? data.windowHours ?? 5,
+				used: data.used ?? 0,
+				reset: data.reset ?? new Date().toISOString(),
 			}
 		} finally {
 			clearTimeout(timeoutId)

src/core/webview/webviewMessageHandler.ts

@@ -1125,7 +1125,7 @@ export const webviewMessageHandler = async (
 				provider.postMessageToWebview({
 					type: "firmwareQuota",
 					requestId,
-					values: { remaining: quota.remaining, windowHours: quota.windowHours },
+					values: { used: quota.used, reset: quota.reset },
 				})
 			} catch (error) {
 				const errorMessage = error instanceof Error ? error.message : String(error)

webview-ui/src/components/settings/providers/FirmwareQuotaDisplay.tsx

@@ -2,19 +2,44 @@ import { VSCodeLink } from "@vscode/webview-ui-toolkit/react"
 
 import { useFirmwareQuota } from "@/components/ui/hooks/useFirmwareQuota"
 
+const formatTimeUntilReset = (ms: number): string => {
+	if (ms <= 0) return "resetting..."
+	const hours = Math.floor(ms / (1000 * 60 * 60))
+	const minutes = Math.floor((ms % (1000 * 60 * 60)) / (1000 * 60))
+	if (hours > 0) return `${hours}h ${minutes}m`
+	return `${minutes}m`
+}
+
 export const FirmwareQuotaDisplay = () => {
 	const { data: quota } = useFirmwareQuota()
 
-	if (quota === null || quota === undefined) {
+	if (!quota) {
 		return null
 	}
 
-	const formattedRemaining = quota.remaining.toFixed(2)
-	const billingUrl = "https://app.firmware.ai/billing"
+	const percentUsed = Math.round(quota.used * 100)
+	const resetDate = new Date(quota.reset)
+	const now = new Date()
+	const msUntilReset = resetDate.getTime() - now.getTime()
+
+	const isAtLimit = quota.used >= 1
+	const isWarning = quota.used >= 0.8
+
+	const statusText = isAtLimit
+		? `Limit reached · resets in ${formatTimeUntilReset(msUntilReset)}`
+		: `${percentUsed}% used · resets in ${formatTimeUntilReset(msUntilReset)}`
+
+	const colorClass = isAtLimit
+		? "text-vscode-errorForeground"
+		: isWarning
+			? "text-vscode-editorWarning-foreground"
+			: "text-vscode-foreground"
 
 	return (
-		<VSCodeLink href={billingUrl} className="text-vscode-foreground hover:underline whitespace-nowrap">
-			${formattedRemaining} remaining
+		<VSCodeLink
+			href="https://app.firmware.ai/billing"
+			className={`${colorClass} hover:underline whitespace-nowrap`}>
+			{statusText}
 		</VSCodeLink>
 	)
 }

webview-ui/src/components/ui/hooks/useFirmwareQuota.ts

@@ -5,8 +5,8 @@ import type { ExtensionMessage } from "@roo-code/types"
 import { vscode } from "@src/utils/vscode"
 
 export interface FirmwareQuotaInfo {
-	remaining: number
-	windowHours: number
+	used: number // 0 to 1 scale (1 = limit reached)
+	reset: string // ISO timestamp when quota resets
 }
 
 export const useFirmwareQuota = () => {
@@ -25,10 +25,10 @@ export const useFirmwareQuota = () => {
 				window.removeEventListener("message", handleMessage)
 				clearTimeout(timeout)
 
-				if (message.values?.remaining !== undefined) {
+				if (message.values?.used !== undefined) {
 					setQuota({
-						remaining: message.values.remaining,
-						windowHours: message.values.windowHours ?? 5,
+						used: message.values.used,
+						reset: message.values.reset,
 					})
 					setError(null)
 				} else if (message.values?.error) {