fix: correct XAI pricing conversion from fractional cents to dollars

- Fixed XAI API price conversion: divide by 10,000 instead of 100
- XAI API returns fractional cents (basis points), not regular cents
- This fixes pricing display showing 0.00 instead of /bin/sh.20
- Fixed parseApiPrice to handle zero values correctly (for free models)
- Added comprehensive test suite for cost utilities
- Updated XAI fetcher tests to reflect correct pricing scale

Author: hannesrudolph

src/api/providers/fetchers/__tests__/xai.spec.ts

@@ -21,9 +21,9 @@ describe("getXaiModels", () => {
 						id: "grok-3",
 						input_modalities: ["text"],
 						output_modalities: ["text"],
-						prompt_text_token_price: 30000,
-						cached_prompt_text_token_price: 7500,
-						completion_text_token_price: 150000,
+						prompt_text_token_price: 2000, // 2000 fractional cents = $0.20 per 1M tokens
+						cached_prompt_text_token_price: 500, // 500 fractional cents = $0.05 per 1M tokens
+						completion_text_token_price: 10000, // 10000 fractional cents = $1.00 per 1M tokens
 						aliases: ["grok-3-latest"],
 					},
 				],
@@ -33,9 +33,9 @@ describe("getXaiModels", () => {
 		const result = await getXaiModels("key", "https://api.x.ai/v1")
 		expect(result["grok-3"]).toBeDefined()
 		expect(result["grok-3"]?.supportsImages).toBe(false)
-		expect(result["grok-3"]?.inputPrice).toBeCloseTo(300) // $300 per 1M (cents->dollars)
-		expect(result["grok-3"]?.outputPrice).toBeCloseTo(1500)
-		expect(result["grok-3"]?.cacheReadsPrice).toBeCloseTo(75)
+		expect(result["grok-3"]?.inputPrice).toBeCloseTo(0.2) // $0.20 per 1M tokens
+		expect(result["grok-3"]?.outputPrice).toBeCloseTo(1.0) // $1.00 per 1M tokens
+		expect(result["grok-3"]?.cacheReadsPrice).toBeCloseTo(0.05) // $0.05 per 1M tokens
 		// aliases are not added to avoid UI duplication
 		expect(result["grok-3-latest"]).toBeUndefined()
 	})

src/api/providers/fetchers/xai.ts

@@ -12,10 +12,10 @@ const xaiLanguageModelSchema = z.object({
 	id: z.string(),
 	input_modalities: z.array(z.string()).optional(),
 	output_modalities: z.array(z.string()).optional(),
-	prompt_text_token_price: z.number().optional(), // cents per 1M tokens
-	cached_prompt_text_token_price: z.number().optional(), // cents per 1M tokens
-	prompt_image_token_price: z.number().optional(), // cents per 1M tokens
-	completion_text_token_price: z.number().optional(), // cents per 1M tokens
+	prompt_text_token_price: z.number().optional(), // fractional cents (basis points) per 1M tokens
+	cached_prompt_text_token_price: z.number().optional(), // fractional cents per 1M tokens
+	prompt_image_token_price: z.number().optional(), // fractional cents per 1M tokens
+	completion_text_token_price: z.number().optional(), // fractional cents per 1M tokens
 	search_price: z.number().optional(),
 	aliases: z.array(z.string()).optional(),
 })
@@ -56,8 +56,9 @@ export async function getXaiModels(apiKey?: string, baseUrl?: string): Promise<R
 			console.error("xAI language models response validation failed", parsed.error?.format?.() ?? parsed.error)
 		}
 
