harn-vm 0.10.153

Async bytecode virtual machine for the Harn programming language
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

use super::cost::{
    calculate_cost_for_provider, pricing_aware_call_cost_with_cache, pricing_detail_for,
    PricingSource,
};

fn install_banded_pricing_model() {
    let mut overlay = crate::llm_config::ProvidersConfig::default();
    let mut model = crate::llm_config::embedded_config(None)
        .models
        .get("gpt-4o-mini")
        .expect("embedded fixture model")
        .clone();
    model.name = "Banded pricing fixture".to_string();
    model.pricing = Some(crate::llm_config::ModelPricing {
        input_per_mtok: 1.0,
        output_per_mtok: 10.0,
        cache_read_per_mtok: Some(0.1),
        cache_write_per_mtok: Some(1.25),
        cache_write_1h_per_mtok: None,
        input_token_bands: vec![crate::llm_config::InputTokenPricingBand {
            minimum_input_tokens: 1_000,
            input_multiplier: 2.0,
            output_multiplier: 1.5,
        }],
        promotions: Vec::new(),
        schedules: Vec::new(),
        hosted_tool_fees: Default::default(),
        modality_rates: None,
    });
    overlay
        .models
        .insert("test/banded-pricing".to_string(), model);
    crate::llm_config::set_user_overrides(Some(overlay));
}

#[test]
fn whole_request_pricing_band_drives_cost_and_cache_accounting() {
    let _guard = super::env_guard();
    install_banded_pricing_model();

    let below = calculate_cost_for_provider(
        "openai",
        "test/banded-pricing",
        999,
        100,
        super::cost::settlement_now(),
    );
    let at_band = calculate_cost_for_provider(
        "openai",
        "test/banded-pricing",
        1_000,
        100,
        super::cost::settlement_now(),
    );
    assert!((below - 0.001999).abs() < 1e-12);
    assert!((at_band - 0.0035).abs() < 1e-12);
    let cached = pricing_aware_call_cost_with_cache(
        "openai",
        "test/banded-pricing",
        1_000,
        100,
        800,
        0,
        super::cost::settlement_now(),
        None,
    )
    .expect("fixture model is priced");
    assert!((cached - 0.00206).abs() < 1e-12);
    crate::llm_config::clear_user_overrides();
}

#[test]
fn provider_wire_model_uses_collision_free_route_pricing() {
    let _guard = super::env_guard();
    crate::llm_config::clear_user_overrides();
    let detail = pricing_detail_for(
        "vercel_ai_gateway",
        "anthropic/claude-haiku-4.5",
        super::cost::settlement_now(),
    )
    .expect("Vercel wire model should resolve to its catalog route");
    assert_eq!(detail.source, PricingSource::CatalogModel);
    assert!((detail.input_per_1k - 0.001).abs() < f64::EPSILON);
    assert!((detail.output_per_1k - 0.005).abs() < f64::EPSILON);

    let cost = calculate_cost_for_provider(
        "vercel_ai_gateway",
        "anthropic/claude-haiku-4.5",
        696,
        40,
        super::cost::settlement_now(),
    );
    assert!((cost - 0.000896).abs() < 1e-12);
    crate::llm_config::clear_user_overrides();
}