tinyagents 1.1.0

A recursive language-model (RLM) harness for Rust.
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

//! Cost accounting.
//!
//! Because [`CostTotals`] is additive, cost composes the same way the runtime
//! recurses: each model call's cost folds into its run, and a parent run rolls
//! up the cost of every nested sub-agent and sub-graph beneath it into one
//! total.
//!
//! [`estimate_cost`] prices a [`Usage`] record against a [`ModelPricing`] entry
//! from the registry catalog. [`CostTotals`] supports `+`/`+=` accumulation so
//! a run can roll up cost across many calls.

mod types;

use std::ops::{Add, AddAssign};

use crate::harness::usage::Usage;
use crate::registry::catalog::ModelPricing;

pub use types::*;

impl CostTotals {
    /// Creates an empty cost accumulator.
    pub fn new() -> Self {
        Self::default()
    }

    /// Recomputes `total_cost` from the component costs.
    fn recompute_total(&mut self) {
        self.total_cost =
            self.input_cost + self.output_cost + self.cache_cost + self.reasoning_cost;
    }
}

impl Add for CostTotals {
    type Output = CostTotals;

    fn add(mut self, rhs: CostTotals) -> CostTotals {
        self += rhs;
        self
    }
}

impl AddAssign for CostTotals {
    fn add_assign(&mut self, rhs: CostTotals) {
        self.input_cost += rhs.input_cost;
        self.output_cost += rhs.output_cost;
        self.cache_cost += rhs.cache_cost;
        self.reasoning_cost += rhs.reasoning_cost;
        self.recompute_total();
    }
}

/// Estimates the cost of a [`Usage`] record using per-token [`ModelPricing`].
///
/// Missing prices contribute zero. Cache read and cache creation tokens are
/// priced independently when the catalog provides those rates and folded into
/// `cache_cost`.
pub fn estimate_cost(pricing: &ModelPricing, usage: &Usage) -> CostTotals {
    let price = |rate: Option<f64>, tokens: u64| rate.unwrap_or(0.0) * tokens as f64;

    let mut totals = CostTotals {
        input_cost: price(pricing.input_per_token, usage.input_tokens),
        output_cost: price(pricing.output_per_token, usage.output_tokens),
        cache_cost: price(pricing.cache_read_input_per_token, usage.cache_read_tokens)
            + price(
                pricing.cache_creation_input_per_token,
                usage.cache_creation_tokens,
            ),
        reasoning_cost: price(pricing.output_reasoning_per_token, usage.reasoning_tokens),
        total_cost: 0.0,
    };
    totals.recompute_total();
    totals
}

#[cfg(test)]
mod test;