harn-vm 0.10.168

Async bytecode virtual machine for the Harn programming language
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160

use crate::value::VmDictExt;
use crate::value::VmValue;

use super::AgentHostSession;

pub(super) struct CallAccounting {
    pub(super) cost_usd: Option<f64>,
    pub(super) usage_unknown: bool,
    /// Worst case USD for this call, priced portion included. `None` means the
    /// call has no computable bound, which is what a ceiling must fail closed
    /// on.
    pub(super) projected_cost_usd: Option<f64>,
}

fn dict_field<'a>(value: &'a VmValue, key: &str) -> Option<&'a VmValue> {
    match value {
        VmValue::Dict(map) => map.get(key),
        _ => None,
    }
}

pub(super) fn resolve_call_accounting(
    usage: &VmValue,
    provider: &str,
    model: &str,
    input_tokens: i64,
    output_tokens: i64,
    cache_read_tokens: i64,
    cache_write_tokens: i64,
) -> CallAccounting {
    // This re-prices a ledger the session already recorded, so the card it
    // must use is the one that settled the original call. The recorded ledger
    // carries that instant; a ledger written before the field existed falls
    // back to now, which is the behaviour this path already had.
    let recorded = super::dict_get(usage, "pricing");
    let settled_at = recorded
        .and_then(|pricing| dict_field(pricing, "settled_at_ms"))
        .and_then(|value| match value {
            VmValue::Int(value) => Some(*value),
            _ => None,
        })
        .map(crate::llm::cost::instant_from_wall_ms)
        .unwrap_or_else(crate::llm::cost::settlement_now);
    let cache_ttl = None;
    let explicit_cost = super::dict_get(usage, "cost_usd").and_then(|value| match value {
        VmValue::Float(value) => Some(*value),
        VmValue::Int(value) => Some(*value as f64),
        _ => None,
    });
    let accounting_status = super::dict_get(usage, "accounting_status");
    let cost_usd = explicit_cost.or_else(|| {
        accounting_status.is_none().then(|| {
            crate::llm::cost::pricing_aware_call_cost_with_cache(
                provider,
                model,
                input_tokens,
                output_tokens,
                cache_read_tokens,
                cache_write_tokens,
                settled_at,
                cache_ttl,
            )
        })?
    });
    let usage_unknown = matches!(
        accounting_status,
        Some(VmValue::String(status)) if status.as_str() == "unknown"
    );
    // A ledger written before the projection existed carries no field. Its own
    // cost stands in: a priced call projects to what it cost, and an unpriced
    // one still refuses. Absence must not read as a free zero here.
    let projected_cost_usd = match super::dict_get(usage, "projected_cost_usd") {
        Some(VmValue::Float(value)) => Some(*value),
        Some(VmValue::Int(value)) => Some(*value as f64),
        Some(VmValue::Nil) => None,
        _ => cost_usd,
    };
    CallAccounting {
        cost_usd,
        usage_unknown,
        projected_cost_usd,
    }
}

#[derive(Clone, Copy)]
pub(super) struct SessionUsageTotals {
    pub(super) tokens_used: i64,
    pub(super) known_cost_usd: f64,
    pub(super) input_tokens: i64,
    pub(super) output_tokens: i64,
    pub(super) cache_read_tokens: i64,
    pub(super) cache_write_tokens: i64,
    pub(super) provider_call_count: i64,
    pub(super) unpriced_calls: i64,
    pub(super) usage_unknown_calls: i64,
    pub(super) priced_calls: i64,
    pub(super) projected_cost_used: f64,
    pub(super) unprojectable_calls: i64,
}

impl From<&AgentHostSession> for SessionUsageTotals {
    fn from(session: &AgentHostSession) -> Self {
        Self {
            tokens_used: session.tokens_used,
            known_cost_usd: session.cost_used,
            input_tokens: session.input_tokens,
            output_tokens: session.output_tokens,
            cache_read_tokens: session.cache_read_tokens,
            cache_write_tokens: session.cache_write_tokens,
            provider_call_count: session.provider_call_count,
            unpriced_calls: session.unpriced_calls,
            usage_unknown_calls: session.usage_unknown_calls,
            priced_calls: session.priced_calls,
            projected_cost_used: session.projected_cost_used,
            unprojectable_calls: session.unprojectable_calls,
        }
    }
}

impl SessionUsageTotals {
    /// What a USD ceiling spends against: everything priced plus the worst
    /// case for everything that was not. `None` when any call in the session
    /// has no bound at all, and a governor or budget must then fail closed.
    pub(super) fn projected_cost_usd(self) -> Option<f64> {
        (self.unprojectable_calls == 0).then_some(self.projected_cost_used)
    }

    pub(super) fn to_vm(self, include_token_split: bool) -> VmValue {
        let mut out = crate::value::DictMap::new();
        out.put_int("tokens_used", self.tokens_used);
        // The priced calls measured something real. Nulling their sum because
        // a sibling was unpriced turns a measurement into no measurement; only
        // a session that priced nothing at all blacks out.
        out.insert(
            crate::value::intern_key("cost_usd"),
            if self.priced_calls > 0 || self.unpriced_calls == 0 {
                VmValue::Float(self.known_cost_usd)
            } else {
                VmValue::Nil
            },
        );
        out.insert(
            crate::value::intern_key("projected_cost_usd"),
            self.projected_cost_usd()
                .map_or(VmValue::Nil, VmValue::Float),
        );
        out.put_int("unprojectable_calls", self.unprojectable_calls);
        out.put("known_cost_usd", VmValue::Float(self.known_cost_usd));
        if include_token_split {
            out.put_int("input_tokens", self.input_tokens);
            out.put_int("output_tokens", self.output_tokens);
        }
        out.put_int("cache_read_tokens", self.cache_read_tokens);
        out.put_int("cache_write_tokens", self.cache_write_tokens);
        out.put_int("unpriced_calls", self.unpriced_calls);
        out.put_int("usage_unknown_calls", self.usage_unknown_calls);
        out.put_int("provider_call_count", self.provider_call_count);
        VmValue::dict(out)
    }
}