Skip to content

Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.

7.2 KB
Raw Blame
use super::*;
use hiroute_domain::*;

fn quote() -> FrozenPriceQuoteV1 {
    let target = PriceTargetV1 {
        workspace_id: WorkspaceId::default(),
        source_id: "source-a".into(),
        source_identity_digest: CanonicalDigest::of_bytes(b"source-a"),
        model_identity: PriceModelIdentityV1::CatalogModel("model-a".into()),
        currency: "USD".into(),
        valuation_kind: PriceValuationKindV1::UsageEstimate,
    };
    let mut quote = FrozenPriceQuoteV1 {
        generation_ref: None,
        actual_source_ref: target.source_id.clone(),
        exact_target: target,
        actual_offer_ref: None,
        reference_model_offer_ref: None,
        valuation_kind: PriceValuationKindV1::UsageEstimate,
        currency: "USD".into(),
        unit: PriceUnitV1::MicrosPerMillionTokens,
        rates: TokenRatesV1 {
            input_uncached: TokenRateV1::known(1_000_000),
            output: TokenRateV1::known(2_000_000),
            cache_read: TokenRateV1::known(100_000),
            cache_write: TokenRateV1::known(1_500_000),
        },
        origin: PriceOriginV1::Manual,
        applied_override_refs: vec![],
        selected_rule_refs: vec![],
        attempt_execution_at: 1,
        applied_schedule: None,
        billing_context: PriceBillingContextV1::StandardTokens,
        unknown_reasons: vec![],
        quote_digest: CanonicalDigest::of_bytes(b"pending"),
    };
    quote.quote_digest = quote.computed_digest().unwrap();
    quote
}

#[test]
fn inclusive_input_is_partitioned_without_double_billing_cache_or_reasoning() {
    let usage = UsageBucketsV2::from_inclusive_input(Some(1000), Some(100), Some(200), Some(100));
    assert_eq!(usage.input_uncached, Some(700));
    let amount = value_attempt(&quote(), &usage).unwrap();
    assert_eq!(amount.known_sum_micros, Some(1070));
    assert_eq!(amount.coverage, MetricCoverage::Complete);
    // Reasoning already included in the output does not create a fifth bucket.
    assert_eq!(amount.components.len(), 4);
}

#[test]
fn unknown_cache_semantics_keep_known_output_and_explicit_partial_coverage() {
    let usage = UsageBucketsV2::from_inclusive_input(Some(1000), Some(100), None, None);
    assert_eq!(usage.input_uncached, None);
    let amount = value_attempt(&quote(), &usage).unwrap();
    assert_eq!(amount.known_sum_micros, Some(200));
    assert_eq!(amount.coverage, MetricCoverage::Partial);
    assert_eq!(
        amount
            .components
            .iter()
            .filter(|part| part.missing.is_some())
            .count(),
        3
    );
}

#[test]
fn rounding_happens_once_after_all_attempt_components() {
    let mut price = quote();
    price.rates = TokenRatesV1 {
        input_uncached: TokenRateV1::known(400_000),
        output: TokenRateV1::known(400_000),
        cache_read: TokenRateV1::known(0),
        cache_write: TokenRateV1::known(0),
    };
    price.quote_digest = price.computed_digest().unwrap();
    let amount = value_attempt(
        &price,
        &UsageBucketsV2 {
            input_uncached: Some(1),
            output: Some(1),
            cache_read: Some(0),
            cache_write: Some(0),
        },
    )
    .unwrap();
    assert_eq!(amount.known_sum_micros, Some(1));
}

