feat: show billing costs in usage stats

Author: james-6-23

database/billing.go

@@ -17,11 +17,30 @@ type modelPricingRule struct {
 	pricing ModelPricing
 }
 
+type costBreakdown struct {
+	InputCost                 float64
+	OutputCost                float64
+	CacheReadCost             float64
+	TotalCost                 float64
+	InputPricePerMToken       float64
+	OutputPricePerMToken      float64
+	CacheReadPricePerMToken   float64
+	ServiceTierCostMultiplier float64
+}
+
 var (
 	defaultModelPricing = &ModelPricing{InputPricePerMToken: 1.0, OutputPricePerMToken: 2.0}
 
 	modelPricingRules = []modelPricingRule{
 		// Codex/GPT-5 系列，参考 sub2api 的本地 fallback 定价。
+		{model: "gpt-5.5", pricing: ModelPricing{
+			InputPricePerMToken:             5.0,
+			InputPricePerMTokenPriority:     10.0,
+			OutputPricePerMToken:            30.0,
+			OutputPricePerMTokenPriority:    60.0,
+			CacheReadPricePerMToken:         0.5,
+			CacheReadPricePerMTokenPriority: 1.0,
+		}},
 		{model: "gpt-5.4-mini", pricing: ModelPricing{InputPricePerMToken: 0.75, OutputPricePerMToken: 4.5, CacheReadPricePerMToken: 0.075}},
 		{model: "gpt-5.4-nano", pricing: ModelPricing{InputPricePerMToken: 0.2, OutputPricePerMToken: 1.25, CacheReadPricePerMToken: 0.02}},
 		{model: "gpt-5.4", pricing: ModelPricing{
@@ -91,6 +110,10 @@ func getModelPricing(model string) *ModelPricing {
 // model: 模型名称
 // 返回：账号计费金额（美元）
 func calculateCost(inputTokens, outputTokens, cachedTokens int, model string, serviceTier string) float64 {
+	return calculateCostBreakdown(inputTokens, outputTokens, cachedTokens, model, serviceTier).TotalCost
+}
+
+func calculateCostBreakdown(inputTokens, outputTokens, cachedTokens int, model string, serviceTier string) costBreakdown {
 	pricing := getModelPricing(model)
 	inputPrice := pricing.InputPricePerMToken
 	outputPrice := pricing.OutputPricePerMToken
@@ -126,7 +149,16 @@ func calculateCost(inputTokens, outputTokens, cachedTokens int, model string, se
 	cacheReadCost := float64(cachedTokens) / 1000000.0 * cacheReadPrice
 	outputCost := float64(outputTokens) / 1000000.0 * outputPrice
 
-	return (inputCost + cacheReadCost + outputCost) * tierMultiplier
+	return costBreakdown{
+		InputCost:                 inputCost * tierMultiplier,
+		OutputCost:                outputCost * tierMultiplier,
+		CacheReadCost:             cacheReadCost * tierMultiplier,
+		TotalCost:                 (inputCost + cacheReadCost + outputCost) * tierMultiplier,
+		InputPricePerMToken:       inputPrice * tierMultiplier,
+		OutputPricePerMToken:      outputPrice * tierMultiplier,
+		CacheReadPricePerMToken:   cacheReadPrice * tierMultiplier,
+		ServiceTierCostMultiplier: tierMultiplier,
+	}
 }
 
 func normalizeBillingModelName(model string) string {
@@ -148,6 +180,8 @@ func normalizeBillingModelName(model string) string {
 func normalizeCodexBillingModel(model string) (string, bool) {
 	compact := strings.NewReplacer(" ", "-", "_", "-").Replace(model)
 	switch {
+	case strings.Contains(compact, "gpt-5.5") || strings.Contains(compact, "gpt5-5") || strings.Contains(compact, "gpt5.5"):
+		return "gpt-5.5", true
 	case strings.Contains(compact, "gpt-5.4-mini") || strings.Contains(compact, "gpt5-4-mini") || strings.Contains(compact, "gpt5.4-mini"):
 		return "gpt-5.4-mini", true
 	case strings.Contains(compact, "gpt-5.4-nano") || strings.Contains(compact, "gpt5-4-nano") || strings.Contains(compact, "gpt5.4-nano"):

database/billing_test.go

@@ -32,7 +32,7 @@ func TestGetModelPricingUsesSub2APICodexFallbacks(t *testing.T) {
 	}{
 		{model: "gpt-5.4-mini-20260401", wantInput: 0.75, wantOutput: 4.5},
 		{model: "gpt-5.3-codex-spark", wantInput: 1.5, wantOutput: 12.0},
-		{model: "gpt-5.5", wantInput: 2.5, wantOutput: 15.0},
+		{model: "gpt-5.5", wantInput: 5.0, wantOutput: 30.0},
 	}
 
 	for _, tt := range tests {
@@ -120,6 +120,47 @@ func TestCalculateCostHandlesCachedTokensAndServiceTier(t *testing.T) {
 	}
 }
 
+func TestCalculateCostBreakdownExposesDisplayFields(t *testing.T) {
+	got := calculateCostBreakdown(1000, 500, 200, "gpt-5.4", "flex")
+
+	assertFloatEqual(t, got.InputCost, 0.001)
+	assertFloatEqual(t, got.CacheReadCost, 0.000025)
+	assertFloatEqual(t, got.OutputCost, 0.00375)
+	assertFloatEqual(t, got.TotalCost, 0.004775)
+	assertFloatEqual(t, got.InputPricePerMToken, 1.25)
+	assertFloatEqual(t, got.CacheReadPricePerMToken, 0.125)
+	assertFloatEqual(t, got.OutputPricePerMToken, 7.5)
+	assertFloatEqual(t, got.ServiceTierCostMultiplier, 0.5)
+}
+
+func TestGPT55PricingIsDoubleGPT54(t *testing.T) {
+	gpt54 := getModelPricing("gpt-5.4")
+	gpt55 := getModelPricing("gpt-5.5")
+
+	assertFloatEqual(t, gpt55.InputPricePerMToken, gpt54.InputPricePerMToken*2)
+	assertFloatEqual(t, gpt55.OutputPricePerMToken, gpt54.OutputPricePerMToken*2)
+	assertFloatEqual(t, gpt55.CacheReadPricePerMToken, gpt54.CacheReadPricePerMToken*2)
+	assertFloatEqual(t, gpt55.InputPricePerMTokenPriority, gpt54.InputPricePerMTokenPriority*2)
+	assertFloatEqual(t, gpt55.OutputPricePerMTokenPriority, gpt54.OutputPricePerMTokenPriority*2)
+	assertFloatEqual(t, gpt55.CacheReadPricePerMTokenPriority, gpt54.CacheReadPricePerMTokenPriority*2)
+}
+
+func TestUsageLogBreakdownScalesToStoredBilledTotal(t *testing.T) {
+	log := &UsageLog{
+		Model:         "gpt-5.5",
+		InputTokens:   1000,
+		StatusCode:    200,
+		AccountBilled: 0.0025,
+		UserBilled:    0.0025,
+	}
+
+	log.populateBillingBreakdown()
+
+	assertFloatEqual(t, log.TotalCost, 0.0025)
+	assertFloatEqual(t, log.InputCost, 0.0025)
+	assertFloatEqual(t, log.InputPrice, 2.5)
+}
+
 func assertPricing(t *testing.T, got *ModelPricing, wantInput, wantOutput float64) {
 	t.Helper()
 	if got == nil {
@@ -130,3 +171,10 @@ func assertPricing(t *testing.T, got *ModelPricing, wantInput, wantOutput float6
 			got.InputPricePerMToken, got.OutputPricePerMToken, wantInput, wantOutput)
 	}
 }
+
+func assertFloatEqual(t *testing.T, got, want float64) {
+	t.Helper()
+	if math.Abs(got-want) > 1e-12 {
+		t.Fatalf("got %.12f, want %.12f", got, want)
+	}
+}