use std::collections::BTreeMap;
use chrono::{DateTime, TimeDelta, Utc};
use super::route::{Route, Routing};
use super::store::{State, Store};
use super::view::Availability;
use crate::harness::{Asked, Choice, ChosenBy, Harness, Settings};
const FRESH_MINUTES: i64 = 5;
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Candidate {
pub route: Route,
pub choice: Choice,
}
impl Candidate {
fn of(route: &Route, settings: &Settings, chosen_by: ChosenBy) -> Self {
Self {
route: route.clone(),
choice: route.choice(settings, chosen_by),
}
}
fn chosen(choice: &Choice) -> Self {
Self {
route: Route {
model: choice.model.clone(),
effort: choice.effort.clone(),
..Route::named(choice.harness)
},
choice: choice.clone(),
}
}
}
#[derive(Debug, Clone, Default)]
pub struct Router {
ordinary: Vec<Candidate>,
security: Vec<Candidate>,
routing: Routing,
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Picked {
pub index: usize,
pub passed: Vec<String>,
}
impl Router {
pub fn pinned() -> Self {
Self::default()
}
pub fn of(
settings: &Settings,
routing: &Routing,
harness: &Choice,
security_review: Option<&Choice>,
security_default: Option<&Choice>,
) -> Self {
let routes: Vec<Candidate> = routing
.routes
.iter()
.map(|route| Candidate::of(route, settings, ChosenBy::Routes))
.collect();
let ordinary = if harness.chosen_by == ChosenBy::Routes {
routes.clone()
} else {
Vec::new()
};
let review = security_review.unwrap_or(harness);
let default = security_default
.cloned()
.unwrap_or_else(|| Choice::of(&Asked::default(), settings));
let mut security = Vec::new();
match review.chosen_by {
ChosenBy::SecurityConfig | ChosenBy::Routes => {
if review.chosen_by == ChosenBy::SecurityConfig {
security.push(Candidate::chosen(review));
}
if !routing.security_routes.is_empty() {
security.extend(
routing
.security_routes
.iter()
.map(|route| Candidate::of(route, settings, ChosenBy::SecurityConfig)),
);
} else if !routes.is_empty() {
security.extend(routes);
} else {
security.push(Candidate::chosen(&default));
}
}
ChosenBy::Command | ChosenBy::UserConfig | ChosenBy::Default | ChosenBy::Step => {}
}
let mut distinct: Vec<Candidate> = Vec::new();
for candidate in security {
if !distinct
.iter()
.any(|kept| kept.choice.runs_as(&candidate.choice))
{
distinct.push(candidate);
}
}
Self {
ordinary,
security: distinct,
routing: routing.clone(),
}
}
pub fn candidates(&self, security: bool) -> &[Candidate] {
if security {
&self.security
} else {
&self.ordinary
}
}
pub fn harnesses(&self) -> Vec<Harness> {
let mut all: Vec<Harness> = Vec::new();
for candidate in self.ordinary.iter().chain(&self.security) {
if !all.contains(&candidate.choice.harness) {
all.push(candidate.choice.harness);
}
}
all
}
pub fn pick(&self, security: bool, tried: &[usize]) -> Option<Picked> {
let candidates = self.candidates(security);
if candidates.len() < 2 {
return None;
}
let saved = if cfg!(test) {
BTreeMap::new()
} else {
let harnesses: Vec<Harness> = candidates
.iter()
.enumerate()
.filter(|(index, _)| !tried.contains(index))
.map(|(_, candidate)| candidate.choice.harness)
.collect();
Store::machine()
.and_then(|store| {
super::refresh_for_routing(&store, &harnesses)?;
store.read()
})
.unwrap_or_default()
};
select(
candidates,
tried,
&self.routing,
&saved,
Harness::installed,
Utc::now(),
)
}
}
impl Router {
pub fn allowed(&self, security: bool, current: Harness) -> Vec<Route> {
let candidates = self.candidates(security);
let configured = |route: &Route| {
self.routing.routes.contains(route) || self.routing.security_routes.contains(route)
};
if candidates.len() >= 2
|| candidates
.iter()
.any(|candidate| configured(&candidate.route))
{
return candidates
.iter()
.map(|candidate| candidate.route.clone())
.collect();
}
let pinned = candidates
.first()
.map_or(current, |candidate| candidate.choice.harness);
vec![super::exhaustion::pinned(pinned)]
}
pub fn exhaustion(&self, security: bool, current: Harness) -> Option<super::Exhaustion> {
if cfg!(test) {
return None;
}
let saved = Store::machine().and_then(|store| store.read()).ok()?;
super::exhaustion::judge(
&self.allowed(security, current),
&self.routing,
&saved,
Harness::installed,
Utc::now(),
)
}
}
fn select(
candidates: &[Candidate],
tried: &[usize],
routing: &Routing,
saved: &BTreeMap<String, State>,
installed: impl Fn(Harness) -> bool,
now: DateTime<Utc>,
) -> Option<Picked> {
let mut passed = Vec::new();
for (index, candidate) in candidates.iter().enumerate() {
if tried.contains(&index) {
continue;
}
let harness = candidate.choice.harness;
let installed = installed(harness);
let availability = if super::observation::subscription(harness) {
saved
.get(harness.name())
.cloned()
.unwrap_or_default()
.availability(&candidate.route, routing, installed, now)
} else if installed {
Availability::Available
} else {
Availability::NotInstalled
};
if availability.usable() {
return Some(Picked { index, passed });
}
passed.push(format!("{} is {availability}", harness.name()));
}
None
}
pub(super) fn stale(state: Option<&State>, now: DateTime<Utc>) -> bool {
let Some(state) = state else {
return true;
};
state.observed_at.is_none_or(|observed| {
observed > now || now - observed >= TimeDelta::minutes(FRESH_MINUTES)
}) || state.windows.iter().any(|window| window.reset_by(now))
|| state
.cooldown
.as_ref()
.is_some_and(|cooldown| cooldown.until <= now)
}
#[cfg(test)]
mod tests {
use super::*;
use crate::plan_usage::observation::{Exhausted, Observation, Window};
use crate::plan_usage::store::Cooldown;
fn routes(routes: &[Route]) -> Routing {
Routing {
routes: routes.to_vec(),
..Routing::default()
}
}
fn routed(harness: Harness) -> Choice {
Choice {
harness,
model: None,
effort: None,
chosen_by: ChosenBy::Routes,
}
}
fn harnesses(candidates: &[Candidate]) -> Vec<Harness> {
candidates.iter().map(|c| c.choice.harness).collect()
}
fn window(used: f64, resets_at: DateTime<Utc>) -> State {
State {
observed_at: Some(Utc::now()),
windows: vec![Window {
used_percent: Some(used),
resets_at: Some(resets_at),
..Window::named("five_hour").unwrap()
}],
..State::default()
}
}
fn picked(
router: &Router,
security: bool,
tried: &[usize],
saved: &BTreeMap<String, State>,
now: DateTime<Utc>,
) -> Option<usize> {
select(
router.candidates(security),
tried,
&router.routing,
saved,
|_| true,
now,
)
.map(|picked| picked.index)
}
#[test]
fn only_a_choice_the_routes_made_routes_ordinary_sessions() {
let routing = routes(&[Route::named(Harness::Claude), Route::named(Harness::Codex)]);
let settings = Settings::default();
let router = Router::of(&settings, &routing, &routed(Harness::Claude), None, None);
assert_eq!(
harnesses(router.candidates(false)),
[Harness::Claude, Harness::Codex]
);
for chosen_by in [
ChosenBy::Command,
ChosenBy::Step,
ChosenBy::UserConfig,
ChosenBy::Default,
] {
let pinned = Choice {
chosen_by,
..routed(Harness::Claude)
};
let router = Router::of(&settings, &routing, &pinned, None, None);
assert!(router.candidates(false).is_empty(), "{chosen_by:?}");
assert_eq!(router.pick(false, &[]), None, "{chosen_by:?}");
}
}
#[test]
fn a_reserve_ceiling_or_cooldown_routes_away_and_a_lapsed_cooldown_revalidates() {
let now = Utc::now();
let routing = Routing {
max_utilization: 85,
..routes(&[Route::named(Harness::Claude), Route::named(Harness::Codex)])
};
let router = Router::of(
&Settings::default(),
&routing,
&routed(Harness::Claude),
None,
None,
);
let mut saved = BTreeMap::new();
assert_eq!(picked(&router, false, &[], &saved, now), Some(0));
saved.insert("claude".into(), window(90.0, now + TimeDelta::hours(1)));
assert_eq!(picked(&router, false, &[], &saved, now), Some(1));
saved.insert("claude".into(), window(90.0, now - TimeDelta::minutes(1)));
assert_eq!(picked(&router, false, &[], &saved, now), Some(0));
let mut cooled = State::default();
cooled.observe(
&Observation {
harness: Harness::Claude,
windows: Vec::new(),
exhausted: Some(Exhausted::default()),
},
"session",
now,
);
saved.insert("claude".into(), cooled.clone());
assert_eq!(picked(&router, false, &[], &saved, now), Some(1));
assert_eq!(picked(&router, false, &[1], &saved, now), None);
let later = cooled.cooldown.as_ref().unwrap().until + TimeDelta::minutes(1);
assert_eq!(picked(&router, false, &[], &saved, later), Some(0));
}
#[test]
fn credits_hold_a_used_up_window_unless_the_route_allows_them() {
let now = Utc::now();
let mut codex = window(100.0, now + TimeDelta::days(3));
codex.credits = Some(crate::plan_usage::store::Credits {
has_credits: Some(true),
balance: Some("100".into()),
});
let saved = BTreeMap::from([("codex".to_string(), codex)]);
for (allow_credits, expected) in [(false, Some(1)), (true, Some(0))] {
let routing = routes(&[
Route {
allow_credits,
..Route::named(Harness::Codex)
},
Route::named(Harness::Claude),
]);
let router = Router::of(
&Settings::default(),
&routing,
&routed(Harness::Codex),
None,
None,
);
assert_eq!(
picked(&router, false, &[], &saved, now),
expected,
"{allow_credits}"
);
}
}
#[test]
fn security_sessions_walk_security_routes_else_harness_routes_else_the_default() {
let settings = Settings {
default: Some(Harness::Claude),
..Settings::default()
};
let security = Choice {
chosen_by: ChosenBy::SecurityConfig,
..routed(Harness::Codex)
};
let default = Choice {
chosen_by: ChosenBy::UserConfig,
..routed(Harness::Claude)
};
let with_security_routes = Routing {
security_routes: vec![Route::named(Harness::Muse), Route::named(Harness::Agy)],
..routes(&[Route::named(Harness::Claude), Route::named(Harness::Grok)])
};
let only_routes = routes(&[Route::named(Harness::Claude), Route::named(Harness::Grok)]);
for (routing, expected) in [
(
&with_security_routes,
vec![Harness::Codex, Harness::Muse, Harness::Agy],
),
(
&only_routes,
vec![Harness::Codex, Harness::Claude, Harness::Grok],
),
(&Routing::default(), vec![Harness::Codex, Harness::Claude]),
] {
let router = Router::of(
&settings,
routing,
&routed(Harness::Claude),
Some(&security),
Some(&default),
);
assert_eq!(harnesses(router.candidates(true)), expected);
}
let pinned = Choice {
chosen_by: ChosenBy::Command,
..routed(Harness::Grok)
};
let router = Router::of(&settings, &only_routes, &pinned, None, Some(&default));
assert!(router.candidates(true).is_empty());
assert!(router.candidates(false).is_empty());
}
#[test]
fn old_or_reset_snapshots_are_stale_for_routing() {
let now = Utc::now();
assert!(stale(None, now));
let fresh = State {
observed_at: Some(now),
..window(10.0, now + TimeDelta::hours(1))
};
assert!(!stale(Some(&fresh), now));
let old = State {
observed_at: Some(now - TimeDelta::minutes(6)),
..fresh.clone()
};
assert!(stale(Some(&old), now));
let reset = window(10.0, now - TimeDelta::seconds(1));
assert!(stale(Some(&reset), now));
let lapsed = State {
cooldown: Some(Cooldown {
since: now - TimeDelta::hours(2),
until: now - TimeDelta::hours(1),
window: None,
overage: None,
backoff_minutes: Some(60),
}),
..fresh.clone()
};
assert!(stale(Some(&lapsed), now));
}
}