use crate::render::Method;
#[cfg(feature = "bpe")]
use crate::render::O200K;
use crate::units;
use std::path::Path;
const MODELS: &str = ".context-models";
pub(crate) struct Model {
pub(crate) encoding: &'static Method,
pub(crate) window: Option<u64>,
pub(crate) rates: Option<Rates>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct Rates {
pub(crate) input: u64,
pub(crate) cache_read: u64,
pub(crate) cache_write: u64,
}
pub(crate) fn tier(model: Option<&str>, root: &Path) -> Result<Model, String> {
match model {
Some(name) => resolve(root, name),
None => Ok(Model {
encoding: default(),
window: None,
rates: None,
}),
}
}
fn default() -> &'static Method {
#[cfg(feature = "bpe")]
{
&O200K
}
#[cfg(not(feature = "bpe"))]
{
&crate::render::DUMMY
}
}
pub(crate) fn resolve(root: &Path, name: &str) -> Result<Model, String> {
let text = std::fs::read_to_string(root.join(MODELS))
.map_err(|_| format!("unknown model '{name}': no {MODELS}"))?;
find(&text, name)
}
type Row = (String, String, Option<String>, Option<String>);
pub(crate) fn base_id(name: &str) -> &str {
match name.split_once('[') {
Some((base, tail)) if tail.ends_with(']') && !base.is_empty() => base,
_ => name,
}
}
fn row_for(rows: &[Row], name: &str) -> Option<Row> {
rows.iter()
.find(|(m, _, _, _)| m == name)
.or_else(|| rows.iter().find(|(m, _, _, _)| m == base_id(name)))
.cloned()
}
fn find(text: &str, name: &str) -> Result<Model, String> {
let (_, enc, win, rate) = row_for(&rows(text)?, name).ok_or_else(|| {
format!("unknown model '{name}'; add a row to {MODELS}")
})?;
let window = window_of(win.as_deref(), name)?;
let rates = rates_of(rate.as_deref(), name)?;
Ok(Model {
encoding: encoding(&enc)?,
window,
rates,
})
}
fn window_of(win: Option<&str>, name: &str) -> Result<Option<u64>, String> {
match win {
Some(w) => units::parse(w)
.map(Some)
.map_err(|e| format!("bad window for '{name}': {e}")),
None => Ok(None),
}
}
fn rows(text: &str) -> Result<Vec<Row>, String> {
text.lines()
.enumerate()
.map(|(i, l)| (i.saturating_add(1), l.trim()))
.filter(|(_, l)| !l.is_empty() && !l.starts_with('#'))
.map(|(n, l)| row(l).ok_or_else(|| row_err(n, l)))
.collect()
}
fn row(line: &str) -> Option<Row> {
let mut p = line.split_whitespace();
let model = p.next()?.to_owned();
let enc = p.next()?.to_owned();
let window = p.next().map(str::to_owned);
Some((model, enc, window, p.next().map(str::to_owned)))
}
fn rates_of(rate: Option<&str>, name: &str) -> Result<Option<Rates>, String> {
let Some(text) = rate else { return Ok(None) };
let mut parts = text.split('/').map(str::parse::<u64>);
let (Some(Ok(input)), Some(Ok(read)), Some(Ok(write)), None) =
(parts.next(), parts.next(), parts.next(), parts.next())
else {
return Err(format!(
"bad rates for '{name}': expected `in/cr/cc`, three whole \
numbers per million tokens, got `{text}`"
));
};
Ok(Some(Rates {
input,
cache_read: read,
cache_write: write,
}))
}
fn row_err(line: usize, text: &str) -> String {
format!(
"{MODELS}:{line}: expected \
`<model> <encoding> [window] [in/cr/cc]`, got `{text}`"
)
}
fn encoding(name: &str) -> Result<&'static Method, String> {
#[cfg(feature = "bpe")]
if name == "o200k" {
return Ok(&O200K);
}
Err(format!("unknown encoding '{name}' in {MODELS}"))
}
#[cfg(test)]
mod tests {
use super::*;
const TABLE: &str = "# models\n\ngpt-4o o200k 128k 300/30/375\n\
claude-x o200k\n";
#[test]
fn a_bracketed_variant_reduces_to_its_base_id() {
assert_eq!(base_id("claude-opus-5[1m]"), "claude-opus-5");
assert_eq!(base_id("claude-opus-4-6[1m]"), "claude-opus-4-6");
}
#[test]
fn an_unsuffixed_id_is_left_alone() {
assert_eq!(base_id("claude-opus-5"), "claude-opus-5");
assert_eq!(base_id(""), "");
}
#[test]
fn a_malformed_bracket_is_not_a_variant_tag() {
assert_eq!(base_id("claude-opus-5[1m"), "claude-opus-5[1m");
assert_eq!(base_id("[1m]"), "[1m]");
assert_eq!(base_id("claude[1m]extra"), "claude[1m]extra");
}
#[test]
fn a_variant_falls_back_to_the_base_row() {
let rows = rows(TABLE).unwrap_or_default();
let got = row_for(&rows, "claude-x[1m]");
assert_eq!(got.map(|(m, _, _, _)| m), Some("claude-x".to_owned()));
}
#[test]
fn a_row_for_the_variant_wins_over_the_base_row() {
let table = "claude-x o200k 200k\nclaude-x[1m] o200k 1m\n";
let rows = rows(table).unwrap_or_default();
let got = row_for(&rows, "claude-x[1m]");
assert_eq!(got.and_then(|(_, _, w, _)| w), Some("1m".to_owned()));
}
#[test]
fn an_unlisted_model_has_no_row_suffix_or_not() {
let rows = rows(TABLE).unwrap_or_default();
assert!(row_for(&rows, "nonesuch[1m]").is_none());
}
#[test]
fn rows_skip_comments_and_blanks() {
let got: Vec<_> = rows(TABLE).unwrap_or_default();
let names: Vec<&str> =
got.iter().map(|(m, _, _, _)| m.as_str()).collect();
assert_eq!(names, vec!["gpt-4o", "claude-x"]);
}
#[test]
fn a_rate_column_carries_the_cache_split() {
let got = rates_of(Some("300/30/375"), "m").ok().flatten();
assert_eq!(
got,
Some(Rates {
input: 300,
cache_read: 30,
cache_write: 375,
})
);
}
#[test]
fn a_row_without_rates_has_no_money() {
assert_eq!(rates_of(None, "m"), Ok(None));
}
#[test]
fn a_malformed_rate_fails_rather_than_reading_as_absent() {
for bad in ["300/30", "300/30/375/9", "300/x/375", "free", ""] {
assert!(
rates_of(Some(bad), "m").is_err(),
"`{bad}` parsed instead of failing"
);
}
}
#[cfg(feature = "bpe")]
#[test]
fn a_resolved_model_carries_its_rates() {
let got = find(TABLE, "gpt-4o").ok().and_then(|m| m.rates);
assert_eq!(got.map(|r| r.cache_read), Some(30));
}
#[test]
fn a_line_missing_its_encoding_is_dropped() {
let msg = rows("gpt-4o\n").err().unwrap_or_default();
assert!(msg.contains(".context-models:1:"), "{msg}");
assert!(msg.contains("expected"), "{msg}");
}
#[test]
fn an_unknown_model_is_an_error() {
assert!(find(TABLE, "gpt-5").is_err());
}
#[test]
fn a_bad_encoding_is_an_error() {
let e = find("weird koi8\n", "weird").err().unwrap_or_default();
assert!(e.contains("koi8"), "{e}");
}
#[test]
fn a_row_without_a_window_has_none() {
assert_eq!(find(TABLE, "claude-x").ok().and_then(|m| m.window), None);
}
#[test]
fn a_bad_window_is_an_error() {
let e = find("m o200k huge\n", "m").err().unwrap_or_default();
assert!(e.contains("window"), "{e}");
}
#[cfg(feature = "bpe")]
#[test]
fn a_listed_model_resolves_its_encoding_and_window() {
let m = find(TABLE, "gpt-4o").ok().unwrap_or(Model {
encoding: &crate::render::DUMMY,
window: None,
rates: None,
});
assert_eq!(m.encoding.label(), "o200k");
assert!(!m.encoding.approximate);
assert_eq!(m.window, Some(128_000));
}
#[cfg(feature = "bpe")]
#[test]
fn tier_carries_the_models_window() {
let dir = std::env::temp_dir()
.join(format!("itok-t14-tier-{}", std::process::id()));
std::fs::create_dir_all(&dir).ok();
std::fs::write(dir.join(".context-models"), "qwen o200k 256k\n").ok();
let window = tier(Some("qwen"), &dir).ok().and_then(|m| m.window);
assert_eq!(window, Some(256_000));
}
#[test]
fn no_model_takes_the_default_tier() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
assert!(tier(None, &root).is_ok());
}
#[test]
fn a_named_unknown_model_makes_tier_fail() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
assert!(tier(Some("gpt-4o"), &root).is_err());
}
#[test]
fn a_missing_table_means_the_model_is_unknown() {
let root = Path::new(env!("CARGO_MANIFEST_DIR")).join("src");
assert!(resolve(&root, "gpt-4o").is_err());
}
#[cfg(not(feature = "bpe"))]
#[test]
fn o200k_needs_bpe() {
assert!(encoding("o200k").is_err());
}
}