fix(pricing): preserve route billing edge cases

Classify StepFun PAYG and Step Plan routes before presenting usage, retain unknown billing for child routes without endpoint provenance, and allow the documented GPT-5.5 cache-write fallback without filling unrelated catalog gaps.

Signed-off-by: Nightt <87569709+nightt5879@users.noreply.github.com>

Author: nightt5879

crates/tui/src/pricing.rs

@@ -203,6 +203,17 @@ pub fn has_pricing_for_provider(provider: ApiProvider, model: &str) -> bool {
     calculate_turn_cost_estimate_for_provider(provider, model, &Usage::default()).is_some()
 }
 
+/// Return whether a provider/model route has authoritative pricing for an
+/// already-classified billing surface.
+#[must_use]
+pub(crate) fn has_pricing_for_billing_surface(
+    provider: ApiProvider,
+    model: &str,
+    billing_surface: Option<&str>,
+) -> bool {
+    pricing_for_billing_surface(provider, model, billing_surface).is_some()
+}
+
 fn pricing_for_model_at(model: &str, now: DateTime<Utc>) -> Option<ModelPricing> {
     let lower = model.to_lowercase();
     if lower.starts_with("deepseek-ai/") {
@@ -561,7 +572,16 @@ pub(crate) fn calculate_turn_cost_estimate_for_provider_at(
         crate::provider_lake::catalog_offering_for_model(provider, &catalog_model)
         && OfferingPricing::from_catalog_offering(&offering).is_some()
     {
-        return catalog_cost_estimate_for_route(provider, &catalog_model, &offering, usage);
+        if let Some(estimate) =
+            catalog_cost_estimate_for_route(provider, &catalog_model, &offering, usage)
+        {
+            return Some(estimate);
+        }
+        if catalog_gap_uses_documented_hand_price(provider, &catalog_model, &offering, usage) {
+            let pricing = provider_owned_hand_pricing_at(provider, &catalog_model, recorded_at)?;
+            return Some(cost_estimate_with_pricing(pricing, usage));
+        }
+        return None;
     }
 
     // A few first-party rows predate or intentionally omit a Models.dev entry
@@ -644,6 +664,30 @@ fn provider_owned_hand_pricing_at(
         .flatten()
 }
 
+/// Whether a failed catalog estimate is missing only a class whose billing is
+/// explicitly documented by the provider-owned row. Keep this narrow: a hand
+/// row must not fill unrelated catalog gaps (for example an unpublished cache
+/// read rate) merely because the model name is known locally.
+fn catalog_gap_uses_documented_hand_price(
+    provider: ApiProvider,
+    model: &str,
+    offering: &codewhale_config::catalog::CatalogOffering,
+    usage: &Usage,
+) -> bool {
+    if provider != ApiProvider::Openai || !model.eq_ignore_ascii_case("gpt-5.5") {
+        return false;
+    }
+    let Some(pricing) = OfferingPricing::from_catalog_offering(offering) else {
+        return false;
+    };
+    let usage = token_usage_for_pricing(usage);
+    usage.cache_write > 0
+        && pricing.cache_write_per_million.is_none()
+        && (usage.input == 0 || pricing.input_per_million.is_some())
+        && (usage.output == 0 || pricing.output_per_million.is_some())
+        && (usage.cache_read == 0 || pricing.cache_read_per_million.is_some())
+}
+
 /// Estimate usage only from the exact provider offering. Missing prices for a
 /// used token class fail closed, except on the two documented first-party
 /// routes where cache tokens are explicitly billed at the input rate.
@@ -1267,6 +1311,34 @@ mod tests {
         assert!(has_pricing_for_provider(ApiProvider::Openai, "gpt-5-codex"));
     }
 
+    #[test]
+    fn provider_hand_price_fills_catalog_missing_used_class() {
+        let offering =
+            crate::provider_lake::catalog_offering_for_model(ApiProvider::Openai, "gpt-5.5")
+                .expect("bundled OpenAI route");
+        let catalog_pricing =
+            OfferingPricing::from_catalog_offering(&offering).expect("catalog pricing");
+        assert!(catalog_pricing.cache_write_per_million.is_none());
+        let usage = Usage {
+            input_tokens: 1_000_000,
+            output_tokens: 0,
+            prompt_cache_miss_tokens: Some(0),
+            prompt_cache_write_tokens: Some(1_000_000),
+            ..Default::default()
+        };
+
+        let estimate = calculate_turn_cost_estimate_for_provider_at(
+            ApiProvider::Openai,
+            "gpt-5.5",
+            &usage,
+            Utc::now(),
+        )
+        .expect("provider hand price supplies the missing cache-write class");
+
+        assert!((estimate.usd - 5.0).abs() < f64::EPSILON);
+        assert_eq!(estimate.cny, 0.0);
+    }
+
     #[test]
     fn provider_cost_does_not_fabricate_price_for_costless_catalog_route() {
         let offering = crate::provider_lake::catalog_offering_for_model(

crates/tui/src/route_billing.rs

@@ -79,6 +79,7 @@ pub fn for_route(config: &Config, provider: ApiProvider) -> BillingPresentation
 
     let provider_config = config.provider_config_for(provider);
     match provider {
+        ApiProvider::Stepfun => stepfun_billing(provider_config),
         // Z.ai's dedicated Coding endpoint is the GLM Coding Plan route. Its
         // quota is subscription-backed, so a public API price estimate is not
         // truthful spend and must not appear as dollars in the UI.
@@ -104,6 +105,19 @@ pub fn for_route(config: &Config, provider: ApiProvider) -> BillingPresentation
     }
 }
 
+fn stepfun_billing(config: Option<&ProviderConfig>) -> BillingPresentation {
+    let base_url = config
+        .and_then(|config| config.base_url.as_deref())
+        .unwrap_or(crate::config::DEFAULT_STEPFUN_BASE_URL);
+    match crate::pricing::billing_surface_for_route(ApiProvider::Stepfun, Some(base_url)) {
+        Some(crate::pricing::STEPFUN_PAYG_BILLING_SURFACE) => BillingPresentation::Metered,
+        Some(crate::pricing::STEPFUN_PLAN_BILLING_SURFACE) => {
+            BillingPresentation::Subscription("StepFun Step Plan quota")
+        }
+        _ => BillingPresentation::Unknown,
+    }
+}
+
 fn uses_zai_coding_plan(config: Option<&ProviderConfig>) -> bool {
     // The configured URL is optional because the Coding Plan endpoint is also
     // CodeWhale's Z.ai default. A credentials-only `[providers.zai]` entry
@@ -138,7 +152,7 @@ pub fn for_child_route(
         | ApiProvider::Anthropic
         | ApiProvider::XiaomiMimo
         | ApiProvider::Zai => BillingPresentation::Subscription("provider quota"),
-        ApiProvider::Custom => BillingPresentation::Unknown,
+        ApiProvider::Stepfun | ApiProvider::Custom => BillingPresentation::Unknown,
         _ => BillingPresentation::Metered,
     }
 }
@@ -154,7 +168,16 @@ pub fn has_priced_metered_basis(
     provider: ApiProvider,
     model: &str,
 ) -> bool {
-    billing.shows_money() && crate::pricing::has_pricing_for_provider(provider, model)
+    billing.shows_money()
+        && if provider == ApiProvider::Stepfun {
+            crate::pricing::has_pricing_for_billing_surface(
+                provider,
+                model,
+                Some(crate::pricing::STEPFUN_PAYG_BILLING_SURFACE),
+            )
+        } else {
+            crate::pricing::has_pricing_for_provider(provider, model)
+        }
 }
 
 /// Build the truthful usage chip for session surfaces.
@@ -401,6 +424,52 @@ mod tests {
         );
     }
 
+    #[test]
+    fn stepfun_payg_shows_money_but_step_plan_stays_subscription_billed() {
+        let payg_billing = for_route(&Config::default(), ApiProvider::Stepfun);
+        assert_eq!(payg_billing, BillingPresentation::Metered);
+        let payg_chip = usage_chip(
+            payg_billing,
+            ApiProvider::Stepfun,
+            crate::config::DEFAULT_STEPFUN_MODEL,
+            0.42,
+            CostCurrency::Usd,
+            None,
+        );
+        assert_eq!(format_usage_chip(&payg_chip).as_deref(), Some("$0.42"));
+
+        let plan_config = config_with(
+            ApiProvider::Stepfun,
+            ProviderConfig {
+                base_url: Some("https://api.stepfun.ai/step_plan/v1".to_string()),
+                ..ProviderConfig::default()
+            },
+        );
+        let plan_billing = for_route(&plan_config, ApiProvider::Stepfun);
+        assert_eq!(
+            plan_billing,
+            BillingPresentation::Subscription("StepFun Step Plan quota")
+        );
+        let plan_chip = usage_chip(
+            plan_billing,
+            ApiProvider::Stepfun,
+            crate::config::DEFAULT_STEPFUN_MODEL,
+            0.42,
+            CostCurrency::Usd,
+            None,
+        );
+        assert!(!format_usage_line(&plan_chip).contains('$'));
+
+        assert_eq!(
+            for_child_route(
+                ApiProvider::Deepseek,
+                BillingPresentation::Metered,
+                ApiProvider::Stepfun,
+            ),
+            BillingPresentation::Unknown
+        );
+    }
+
     #[test]
     fn routed_zai_child_never_claims_api_dollars_without_full_route_config() {
         assert_eq!(