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) fn tier(model: Option<&str>, root: &Path) -> Result<Model, String> {
match model {
Some(name) => resolve(root, name),
None => Ok(Model {
encoding: default(),
window: 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>);
fn find(text: &str, name: &str) -> Result<Model, String> {
let (_, enc, win) = rows(text)?
.into_iter()
.find(|(m, _, _)| m == name)
.ok_or_else(|| {
format!("unknown model '{name}'; add a row to {MODELS}")
})?;
let window = window_of(win.as_deref(), name)?;
Ok(Model {
encoding: encoding(&enc)?,
window,
})
}
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();
Some((model, enc, p.next().map(str::to_owned)))
}
fn row_err(line: usize, text: &str) -> String {
format!(
"{MODELS}:{line}: expected `<model> <encoding> [window]`, 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\nclaude-x o200k\n";
#[test]
fn rows_skip_comments_and_blanks() {
let got: Vec<_> = rows(TABLE).unwrap_or_default();
assert_eq!(
got,
vec![
(
"gpt-4o".to_owned(),
"o200k".to_owned(),
Some("128k".to_owned())
),
("claude-x".to_owned(), "o200k".to_owned(), None),
]
);
}
#[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,
});
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());
}
}