obol-core 0.1.0

Read AI-agent transcripts (Claude Code, Codex, Pi) and estimate their USD cost.
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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115

//! Public result types + the internal per-message usage record.

use serde::Serialize;

#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Provider {
    Anthropic,
    OpenAI,
    OpenRouter,
    Other(String),
}

impl Provider {
    pub fn label(&self) -> &str {
        match self {
            Provider::Anthropic => "anthropic",
            Provider::OpenAI => "openai",
            Provider::OpenRouter => "openrouter",
            Provider::Other(s) => s.as_str(),
        }
    }
}

impl serde::Serialize for Provider {
    fn serialize<S: serde::Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
        s.serialize_str(self.label())
    }
}

#[derive(Debug, Clone, Default, PartialEq, Serialize)]
pub struct TokenBuckets {
    pub input: u64, // uncached input
    pub output: u64,
    pub cache_read: u64,
    pub cache_write: u64, // 5m + 1h combined, for the summary
}

#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct ModelCost {
    pub model: String,
    pub provider: Provider,
    pub tokens: TokenBuckets,
    pub subtotal_usd: f64,
}

#[derive(Debug, Clone, PartialEq, Serialize)]
#[serde(tag = "kind", content = "detail")]
pub enum Approximation {
    UnpricedModel(String),
    AssumedStandardTier,
    UnknownModelForTurn,
}

#[derive(Debug, Clone, PartialEq, Serialize)]
pub struct CostEstimate {
    pub total_usd: f64,
    pub per_model: Vec<ModelCost>,
    pub tokens: TokenBuckets,
    pub unpriced_models: Vec<String>,
    pub approximations: Vec<Approximation>,
    pub pricing_as_of: String,
}

/// One billable API call extracted from a transcript. Produced by the dialect
/// parsers, consumed by the cost engine.
#[derive(Debug, Clone, PartialEq)]
pub struct MessageUsage {
    pub model: String, // verbatim; empty string == unknown (e.g. Codex cleared turn_context)
    pub provider: Provider,
    pub namespace: String, // "litellm" in v1
    pub input_uncached: u64,
    pub cache_read: u64,
    pub cache_write_5m: u64,
    pub cache_write_1h: u64,
    pub output: u64,
    pub request_input_tokens: u64, // full billed input for THIS call, for tier selection
    pub service_tier: Option<String>,
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn provider_serializes_as_lowercase_string() {
        assert_eq!(
            serde_json::to_value(Provider::OpenRouter).unwrap(),
            serde_json::json!("openrouter")
        );
        assert_eq!(
            serde_json::to_value(Provider::Other("bedrock".into())).unwrap(),
            serde_json::json!("bedrock")
        );
        assert_eq!(
            serde_json::to_value(Provider::OpenAI).unwrap(),
            serde_json::json!("openai")
        );
    }

    #[test]
    fn cost_estimate_serializes_with_expected_fields() {
        let est = CostEstimate {
            total_usd: 1.5,
            per_model: vec![],
            tokens: TokenBuckets::default(),
            unpriced_models: vec![],
            approximations: vec![Approximation::AssumedStandardTier],
            pricing_as_of: "2026-06-04".into(),
        };
        let v: serde_json::Value = serde_json::to_value(&est).unwrap();
        assert_eq!(v["total_usd"], 1.5);
        assert_eq!(v["pricing_as_of"], "2026-06-04");
        assert_eq!(v["approximations"][0]["kind"], "AssumedStandardTier");
    }
}