fix(dashboard): resolve custom model pricing for openai-compatible providers and day rollup

Author: Zoo (VP)

src/api/transform/__tests__/gemini-format.spec.ts

@@ -99,7 +99,7 @@ describe("convertAnthropicMessageToGemini", () => {
 					source: {
 						type: "url", // Not supported
 						url: "https://example.com/image.jpg",
-					} as any,
+					} as unknown as Anthropic.Messages.ImageBlockParam["source"],
 				},
 			],
 		}
@@ -149,7 +149,10 @@ describe("convertAnthropicMessageToGemini", () => {
 		const anthropicMessage: Anthropic.Messages.MessageParam = {
 			role: "assistant",
 			content: [
-				{ type: "thoughtSignature", thoughtSignature: "sig-123" } as any,
+				{
+					type: "thoughtSignature",
+					thoughtSignature: "sig-123",
+				} as unknown as Anthropic.Messages.ContentBlockParam,
 				{ type: "tool_use", id: "call-1", name: "toolA", input: { a: 1 } },
 				{ type: "tool_use", id: "call-2", name: "toolB", input: { b: 2 } },
 			],
@@ -158,7 +161,7 @@ describe("convertAnthropicMessageToGemini", () => {
 		const result = convertAnthropicMessageToGemini(anthropicMessage)
 		expect(result).toHaveLength(1)
 
-		const parts = result[0]!.parts as any[]
+		const parts = result[0]!.parts as Array<{ functionCall?: unknown; thoughtSignature?: string }>
 		const functionCallParts = parts.filter((p) => p.functionCall)
 		expect(functionCallParts).toHaveLength(2)
 
@@ -240,7 +243,7 @@ describe("convertAnthropicMessageToGemini", () => {
 				{
 					type: "tool_result",
 					tool_use_id: "calculator-123",
-					content: null as any,
+					content: null as unknown as string,
 				},
 			],
 		}
@@ -616,7 +619,7 @@ describe("convertAnthropicMessageToGemini", () => {
 				{
 					type: "unknown_type", // Unsupported type
 					data: "some data",
-				} as any,
+				} as unknown as Anthropic.Messages.ContentBlockParam,
 				{ type: "text", text: "Valid content" },
 			],
 		}
@@ -636,9 +639,9 @@ describe("convertAnthropicMessageToGemini", () => {
 			role: "assistant",
 			content: [
 				{
-					type: "reasoning" as any,
+					type: "reasoning",
 					text: "Let me think about this...",
-				},
+				} as unknown as Anthropic.Messages.ContentBlockParam,
 				{ type: "text", text: "Here's my answer" },
 			],
 		}

src/services/stats/DashboardTaskProjection.ts

@@ -12,7 +12,9 @@ import {
 	getEffectiveCost,
 	computeCacheDiscountBase,
 	computeCacheDiscountBaseFromAggregated,
+	computeCostFromAggregated,
 	applyCacheDiscount,
+	customPricingKey,
 } from "./costRecalculation"
 import type { CustomModelPricingMap } from "./costRecalculation"
 import { type StatsQueryRangeMs } from "./statsQueryRange"
@@ -53,7 +55,15 @@ export interface DashboardTaskUsageReader {
 		taskIds: string[],
 		rangeMs?: StatsQueryRangeMs,
 		includeCancelled?: boolean,
-	): Array<{ taskId: string; provider: string; model: string; inputTokens: number }>
+	): Array<{
+		taskId: string
+		provider: string
+		model: string
+		inputTokens: number
+		outputTokens?: number
+		cacheWriteTokens?: number
+		cacheReadTokens?: number
+	}>
 }
 
 /**
@@ -224,7 +234,15 @@ function computeTaskSummary(
 	identityByTaskId: ReadonlyMap<string, TaskIdentityAggregate>,
 	cacheRatio?: number,
 	customPricing?: CustomModelPricingMap,
-	inputTokensByTaskId: Array<{ taskId: string; provider: string; model: string; inputTokens: number }> = [],
+	inputTokensByTaskId: Array<{
+		taskId: string
+		provider: string
+		model: string
+		inputTokens: number
+		outputTokens?: number
+		cacheWriteTokens?: number
+		cacheReadTokens?: number
+	}> = [],
 ): DashboardTaskSummary {
 	const task = catalog.byId.get(taskId)!
 	const subtreeUsage = summarizeSubtreeUsage(
@@ -262,7 +280,15 @@ function summarizeSubtreeUsage(
 	identityByTaskId: ReadonlyMap<string, TaskIdentityAggregate>,
 	cacheRatio?: number,
 	customPricing?: CustomModelPricingMap,
-	inputTokensByTaskId: Array<{ taskId: string; provider: string; model: string; inputTokens: number }> = [],
+	inputTokensByTaskId: Array<{
+		taskId: string
+		provider: string
+		model: string
+		inputTokens: number
+		outputTokens?: number
+		cacheWriteTokens?: number
+		cacheReadTokens?: number
+	}> = [],
 ): SubtreeUsageSummary {
 	let totalCost = 0
 	let totalCacheDiscountBase = 0
@@ -274,13 +300,30 @@ function summarizeSubtreeUsage(
 	const subtreeModels: string[] = []
 	const subtreeModes: string[] = []
 
-	// Build a lookup map for per-(task, provider, model) input tokens
-	// so we can recompute cacheDiscountBase at query time when customPricing
+	// Build a lookup map for per-(task, provider, model) token counts
+	// so we can recompute cost and cacheDiscountBase at query time when customPricing
 	// is available (the stored value was 0 for custom models).
-	const inputTokensLookup = new Map<string, Array<{ provider: string; model: string; inputTokens: number }>>()
+	const inputTokensLookup = new Map<
+		string,
+		Array<{
+			provider: string
+			model: string
+			inputTokens: number
+			outputTokens: number
+			cacheWriteTokens: number
+			cacheReadTokens: number
+		}>
+	>()
 	for (const row of inputTokensByTaskId) {
 		const existing = inputTokensLookup.get(row.taskId) ?? []
-		existing.push({ provider: row.provider, model: row.model, inputTokens: row.inputTokens })
+		existing.push({
+			provider: row.provider,
+			model: row.model,
+			inputTokens: row.inputTokens,
+			outputTokens: row.outputTokens ?? 0,
+			cacheWriteTokens: row.cacheWriteTokens ?? 0,
+			cacheReadTokens: row.cacheReadTokens ?? 0,
+		})
 		inputTokensLookup.set(row.taskId, existing)
 	}
 
@@ -301,7 +344,39 @@ function summarizeSubtreeUsage(
 			continue
 		}
 
-		totalCost += usage.totalCost
+		// When customPricing is present and usage has events, recompute cost
+		// if stored usage.totalCost === 0 or if customPricing contains pricing for any model in the task.
+		if (customPricing && customPricing.size > 0 && usage.eventCount > 0) {
+			const perModelRows = inputTokensLookup.get(taskId)
+			if (perModelRows && perModelRows.length > 0) {
+				let taskRecomputedCost = 0
+				let hasRecomputedCost = false
+				for (const row of perModelRows) {
+					const hasCustom = customPricing.has(customPricingKey(row.provider, row.model))
+					if (hasCustom || usage.totalCost === 0) {
+						taskRecomputedCost += computeCostFromAggregated(
+							row.provider,
+							row.model,
+							row.inputTokens,
+							row.outputTokens,
+							row.cacheWriteTokens,
+							row.cacheReadTokens,
+							customPricing,
+						)
+						hasRecomputedCost = true
+					}
+				}
+				if (hasRecomputedCost) {
+					totalCost += taskRecomputedCost
+				} else {
+					totalCost += usage.totalCost
+				}
+			} else {
+				totalCost += usage.totalCost
+			}
+		} else {
+			totalCost += usage.totalCost
+		}
 
 		// When customPricing is available and the stored cacheDiscountBase
 		// is 0, recompute it from per-(provider, model) input token sums.

src/services/stats/UsageStatsDatabase.ts

@@ -3267,36 +3267,115 @@ export class UsageStatsDatabase {
 	}
 
 	/**
-	 * Queries per-(task_id, provider, model) input token sums from
+	 * Queries per-(hour/day, provider, model) token sums from usage_events.
+	 * Used for day-axis recomputation with custom pricing.
+	 *
+	 * @param fromEpochMs Start epoch ms (inclusive). 0 for no lower bound.
+	 * @param toEpochMs End epoch ms (exclusive). MAX_SAFE_INTEGER for no upper bound.
+	 * @param includeCancelled If true, includes cancelled events.
+	 * @returns Array of { occurredAt, provider, model, endpoint, mode, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens } rows.
+	 */
+	queryDailyTokensByProviderModel(
+		fromEpochMs: number,
+		toEpochMs: number,
+		includeCancelled: boolean = false,
+	): Array<{
+		occurredAt: string
+		provider: string
+		model: string
+		endpoint: string | null
+		mode: string
+		inputTokens: number
+		outputTokens: number
+		cacheWriteTokens: number
+		cacheReadTokens: number
+	}> {
+		const db = this.getDb()
+
+		try {
+			let query = `SELECT occurred_at, provider, model, endpoint, mode,
+						SUM(COALESCE(json_extract(usage_json, '$.inputTokens.value'), 0)) as input_tokens,
+						SUM(COALESCE(json_extract(usage_json, '$.outputTokens.value'), 0)) as output_tokens,
+						SUM(COALESCE(json_extract(usage_json, '$.cacheWriteTokens.value'), 0)) as cache_write_tokens,
+						SUM(COALESCE(json_extract(usage_json, '$.cacheReadTokens.value'), 0)) as cache_read_tokens
+						FROM usage_events
+						WHERE occurred_epoch_ms >= ? AND occurred_epoch_ms < ?`
+			const params: Array<number | string> = [fromEpochMs, toEpochMs]
+
+			if (!includeCancelled) {
+				query += ` AND status != 'cancelled'`
+			}
+
+			query += ` GROUP BY SUBSTR(occurred_at, 1, 13), provider, model, endpoint, mode`
+
+			const rows = db.prepare(query).all(...params) as Array<Record<string, unknown>>
+
+			return rows.map((row) => ({
+				occurredAt: (row.occurred_at as string) ?? "",
+				provider: (row.provider as string) ?? "",
+				model: (row.model as string) ?? "",
+				endpoint: (row.endpoint as string | null) ?? null,
+				mode: (row.mode as string) ?? "",
+				inputTokens: (row.input_tokens as number) ?? 0,
+				outputTokens: (row.output_tokens as number) ?? 0,
+				cacheWriteTokens: (row.cache_write_tokens as number) ?? 0,
+				cacheReadTokens: (row.cache_read_tokens as number) ?? 0,
+			}))
+		} catch (err) {
+			throw new StatsDbError("STATS_DB/read/001", "Failed to query daily tokens by provider+model", err)
+		}
+	}
+
+	/**
+	 * Queries per-(task_id, provider, model) token sums from
 	 * usage_events for a given set of task IDs. Used by the task projection
-	 * to recompute `cache_discount_base` at query time when `customPricing`
-	 * is available, overriding the stale stored value (which was 0 for custom
-	 * models because pricing wasn't available at write time).
+	 * to recompute `totalCost` and `cache_discount_base` at query time when
+	 * `customPricing` is available, overriding the stale stored values (which
+	 * were 0 for custom models because pricing wasn't available at write time).
 	 *
 	 * @param taskIds The task IDs to query.
 	 * @param rangeMs Optional time range filter.
 	 * @param includeCancelled If true, includes cancelled events.
-	 * @returns Array of { taskId, provider, model, inputTokens } rows.
+	 * @returns Array of { taskId, provider, model, inputTokens, outputTokens, cacheWriteTokens, cacheReadTokens } rows.
 	 */
 	queryInputTokensByTaskId(
 		taskIds: string[],
 		rangeMs?: StatsQueryRangeMs,
 		includeCancelled: boolean = false,
-	): Array<{ taskId: string; provider: string; model: string; inputTokens: number }> {
+	): Array<{
+		taskId: string
+		provider: string
+		model: string
+		inputTokens: number
+		outputTokens: number
+		cacheWriteTokens: number
+		cacheReadTokens: number
+	}> {
 		const db = this.getDb()
 		const uniqueTaskIds = [...new Set(taskIds)]
 
 		if (uniqueTaskIds.length === 0) return []
 
 		try {
-			const result: Array<{ taskId: string; provider: string; model: string; inputTokens: number }> = []
+			const result: Array<{
+				taskId: string
+				provider: string
+				model: string
+				inputTokens: number
+				outputTokens: number
+				cacheWriteTokens: number
+				cacheReadTokens: number
+			}> = []
 
 			for (let start = 0; start < uniqueTaskIds.length; start += TASK_ID_QUERY_CHUNK_SIZE) {
 				const chunk = uniqueTaskIds.slice(start, start + TASK_ID_QUERY_CHUNK_SIZE)
 				const placeholders = chunk.map(() => "?").join(", ")
 
 				let query = `SELECT task_id, provider, model,
-							SUM(COALESCE(json_extract(usage_json, '$.inputTokens.value'), 0)) as input_tokens
+							SUM(COALESCE(json_extract(usage_json, '$.inputTokens.value'), 0)) as input_tokens,
+							SUM(COALESCE(json_extract(usage_json, '$.outputTokens.value'), 0)) as output_tokens,
+							SUM(COALESCE(json_extract(usage_json, '$.cacheWriteTokens.value'), 0)) as cache_write_tokens,
+							SUM(COALESCE(json_extract(usage_json, '$.cacheReadTokens.value'), 0)) as cache_read_tokens
 							FROM usage_events
 							WHERE task_id IN (${placeholders})`
 				const params: Array<string | number> = [...chunk]
@@ -3324,6 +3403,9 @@ export class UsageStatsDatabase {
 						provider: (row.provider as string) ?? "",
 						model: (row.model as string) ?? "",
 						inputTokens: (row.input_tokens as number) ?? 0,
+						outputTokens: (row.output_tokens as number) ?? 0,
+						cacheWriteTokens: (row.cache_write_tokens as number) ?? 0,
+						cacheReadTokens: (row.cache_read_tokens as number) ?? 0,
 					})
 				}
 			}