feat: run each loop phase on its own strength (Thrifty, Balanced, Best)

AI Assisted
This commit is contained in:
jparkerweb committed 2026-11-04 19:23:52 -08:00
1 parent e963513a8a
commit 81d14c8e78
41 files changed
+3290 -81

No files matched your search

+276 -2
View File
@@ -7,8 +7,9 @@
//! agents never come through here: their menu is their own `models` in
//! agents.json.
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::HashSet;
use std::collections::{BTreeMap, HashSet};
use std::path::{Path, PathBuf};
use crate::agents::CustomModel;
@@ -108,6 +109,126 @@ pub fn models_for_builtin(cli_id: &str) -> Vec<CustomModel> {
)
}
/// The loop's strength words, lightest first (`STRENGTH_ORDER` in
/// src/web-console/strengths.mjs).
pub const STRENGTH_ORDER: [&str; 3] = ["thrifty", "balanced", "best"];
/// One strength's model, and the effort when the agent takes one.
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StrengthRow {
pub model: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub effort: Option<String>,
}
/// A row as the resolver keeps it, or None when it is not usable: the model
/// must be a string in `models`; an effort survives only when the agent takes
/// one and it is low, medium or high (`validRow` in strengths.mjs).
fn valid_strength_row(
row: Option<&Value>,
models: &[String],
has_effort: bool,
) -> Option<StrengthRow> {
let row = row?.as_object()?;
let model = row.get("model")?.as_str()?;
if !models.iter().any(|m| m == model) {
return None;
}
let effort = row
.get("effort")
.and_then(Value::as_str)
.filter(|e| has_effort && matches!(*e, "low" | "medium" | "high"))
.map(str::to_string);
Some(StrengthRow {
model: model.to_string(),
effort,
})
}
/// `{ thrifty?, balanced?, best? }` for one agent from the shipped and the
/// user's `strengths` objects (each keyed by agent id): per word the user's row
/// if it is valid, else the shipped row if it is valid; a word with neither is
/// left out. The twin of `resolveStrengths` in strengths.mjs, held to
/// scripts/fixtures/strength-cases.json.
pub fn resolve_strengths(
shipped: &Value,
user: &Value,
agent: &str,
models: &[String],
has_effort: bool,
) -> BTreeMap<String, StrengthRow> {
let mut resolved = BTreeMap::new();
for word in STRENGTH_ORDER {
let row = valid_strength_row(
user.get(agent).and_then(|a| a.get(word)),
models,
has_effort,
)
.or_else(|| {
valid_strength_row(
shipped.get(agent).and_then(|a| a.get(word)),
models,
has_effort,
)
});
if let Some(row) = row {
resolved.insert(word.to_string(), row);
}
}
resolved
}
/// The first mapped word after `word` in `STRENGTH_ORDER`, else None
/// (`nextStrength` in strengths.mjs).
pub fn next_strength(resolved: &BTreeMap<String, StrengthRow>, word: &str) -> Option<String> {
let at = STRENGTH_ORDER.iter().position(|w| *w == word)?;
STRENGTH_ORDER[at + 1..]
.iter()
.find(|w| resolved.contains_key(**w))
.map(|w| w.to_string())
}
/// `strengths_for` from explicit file paths, so tests never touch the real
/// home. The shipped file falls back to the baked list, like `models_for`.
fn strengths_from(
agent: &str,
models: &[String],
has_effort: bool,
shipped_file: Option<&Path>,
user_file: Option<&Path>,
) -> BTreeMap<String, StrengthRow> {
let shipped = shipped_file
.and_then(read_json)
.or_else(|| serde_json::from_str(BAKED_MODELS).ok())
.unwrap_or(Value::Null);
let user = user_file.and_then(read_json).unwrap_or(Value::Null);
resolve_strengths(
shipped.get("strengths").unwrap_or(&Value::Null),
user.get("strengths").unwrap_or(&Value::Null),
agent,
models,
has_effort,
)
}
/// What each strength word maps to for the built-in `agent`, from the same
/// shipped and user files as `models_for_builtin`. `models` is the ids of the
/// agent's menu; a row naming a model outside it reads unmapped.
pub fn strengths_for(
agent: &str,
models: &[String],
has_effort: bool,
) -> BTreeMap<String, StrengthRow> {
strengths_from(
agent,
models,
has_effort,
shipped_models_file().as_deref(),
user_models_file().as_deref(),
)
}
#[cfg(test)]
mod tests {
use super::*;
@@ -211,7 +332,7 @@ mod tests {
assert!(baked.len() > 1);
std::fs::write(&missing, "{ nope").unwrap();
assert!(models_for("claude", Some(&missing), Some(&missing)).len() > 1);
assert!(models_for("codex", Some(&missing), Some(&missing)).is_empty());
assert!(models_for("nonesuch", Some(&missing), Some(&missing)).is_empty());
}
#[test]
@@ -234,4 +355,157 @@ mod tests {
vec![model("sonnet", Some("S"))]
);
}
/// Every case in the shared strength fixture: the same file drives
/// scripts/test-web-console-strengths.mjs, so the console's resolver and
/// this one stay the one rule.
#[test]
fn the_shared_strength_cases_all_resolve_the_same() {
let cases: Value = serde_json::from_str(include_str!(
"../../../scripts/fixtures/strength-cases.json"
))
.unwrap();
assert_eq!(cases["schema"], 1);
let list = cases["cases"].as_array().unwrap();
assert!(list.len() >= 10);
for case in list {
let name = case["name"].as_str().unwrap();
let agent = case["agent"].as_str().unwrap();
let models: Vec<String> = case["models"]
.as_array()
.unwrap()
.iter()
.map(|m| m.as_str().unwrap().to_string())
.collect();
// The fixture holds one agent's rows; the resolver reads them by agent id.
let wrap = |rows: &Value| json!({ agent: rows.clone() });
let resolved = resolve_strengths(
&wrap(&case["shipped"]),
&wrap(&case["user"]),
agent,
&models,
case["hasEffort"].as_bool().unwrap(),
);
let got = serde_json::to_value(&resolved).unwrap();
assert_eq!(got, case["expect"]["resolved"], "{name}: resolved");
for word in STRENGTH_ORDER {
let want = case["expect"]["next"][word].as_str().map(str::to_string);
assert_eq!(
next_strength(&resolved, word),
want,
"{name}: next after {word}"
);
}
}
}
#[test]
fn next_strength_of_an_unknown_word_is_none() {
let mut resolved = BTreeMap::new();
resolved.insert(
"best".to_string(),
StrengthRow {
model: "x".to_string(),
effort: None,
},
);
assert_eq!(next_strength(&resolved, "cheap"), None);
assert_eq!(
next_strength(&resolved, "thrifty"),
Some("best".to_string())
);
}
#[test]
fn strengths_for_reads_the_shipped_and_user_files() {
let dir = temp_dir("strengths");
let shipped = dir.join("bin").join("models.json");
let user = dir.join("models.json");
std::fs::write(
&shipped,
r#"{ "claude": [{ "id": "sonnet", "label": "S" }, { "id": "opus", "label": "O" }],
"strengths": { "claude": {
"thrifty": { "model": "sonnet", "effort": "low" },
"best": { "model": "opus", "effort": "medium" } } } }"#,
)
.unwrap();
std::fs::write(
&user,
r#"{ "strengths": { "claude": { "best": { "model": "sonnet", "effort": "high" } } } }"#,
)
.unwrap();
let models = vec!["sonnet".to_string(), "opus".to_string()];
let got = strengths_from("claude", &models, true, Some(&shipped), Some(&user));
assert_eq!(got["thrifty"].model, "sonnet");
assert_eq!(got["best"].model, "sonnet");
assert_eq!(got["best"].effort.as_deref(), Some("high"));
assert!(!got.contains_key("balanced"));
// No user file: the shipped rows alone.
let got = strengths_from("claude", &models, true, Some(&shipped), None);
assert_eq!(got["best"].model, "opus");
// An agent with no rows anywhere has none.
assert!(strengths_from("codex", &models, false, Some(&shipped), Some(&user)).is_empty());
}
#[test]
fn the_baked_copy_ships_the_claude_and_devin_strengths() {
let dir = temp_dir("baked-strengths");
let missing = dir.join("bin").join("models.json");
let ids = |agent: &str| -> Vec<String> {
models_for(agent, Some(&missing), Some(&missing))
.into_iter()
.map(|m| m.id)
.collect()
};
let claude = strengths_from(
"claude",
&ids("claude"),
true,
Some(&missing),
Some(&missing),
);
assert_eq!(claude.len(), 3);
let devin = strengths_from(
"devin",
&ids("devin"),
false,
Some(&missing),
Some(&missing),
);
assert_eq!(devin.len(), 3);
assert!(strengths_from(
"codex",
&ids("codex"),
false,
Some(&missing),
Some(&missing)
)
.is_empty());
}
/// A `strengths` key beside the agents' lists is never read as a model
/// list: the menus come out as they did without it.
#[test]
fn a_strengths_key_leaves_the_model_menus_unchanged() {
let dir = temp_dir("strengths-menu");
let shipped = dir.join("bin").join("models.json");
let user = dir.join("models.json");
std::fs::write(
&shipped,
r#"{ "claude": [{ "id": "sonnet", "label": "S" }],
"strengths": { "claude": { "best": { "model": "sonnet" } } } }"#,
)
.unwrap();
std::fs::write(
&user,
r#"{ "claude": [{ "id": "mine", "label": "M" }],
"strengths": { "claude": { "best": { "model": "mine" } } } }"#,
)
.unwrap();
assert_eq!(
models_for("claude", Some(&shipped), Some(&user)),
vec![model("sonnet", Some("S")), model("mine", Some("M"))]
);
assert!(models_for("strengths", Some(&shipped), Some(&user)).is_empty());
}
}