feat(api): implement FirmwareHandler for firmware.ai integration

- Add FirmwareHandler extending RouterProvider for OpenAI-compatible API
- Add firmware fetcher for models and quota endpoints
- Update modelCache to include firmware provider case
- Export FirmwareHandler from providers index
- Add firmware case in buildApiHandler switch
- Add firmware to dynamicProviderExtras for model management
- Add firmware case in useSelectedModel hook
- Fix test mock to include firmware in RouterModels

Author: xavieroyj

src/api/index.ts

@@ -41,6 +41,7 @@ import {
 	DeepInfraHandler,
 	MiniMaxHandler,
 	BasetenHandler,
+	FirmwareHandler,
 } from "./providers"
 import { NativeOllamaHandler } from "./providers/native-ollama"
 
@@ -197,6 +198,8 @@ export function buildApiHandler(configuration: ProviderSettings): ApiHandler {
 			return new MiniMaxHandler(options)
 		case "baseten":
 			return new BasetenHandler(options)
+		case "firmware":
+			return new FirmwareHandler(options)
 		default:
 			return new AnthropicHandler(options)
 	}

src/api/providers/fetchers/firmware.ts

@@ -0,0 +1,163 @@
+import type { ModelInfo, ModelRecord } from "@roo-code/types"
+
+import { DEFAULT_HEADERS } from "../constants"
+
+const FIRMWARE_BASE_URL = "https://app.firmware.ai/api/v1"
+
+/**
+ * Fetches available models from the Firmware.ai API
+ *
+ * @param apiKey The API key for the Firmware.ai provider
+ * @returns A promise that resolves to a record of model IDs to model info
+ * @throws Will throw an error if the request fails or the response is not as expected.
+ */
+export async function getFirmwareModels(apiKey?: string): Promise<ModelRecord> {
+	const url = `${FIRMWARE_BASE_URL}/models`
+
+	try {
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			...DEFAULT_HEADERS,
+		}
+
+		if (apiKey) {
+			headers["Authorization"] = `Bearer ${apiKey}`
+		}
+
+		const controller = new AbortController()
+		const timeoutId = setTimeout(() => controller.abort(), 10000)
+
+		try {
+			const response = await fetch(url, {
+				headers,
+				signal: controller.signal,
+			})
+
+			if (!response.ok) {
+				let errorBody = ""
+				try {
+					errorBody = await response.text()
+				} catch {
+					errorBody = "(unable to read response body)"
+				}
+
+				console.error(`[getFirmwareModels] HTTP error:`, {
+					status: response.status,
+					statusText: response.statusText,
+					url,
+					body: errorBody,
+				})
+
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+			}
+
+			const data = await response.json()
+			const models: ModelRecord = {}
+
+			// OpenAI-compatible /models endpoint returns { data: [...] }
+			if (!data.data || !Array.isArray(data.data)) {
+				console.error("[getFirmwareModels] Unexpected response format:", data)
+				throw new Error("Failed to fetch Firmware models: Unexpected response format.")
+			}
+
+			for (const model of data.data) {
+				const modelId = model.id
+
+				if (!modelId) continue
+
+				// Extract model capabilities from the API response
+				// Firmware.ai returns OpenAI-compatible model info with additional metadata
+				const modelInfo: ModelInfo = {
+					maxTokens: model.max_tokens ?? model.max_output_tokens ?? 8192,
+					contextWindow: model.context_window ?? model.context_length ?? 128000,
+					supportsImages: model.supports_vision ?? model.capabilities?.vision ?? false,
+					supportsPromptCache: model.supports_prompt_cache ?? false,
+					inputPrice: model.pricing?.input ?? model.input_price ?? 0,
+					outputPrice: model.pricing?.output ?? model.output_price ?? 0,
+					description: model.description ?? model.name ?? modelId,
+				}
+
+				// Add optional fields if available
+				if (model.supports_reasoning || model.capabilities?.reasoning) {
+					modelInfo.supportsReasoningEffort = true
+				}
+
+				if (model.default_temperature !== undefined) {
+					modelInfo.defaultTemperature = model.default_temperature
+				}
+
+				models[modelId] = modelInfo
+			}
+
+			return models
+		} finally {
+			clearTimeout(timeoutId)
+		}
+	} catch (error: any) {
+		console.error("[getFirmwareModels] Error fetching Firmware models:", {
+			message: error.message || String(error),
+			name: error.name,
+			url,
+			hasApiKey: Boolean(apiKey),
+		})
+
+		if (error.name === "AbortError") {
+			throw new Error("Failed to fetch Firmware models: Request timed out after 10 seconds.")
+		}
+
+		if (error.message?.includes("HTTP")) {
+			throw new Error(`Failed to fetch Firmware models: ${error.message}. Check API key.`)
+		}
+
+		if (error instanceof TypeError) {
+			throw new Error("Failed to fetch Firmware models: No response from server. Check network connection.")
+		}
+
+		throw new Error(`Failed to fetch Firmware models: ${error.message || "An unknown error occurred."}`)
+	}
+}
+
+/**
+ * Fetches quota information from the Firmware.ai API
+ *
+ * @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 }> {
+	const url = `${FIRMWARE_BASE_URL}/quota`
+
+	try {
+		const headers: Record<string, string> = {
+			"Content-Type": "application/json",
+			...DEFAULT_HEADERS,
+			Authorization: `Bearer ${apiKey}`,
+		}
+
+		const controller = new AbortController()
+		const timeoutId = setTimeout(() => controller.abort(), 10000)
+
+		try {
+			const response = await fetch(url, {
+				headers,
+				signal: controller.signal,
+			})
+
+			if (!response.ok) {
+				throw new Error(`HTTP ${response.status}: ${response.statusText}`)
+			}
+
+			const data = await response.json()
+
+			return {
+				remaining: data.remaining ?? data.balance ?? 0,
+				windowHours: data.window_hours ?? data.windowHours ?? 5,
+			}
+		} finally {
+			clearTimeout(timeoutId)
+		}
+	} catch (error: any) {
+		console.error("[getFirmwareQuota] Error fetching Firmware quota:", error.message)
+		throw new Error(`Failed to fetch Firmware quota: ${error.message || "An unknown error occurred."}`)
+	}
+}

src/api/providers/fetchers/modelCache.ts

@@ -29,6 +29,7 @@ import { getDeepInfraModels } from "./deepinfra"
 import { getHuggingFaceModels } from "./huggingface"
 import { getRooModels } from "./roo"
 import { getChutesModels } from "./chutes"
+import { getFirmwareModels } from "./firmware"
 
 const memoryCache = new NodeCache({ stdTTL: 5 * 60, checkperiod: 5 * 60 })
 
@@ -108,8 +109,10 @@ async function fetchModelsFromProvider(options: GetModelsOptions): Promise<Model
 		case "chutes":
 			models = await getChutesModels(options.apiKey)
 			break
+		case "firmware":
+			models = await getFirmwareModels(options.apiKey)
+			break
 		default: {
-			// Ensures router is exhaustively checked if RouterName is a strict union.
 			const exhaustiveCheck: never = provider
 			throw new Error(`Unknown provider: ${exhaustiveCheck}`)
 		}

src/api/providers/firmware.ts

@@ -0,0 +1,155 @@
+import { Anthropic } from "@anthropic-ai/sdk"
+import OpenAI from "openai"
+
+import { openAiModelInfoSaneDefaults, type ModelInfo } from "@roo-code/types"
+
+import type { ApiHandlerOptions } from "../../shared/api"
+import { calculateApiCostOpenAI } from "../../shared/cost"
+
+import { ApiStream, ApiStreamUsageChunk } from "../transform/stream"
+import { convertToOpenAiMessages } from "../transform/openai-format"
+import { getModelParams } from "../transform/model-params"
+
+import type { SingleCompletionHandler, ApiHandlerCreateMessageMetadata } from "../index"
+import { RouterProvider } from "./router-provider"
+import { getModels } from "./fetchers/modelCache"
+
+const FIRMWARE_BASE_URL = "https://app.firmware.ai/api/v1"
+const FIRMWARE_DEFAULT_MODEL_ID = "claude-sonnet-4-5"
+
+export class FirmwareHandler extends RouterProvider implements SingleCompletionHandler {
+	constructor(options: ApiHandlerOptions) {
+		super({
+			options,
+			name: "firmware",
+			baseURL: FIRMWARE_BASE_URL,
+			apiKey: options.firmwareApiKey || "not-provided",
+			modelId: options.firmwareModelId,
+			defaultModelId: FIRMWARE_DEFAULT_MODEL_ID,
+			defaultModelInfo: openAiModelInfoSaneDefaults,
+		})
+	}
+
+	public override async fetchModel() {
+		this.models = await getModels({ provider: this.name, apiKey: this.client.apiKey, baseUrl: this.client.baseURL })
+		return this.getModel()
+	}
+
+	override getModel() {
+		const id = this.options.firmwareModelId ?? FIRMWARE_DEFAULT_MODEL_ID
+		const info = this.models[id] ?? openAiModelInfoSaneDefaults
+
+		const params = getModelParams({
+			format: "openai",
+			modelId: id,
+			model: info,
+			settings: this.options,
+		})
+
+		return { id, info, ...params }
+	}
+
+	override async *createMessage(
+		systemPrompt: string,
+		messages: Anthropic.Messages.MessageParam[],
+		metadata?: ApiHandlerCreateMessageMetadata,
+	): ApiStream {
+		await this.fetchModel()
+		const { id: modelId, info, reasoningEffort: reasoning_effort } = this.getModel()
+
+		const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming = {
+			model: modelId,
+			messages: [{ role: "system", content: systemPrompt }, ...convertToOpenAiMessages(messages)],
+			stream: true,
+			stream_options: { include_usage: true },
+			reasoning_effort,
+			tools: this.convertToolsForOpenAI(metadata?.tools),
+			tool_choice: metadata?.tool_choice,
+			parallel_tool_calls: metadata?.parallelToolCalls ?? false,
+		} as OpenAI.Chat.Completions.ChatCompletionCreateParamsStreaming
+
+		if (this.supportsTemperature(modelId)) {
+			requestOptions.temperature = this.options.modelTemperature ?? 0
+		}
+
+		if (this.options.includeMaxTokens === true && info.maxTokens) {
+			;(requestOptions as any).max_completion_tokens = this.options.modelMaxTokens || info.maxTokens
+		}
+
+		const { data: stream } = await this.client.chat.completions.create(requestOptions).withResponse()
+
+		let lastUsage: OpenAI.CompletionUsage | undefined
+		for await (const chunk of stream) {
+			const delta = chunk.choices[0]?.delta
+
+			if (delta?.content) {
+				yield { type: "text", text: delta.content }
+			}
+
+			if (delta && "reasoning_content" in delta && delta.reasoning_content) {
+				yield { type: "reasoning", text: (delta.reasoning_content as string | undefined) || "" }
+			}
+
+			if (delta?.tool_calls) {
+				for (const toolCall of delta.tool_calls) {
+					yield {
+						type: "tool_call_partial",
+						index: toolCall.index,
+						id: toolCall.id,
+						name: toolCall.function?.name,
+						arguments: toolCall.function?.arguments,
+					}
+				}
+			}
+
+			if (chunk.usage) {
+				lastUsage = chunk.usage
+			}
+		}
+
+		if (lastUsage) {
+			yield this.processUsageMetrics(lastUsage, info)
+		}
+	}
+
+	async completePrompt(prompt: string): Promise<string> {
+		await this.fetchModel()
+		const { id: modelId, info } = this.getModel()
+
+		const requestOptions: OpenAI.Chat.Completions.ChatCompletionCreateParamsNonStreaming = {
+			model: modelId,
+			messages: [{ role: "user", content: prompt }],
+		}
+
+		if (this.supportsTemperature(modelId)) {
+			requestOptions.temperature = this.options.modelTemperature ?? 0
+		}
+
+		if (this.options.includeMaxTokens === true && info.maxTokens) {
+			;(requestOptions as any).max_completion_tokens = this.options.modelMaxTokens || info.maxTokens
+		}
+
+		const resp = await this.client.chat.completions.create(requestOptions)
+		return resp.choices[0]?.message?.content || ""
+	}
+
+	protected processUsageMetrics(usage: any, modelInfo?: ModelInfo): ApiStreamUsageChunk {
+		const inputTokens = usage?.prompt_tokens || 0
+		const outputTokens = usage?.completion_tokens || 0
+		const cacheWriteTokens = usage?.prompt_tokens_details?.cache_write_tokens || 0
+		const cacheReadTokens = usage?.prompt_tokens_details?.cached_tokens || 0
+
+		const { totalCost } = modelInfo
+			? calculateApiCostOpenAI(modelInfo, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens)
+			: { totalCost: 0 }
+
+		return {
+			type: "usage",
+			inputTokens,
+			outputTokens,
+			cacheWriteTokens: cacheWriteTokens || undefined,
+			cacheReadTokens: cacheReadTokens || undefined,
+			totalCost,
+		}
+	}
+}

src/api/providers/index.ts

@@ -33,3 +33,4 @@ export { VercelAiGatewayHandler } from "./vercel-ai-gateway"
 export { DeepInfraHandler } from "./deepinfra"
 export { MiniMaxHandler } from "./minimax"
 export { BasetenHandler } from "./baseten"
+export { FirmwareHandler } from "./firmware"

src/shared/api.ts

@@ -181,6 +181,7 @@ const dynamicProviderExtras = {
 	lmstudio: {} as {}, // eslint-disable-line @typescript-eslint/no-empty-object-type
 	roo: {} as { apiKey?: string; baseUrl?: string },
 	chutes: {} as { apiKey?: string },
+	firmware: {} as { apiKey?: string },
 } as const satisfies Record<RouterName, object>
 
 // Build the dynamic options union from the map, intersected with CommonFetchParams

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

@@ -368,6 +368,11 @@ function getSelectedModel({
 			const info = routerModels["vercel-ai-gateway"]?.[id]
 			return { id, info }
 		}
+		case "firmware": {
+			const id = getValidatedModelId(apiConfiguration.firmwareModelId, routerModels.firmware, defaultModelId)
+			const info = routerModels.firmware?.[id]
+			return { id, info }
+		}
 		// case "anthropic":
 		// case "fake-ai":
 		default: {

webview-ui/src/utils/__tests__/validate.spec.ts

@@ -49,6 +49,7 @@ describe("Model Validation Functions", () => {
 		huggingface: {},
 		roo: {},
 		chutes: {},
+		firmware: {},
 	}
 
 	const allowAllOrganization: OrganizationAllowList = {