-		// Helper to convert cents-per-1M to dollars-per-1M (assumption per API examples)
-		const centsToDollars = (v?: number) => (typeof v === "number" ? v / 100 : undefined)
+		// Helper to convert fractional-cents-per-1M (basis points) to dollars-per-1M
+		// The API returns values in 1/100th of a cent, so divide by 10,000 to get dollars
+		const centsToDollars = (v?: number) => (typeof v === "number" ? v / 10_000 : undefined)
 
 		for (const m of items) {
 			const id = m.id

src/shared/__tests__/cost.spec.ts

@@ -0,0 +1,114 @@
+import { describe, expect, it } from "vitest"
+import { parseApiPrice, calculateApiCostAnthropic, calculateApiCostOpenAI } from "../cost"
+import type { ModelInfo } from "@roo-code/types"
+
+describe("parseApiPrice", () => {
+	it("should handle zero as a number", () => {
+		expect(parseApiPrice(0)).toBe(0)
+	})
+
+	it("should handle zero as a string", () => {
+		expect(parseApiPrice("0")).toBe(0)
+	})
+
+	it("should handle positive numbers", () => {
+		expect(parseApiPrice(0.0002)).toBe(200)
+		expect(parseApiPrice(0.00002)).toBe(20)
+	})
+
+	it("should handle positive number strings", () => {
+		expect(parseApiPrice("0.0002")).toBe(200)
+		expect(parseApiPrice("0.00002")).toBe(20)
+	})
+
+	it("should return undefined for null", () => {
+		expect(parseApiPrice(null)).toBeUndefined()
+	})
+
+	it("should return undefined for undefined", () => {
+		expect(parseApiPrice(undefined)).toBeUndefined()
+	})
+
+	it("should return undefined for empty string", () => {
+		expect(parseApiPrice("")).toBeUndefined()
+	})
+})
+
+describe("calculateApiCostAnthropic", () => {
+	const modelInfo: ModelInfo = {
+		maxTokens: 4096,
+		contextWindow: 200000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 300,
+		outputPrice: 1500,
+		cacheWritesPrice: 375,
+		cacheReadsPrice: 30,
+	}
+
+	it("should calculate cost without caching", () => {
+		const cost = calculateApiCostAnthropic(modelInfo, 1000, 500)
+		expect(cost).toBeCloseTo(0.3 + 0.75, 10)
+	})
+
+	it("should calculate cost with cache creation", () => {
+		const cost = calculateApiCostAnthropic(modelInfo, 1000, 500, 2000)
+		expect(cost).toBeCloseTo(0.3 + 0.75 + 0.75, 10)
+	})
+
+	it("should calculate cost with cache reads", () => {
+		const cost = calculateApiCostAnthropic(modelInfo, 1000, 500, 0, 3000)
+		expect(cost).toBeCloseTo(0.3 + 0.75 + 0.09, 10)
+	})
+
+	it("should handle zero cost for free models", () => {
+		const freeModel: ModelInfo = {
+			maxTokens: 4096,
+			contextWindow: 200000,
+			supportsImages: false,
+			supportsPromptCache: false,
+			inputPrice: 0,
+			outputPrice: 0,
+		}
+		const cost = calculateApiCostAnthropic(freeModel, 1000, 500)
+		expect(cost).toBe(0)
+	})
+})
+
+describe("calculateApiCostOpenAI", () => {
+	const modelInfo: ModelInfo = {
+		maxTokens: 4096,
+		contextWindow: 128000,
+		supportsImages: true,
+		supportsPromptCache: true,
+		inputPrice: 150,
+		outputPrice: 600,
+		cacheWritesPrice: 187.5,
+		cacheReadsPrice: 15,
+	}
+
+	it("should calculate cost without caching", () => {
+		const cost = calculateApiCostOpenAI(modelInfo, 1000, 500)
+		expect(cost).toBeCloseTo(0.15 + 0.3, 10)
+	})
+
+	it("should subtract cached tokens from input tokens", () => {
+		const cost = calculateApiCostOpenAI(modelInfo, 5000, 500, 2000, 1000)
+		// 5000 total - 2000 cache creation - 1000 cache read = 2000 non-cached
+		// Cost: (2000 * 0.00015) + (2000 * 0.0001875) + (1000 * 0.000015) + (500 * 0.0006)
+		expect(cost).toBeCloseTo(0.3 + 0.375 + 0.015 + 0.3, 10)
+	})
+
+	it("should handle zero cost for free models", () => {
+		const freeModel: ModelInfo = {
+			maxTokens: 4096,
+			contextWindow: 128000,
+			supportsImages: false,
+			supportsPromptCache: false,
+			inputPrice: 0,
+			outputPrice: 0,
+		}
+		const cost = calculateApiCostOpenAI(freeModel, 1000, 500)
+		expect(cost).toBe(0)
+	})
+})

src/shared/cost.ts

@@ -54,4 +54,8 @@ export function calculateApiCostOpenAI(
 	)
 }
 
-export const parseApiPrice = (price: any) => (price ? parseFloat(price) * 1_000_000 : undefined)
+export const parseApiPrice = (price: any) => {
+	if (price == null) return undefined
+	const parsed = parseFloat(price)
+	return isNaN(parsed) ? undefined : parsed * 1_000_000
+}