#![cfg(feature = "ollama")]
use crate::args::Opts;
use crate::cli::Output;
use crate::estimate::{count, select};
use crate::ollama;
use crate::ollama::pick::{self, Resolved};
use std::collections::BTreeMap;
use std::path::Path;
pub(crate) fn run(opts: &Opts, root: &Path) -> Output {
let fleet = match ollama::hosts::bases(opts.ollama_hosts.as_deref(), root) {
Ok(f) => f,
Err(e) => return net_err(&e),
};
let tokens = match fileset_tokens(opts, root) {
Ok(t) => t,
Err(e) => return arg_err(&e),
};
match &opts.model {
Some(m) => fleet_models(&fleet, m, tokens),
None => fleet_all(&fleet, tokens),
}
}
fn fleet_models(fleet: &[String], want: &str, tokens: u64) -> Output {
let names: Vec<&str> = want.split(',').map(str::trim).collect();
match names.as_slice() {
[one] => fleet_model(fleet, one, tokens),
_ => fleet_list(fleet, &names, tokens),
}
}
fn fleet_list(fleet: &[String], names: &[&str], tokens: u64) -> Output {
let seen = fleet_windows(fleet);
if seen.windows.is_empty() {
return net_err("no models on the ollama fleet");
}
let fl = Fleet::of(&seen, fleet.len());
match fl.rows_for(names, tokens) {
Ok(rows) => Output::ok(listing(tokens, &rows, &seen, fleet.len())),
Err(e) => arg_err(&e),
}
}
fn listing(tokens: u64, rows: &str, seen: &Seen, named: usize) -> String {
format!("context: {tokens} itok\n{rows}") + &coverage(seen.answered, named)
}
struct Fleet<'a> {
seen: &'a Seen,
served: Vec<&'a str>,
named: usize,
}
impl<'a> Fleet<'a> {
fn of(seen: &'a Seen, named: usize) -> Self {
Self {
seen,
served: seen.windows.keys().map(String::as_str).collect(),
named,
}
}
fn rows_for(&self, names: &[&str], tokens: u64) -> Result<String, String> {
names
.iter()
.map(|w| self.row_for(w, tokens))
.collect::<Result<Vec<_>, _>>()
.map(|rows| rows.concat())
}
fn row_for(&self, want: &str, tokens: u64) -> Result<String, String> {
match pick::resolve(&self.served, want) {
Resolved::One(m) => {
let w = self.seen.windows.get(m).copied().flatten();
Ok(row(m, tokens, w) + "\n")
}
Resolved::Ambiguous(c) => Err(pick::ambiguous_msg(want, &c)),
Resolved::Missing => Err(pick::missing_msg(
want,
&self.served,
self.seen.answered,
self.named,
)),
}
}
}
fn fleet_model(fleet: &[String], want: &str, tokens: u64) -> Output {
let seen = fleet_windows(fleet);
if seen.windows.is_empty() {
return net_err("no models on the ollama fleet");
}
let names: Vec<&str> = seen.windows.keys().map(String::as_str).collect();
let hosts = (seen.answered, fleet.len());
match pick::resolve(&names, want) {
Resolved::One(m) => Output::ok(
row(m, tokens, seen.windows.get(m).copied().flatten()) + "\n",
),
Resolved::Ambiguous(c) => arg_err(&pick::ambiguous_msg(want, &c)),
Resolved::Missing => {
arg_err(&pick::missing_msg(want, &names, hosts.0, hosts.1))
}
}
}
fn arg_err(msg: &str) -> Output {
Output::usage(format!("itok: {msg}\n"))
}
fn fleet_all(fleet: &[String], tokens: u64) -> Output {
let seen = fleet_windows(fleet);
if seen.windows.is_empty() {
return net_err("no models on the ollama fleet");
}
let mut s = format!("context: {tokens} itok\n");
for (model, window) in &seen.windows {
s.push_str(&row(model, tokens, *window));
s.push('\n');
}
s.push_str(&coverage(seen.answered, fleet.len()));
Output::ok(s)
}
fn coverage(answered: usize, named: usize) -> String {
if answered >= named {
return String::new();
}
format!(
" note: {answered}/{named} host(s) answered -- this union is \
PARTIAL; a model may live on a host that did not reply\n"
)
}
fn fleet_windows(fleet: &[String]) -> Seen {
merge(probe_all(fleet))
}
type Served = Vec<(String, Option<u64>)>;
fn probe_all(fleet: &[String]) -> Vec<Option<Served>> {
let running: Vec<_> = fleet
.iter()
.cloned()
.map(|base| std::thread::spawn(move || probe(&base)))
.collect();
running
.into_iter()
.map(|h| h.join().unwrap_or(None))
.collect()
}
fn probe(base: &str) -> Option<Served> {
let models = ollama::models(base).ok()?;
Some(
models
.into_iter()
.map(|m| {
let w = ollama::window(base, &m).ok();
(m, w)
})
.collect(),
)
}
#[derive(Default)]
struct Seen {
windows: BTreeMap<String, Option<u64>>,
answered: usize,
}
fn merge(probed: Vec<Option<Served>>) -> Seen {
let mut seen = Seen::default();
for host in probed {
let Some(models) = host else {
continue; };
seen.answered = seen.answered.saturating_add(1);
for (model, window) in models {
seen.windows.entry(model).or_insert(window);
}
}
seen
}
fn row(model: &str, tokens: u64, window: Option<u64>) -> String {
match window {
Some(w) => fit_line(model, tokens, w),
None => format!(" {model} window unavailable"),
}
}
fn fileset_tokens(opts: &Opts, root: &Path) -> Result<u64, String> {
Ok(select(opts, root)?
.iter()
.filter_map(|f| count(&root.join(f), cfg!(feature = "bpe")))
.fold(0u64, u64::saturating_add))
}
fn fit_line(model: &str, tokens: u64, window: u64) -> String {
let p = pct(tokens, window);
format!(" {model} {tokens} / {window} {p}% {}", verdict(p))
}
fn pct(part: u64, whole: u64) -> u64 {
part.saturating_mul(100).checked_div(whole).unwrap_or(0)
}
fn verdict(pct: u64) -> &'static str {
if pct > 100 {
"OVER"
} else if pct >= 80 {
"warn"
} else {
"ok"
}
}
fn net_err(msg: &str) -> Output {
Output {
out: String::new(),
err: format!("itok: {msg}\n"),
code: 7,
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn the_first_host_in_the_list_wins() {
let a = vec![("shared".to_owned(), Some(100u64))];
let b = vec![("shared".to_owned(), Some(200u64))];
let fwd = merge(vec![Some(a.clone()), Some(b.clone())]);
assert_eq!(fwd.windows.get("shared"), Some(&Some(100)));
let rev = merge(vec![Some(b), Some(a)]);
assert_eq!(rev.windows.get("shared"), Some(&Some(200)));
}
#[test]
fn the_union_spans_hosts_and_counts_the_silent_ones() {
let seen = merge(vec![
Some(vec![("a".to_owned(), Some(1))]),
None, Some(vec![("b".to_owned(), Some(2))]),
]);
assert_eq!(seen.windows.len(), 2, "union across the live hosts");
assert_eq!(seen.answered, 2, "the silent host is not counted");
}
#[test]
fn an_empty_host_still_counts_as_answered() {
let seen = merge(vec![Some(Vec::new())]);
assert!(seen.windows.is_empty());
assert_eq!(seen.answered, 1);
}
#[test]
fn a_hosts_unresolved_window_still_takes_precedence() {
let seen = merge(vec![
Some(vec![("m".to_owned(), None)]),
Some(vec![("m".to_owned(), Some(9))]),
]);
assert_eq!(seen.windows.get("m"), Some(&None));
}
#[test]
fn a_list_is_all_or_nothing() {
let seen = seen_two();
let fl = Fleet::of(&seen, 1);
assert!(fl.row_for("gpt-oss", 1_000).is_ok(), "a resolvable element");
let err = fl.row_for("llama", 1_000).err().unwrap_or_default();
assert!(err.contains("no fleet host serves 'llama'"), "{err}");
assert!(err.contains("1/1 host(s)"), "coverage is stated: {err}");
let both = fl.rows_for(&["gpt-oss", "llama"], 1_000);
assert!(both.is_err(), "one bad element fails the call");
}
fn seen_two() -> Seen {
Seen {
answered: 1,
windows: [
("gpt-oss:20b".to_owned(), Some(131_072u64)),
("codestral:latest".to_owned(), Some(393_216u64)),
]
.into(),
}
}
#[test]
fn the_listing_headers_the_shared_context_and_flags_a_partial_union() {
let seen = seen_two();
let whole = listing(1_000, " row\n", &seen, 1);
assert!(whole.starts_with("context: 1000 itok\n"));
assert!(whole.contains(" row"));
assert!(!whole.contains("PARTIAL"), "1 of 1 answered");
let partial = listing(1_000, " row\n", &seen, 3);
assert!(partial.contains("1/3 host(s) answered"), "{partial}");
}
#[test]
fn every_element_resolves_by_the_same_rule() {
let seen = seen_two();
let fl = Fleet::of(&seen, 1);
for want in ["gpt-oss", "gpt-oss:20b", "codestral"] {
assert!(
fl.row_for(want, 1).is_ok(),
"{want} must resolve as it does alone"
);
}
}
#[test]
fn pct_is_division_safe() {
assert_eq!(pct(50, 200), 25);
assert_eq!(pct(5, 0), 0);
}
#[test]
fn verdict_bands() {
assert_eq!(verdict(10), "ok");
assert_eq!(verdict(90), "warn");
assert_eq!(verdict(120), "OVER");
}
#[test]
fn fit_line_names_model_tokens_and_window() {
let l = fit_line("qwen3-coder:30b", 1000, 262_144);
assert!(l.contains("qwen3-coder:30b"));
assert!(l.contains("1000 / 262144"));
assert!(l.contains("ok"));
}
#[test]
fn a_network_failure_is_exit_seven() {
assert_eq!(net_err("boom").code, 7);
}
}