#[test]
fn absent_price_is_not_free_and_overflow_is_explicit() {
    let mut price = quote();
    price.rates = TokenRatesV1::unknown(PriceUnknownReasonV1::SnapshotUnavailable);
    price.quote_digest = price.computed_digest().unwrap();
    let amount = value_attempt(
        &price,
        &UsageBucketsV2 {
            input_uncached: Some(0),
            output: Some(0),
            cache_read: Some(0),
            cache_write: Some(0),
        },
    )
    .unwrap();
    assert_eq!(amount.coverage, MetricCoverage::Unknown);
    assert_eq!(amount.known_sum_micros, None);
    price.rates = TokenRatesV1 {
        input_uncached: TokenRateV1::known(u64::MAX),
        output: TokenRateV1::known(u64::MAX),
        cache_read: TokenRateV1::known(u64::MAX),
        cache_write: TokenRateV1::known(u64::MAX),
    };
    price.quote_digest = price.computed_digest().unwrap();
    let amount = value_attempt(
        &price,
        &UsageBucketsV2 {
            input_uncached: Some(u64::MAX),
            output: Some(u64::MAX),
            cache_read: Some(u64::MAX),
            cache_write: Some(u64::MAX),
        },
    )
    .unwrap();
    assert_eq!(amount.known_sum_micros, None);
    assert_eq!(amount.coverage, MetricCoverage::Unknown);
}

#[test]
fn altered_quote_and_inconsistent_usage_do_not_produce_complete_cost() {
    let mut price = quote();
    price.currency = "EUR".into();
    assert_eq!(
        value_attempt(&price, &UsageBucketsV2::default()),
        Err(ValuationError::InvalidEvidence)
    );
    let usage = UsageBucketsV2::from_inclusive_input(Some(10), Some(5), Some(9), Some(9));
    assert_eq!(usage.input_uncached, None);
    assert_eq!(usage.cache_read, None);
    assert_eq!(
        value_attempt(&quote(), &usage).unwrap().coverage,
        MetricCoverage::Partial
    );
}

#[test]
fn reference_comparison_includes_retries_preserves_negative_values_and_rejects_mixed_generation() {
    let mut reference = quote();
    reference.generation_ref = Some(hiroute_domain::PriceGenerationRefV1 {
        id: "g-one".into(),
        digest: hiroute_domain::CanonicalDigest::of_bytes(b"g-one"),
        configuration_revision: 1,
        catalog_refs: vec![],
    });
    reference.quote_digest = reference.computed_digest().unwrap();
    let usage = UsageBucketsV2 {
        input_uncached: Some(100),
        output: Some(20),
        cache_read: Some(0),
        cache_write: Some(0),
    };
    let attempt = value_attempt(&reference, &usage).unwrap();
    let cost = attempt.known_sum_micros.unwrap();
    let comparison = compare_reference(
        &reference,
        &usage,
        &[attempt.clone(), attempt.clone()],
        true,
    )
    .unwrap();
    assert_eq!(comparison.baseline_micros, Some(cost));
    assert_eq!(comparison.savings_micros, Some(-(cost as i64)));
    assert_eq!(comparison.actual_cash_micros, None);
    assert!(comparison.disclosure.contains("quality"));
    assert_eq!(
        compare_reference(&reference, &usage, std::slice::from_ref(&attempt), false)
            .unwrap()
            .savings_micros,
        None
    );
    let mut other = reference.clone();
    other.generation_ref.as_mut().unwrap().id = "g-two".into();
    other.quote_digest = other.computed_digest().unwrap();
    assert_eq!(
        compare_reference(&other, &usage, &[attempt], true)
            .unwrap()
            .savings_micros,
        None
    );
}

#[test]
fn known_zero_bucket_needs_no_rate_but_unknown_usage_stays_unknown() {
    let mut price = quote();
    price.rates.cache_write = TokenRateV1::unknown(PriceUnknownReasonV1::CacheRateNotCollected);
    price.quote_digest = price.computed_digest().unwrap();
    let usage = UsageBucketsV2 {
        input_uncached: Some(100),
        output: Some(10),
        cache_read: Some(0),
        cache_write: Some(0),
    };
    assert_eq!(
        value_attempt(&price, &usage).unwrap().coverage,
        MetricCoverage::Complete
    );
    let unknown = UsageBucketsV2 {
        cache_write: None,
        ..usage
    };
    assert_eq!(
        value_attempt(&price, &unknown).unwrap().coverage,
        MetricCoverage::Partial
    );
}