Make Codex and Claude Code subscriptions go further: a local model router that gives routine agent work to economical models and keeps your strongest model for the hard parts.
Rust ai-agentsai-gatewayclaude-codecodexcoding-agentcost-optimizationdeepseekllm-gatewayllm-routerlocal-firstmodel-routingrusttask-routingtauri
use super::*;
use serde_json::json;
const PROVIDER: &str =
"hiroute-main-0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef";
const ENDPOINT: &str = "http://127.0.0.1:4321/_hiroute/qoder/v1";
fn models() -> Vec<AdditionalAgentModelV1> {
["plan-branch-cheap", "hiroute/0011223344556677"]
.into_iter()
.map(|alias| AdditionalAgentModelV1 {
protocol: hiroute_domain::AgentIngressProtocolV1::Responses,
alias: alias.into(),
context_window_tokens: 32_768,
max_output_tokens: 4096,
})
.collect()
}
fn provider(alias: &str) -> String {
let model = models().into_iter().find(|m| m.alias == alias).unwrap();
hiroute_domain::additional_model_provider_for(PROVIDER, &models(), &model)
}
fn first_provider() -> String {
provider("plan-branch-cheap")
}
fn token(byte: u8) -> AgentAccessGrantMaterial {
AgentAccessGrantMaterial::from_csprng_entropy([byte; 32])
}
fn install(bytes: Option<&[u8]>) -> Edit {
configure(
hiroute_domain::AgentKindV1::Qoder,
bytes,
PROVIDER,
ENDPOINT,
&models(),
&token(3),
None,
)
.unwrap()
}
fn value(bytes: &[u8]) -> Value {
Document::parse(bytes).unwrap().root.value
}
#[test]
fn two_additional_routes_keep_native_default_extensions_and_foreign_provider_bytes() {
let original = br#"{
// user's preferred native model
"model": { "name": "auto", "reasoningEffort": "high" },
"providers": { "user-models": {"apiKey":"native-secret", "unknown": [1,2]} },
"hooks":{"SessionEnd":[]},"mcpServers":{"local":{"command":"my-tool"}},
"unknown": "keep // this string"
}"#;
let edit = install(Some(original));
let configured = value(&edit.bytes);
let before = value(original);
for key in ["model", "hooks", "mcpServers", "unknown"] {
assert_eq!(configured[key], before[key]);
}
assert_eq!(
configured["providers"]["user-models"],
before["providers"]["user-models"]
);
let text = std::str::from_utf8(&edit.bytes).unwrap();
assert!(text.contains("// user's preferred native model"));
assert!(text.contains("\"user-models\": {\"apiKey\":\"native-secret\", \"unknown\": [1,2]}"));
for model in models() {
let provider = &configured["providers"][&provider(&model.alias)];
assert_eq!(provider["protocol"], "openai-responses");
assert_eq!(provider["baseUrl"], ENDPOINT);
assert_eq!(
provider["apiKey"],
std::str::from_utf8(token(3).expose()).unwrap()
);
assert_eq!(provider["models"].as_array().unwrap().len(), 1);
let native = &provider["models"][0];
assert_eq!(native["model"], model.alias);
assert_eq!(native["contextWindow"], 32_768);
assert_eq!(native["maxOutputTokens"], 4096);
assert!(provider.get("routing").is_none());
}
assert!(configured.get("modelConfigs").is_none());
assert_eq!(
edit.restore
.restore(Some(&edit.bytes))
.unwrap()
.unwrap()
.as_slice(),
original
);
}
#[test]
fn unrelated_edits_survive_rotation_and_final_restore_without_adopting_owned_drift() {
let original = br#"{"model":{"name":"auto"},"unrelated":1}"#;
let first = install(Some(original));
let edited = std::str::from_utf8(&first.bytes)
.unwrap()
.replace("\"unrelated\":1", "\"unrelated\":2 /* user changed this */");
assert!(first.restore.applied(Some(edited.as_bytes())).unwrap());
let rotated = configure(
hiroute_domain::AgentKindV1::Qoder,
Some(edited.as_bytes()),
PROVIDER,
ENDPOINT,
&models()[..1],
&token(4),
Some(&first.restore),
)
.unwrap();
assert_ne!(
value(&rotated.bytes)["providers"][&first_provider()]["apiKey"],
value(&first.bytes)["providers"][&first_provider()]["apiKey"]
);
let restored = rotated
.restore
.restore(Some(&rotated.bytes))
.unwrap()
.unwrap();
assert_eq!(value(&restored)["unrelated"], 2);
assert!(
std::str::from_utf8(&restored)
.unwrap()
.contains("/* user changed this */")
);
assert!(
value(&restored)["providers"]
.get(first_provider())
.is_none()
);
// A user edit within the owned node remains a conflict even if all declared routes survive.
let mut drift = value(&rotated.bytes);
drift["providers"][&first_provider()]["routing"] = json!({"compact":"user-selected"});
let drift = serde_json::to_vec(&drift).unwrap();
assert!(!rotated.restore.applied(Some(&drift)).unwrap());
assert!(rotated.restore.restore(Some(&drift)).is_err());
assert!(
configure(
hiroute_domain::AgentKindV1::Qoder,
Some(&drift),
PROVIDER,
ENDPOINT,
&models(),
&token(5),
Some(&rotated.restore)
)
.is_err()
);
}
#[test]
fn removing_selected_native_default_requires_user_switch_but_retaining_it_is_allowed() {
let first = install(Some(br#"{"model":{"name":"auto"}}"#));
let mut current = value(&first.bytes);
current["model"]["name"] = format!("{}/plan-branch-cheap", first_provider()).into();
let current = serde_json::to_vec(¤t).unwrap();
assert_eq!(
first
.restore
.validate_restoration(Some(¤t))
.unwrap_err()
.stage,
"default in use"
);
assert_eq!(
validate_configuration(
hiroute_domain::AgentKindV1::Qoder,
Some(¤t),
PROVIDER,
ENDPOINT,
&models()[1..],
Some(&first.restore)
)
.unwrap_err()
.stage,
"default in use"
);
let adjusted = configure(
hiroute_domain::AgentKindV1::Qoder,
Some(¤t),
PROVIDER,
ENDPOINT,
&models()[..1],
&token(4),
Some(&first.restore),
)
.unwrap();
assert_eq!(
value(&adjusted.bytes)["model"]["name"],
format!("{}/plan-branch-cheap", first_provider())
);
let mut switched = value(&adjusted.bytes);
switched["model"]["name"] = "user-provider/user-model".into();
let restored = adjusted
.restore
.restore(Some(&serde_json::to_vec(&switched).unwrap()))
.unwrap()
.unwrap();
assert_eq!(
value(&restored)["model"]["name"],
"user-provider/user-model"
);
}
#[test]
fn existing_provider_is_never_claimed_by_name_and_missing_original_is_removed_exactly() {
let first = install(None);
assert!(
configure(
hiroute_domain::AgentKindV1::Qoder,
Some(&first.bytes),
PROVIDER,
ENDPOINT,
&models(),
&token(3),
None
)
.is_err()
);
assert!(first.restore.restore(Some(&first.bytes)).unwrap().is_none());
assert!(first.restore.restore(None).unwrap().is_none());
let protected = first.restore.encode().unwrap();
let recovered = Restore::decode(&protected).unwrap();
assert!(recovered.applied(Some(&first.bytes)).unwrap());
// Root-level credentials/config cannot be smuggled into the protected ownership baseline.
let mut invalid = recovered;
invalid.original_exists = true;
invalid.original = first.bytes.to_vec();
assert!(Restore::decode(&invalid.encode().unwrap()).is_err());
}
#[test]
fn restore_only_removes_owned_member_at_every_position_preserving_other_jsonc_bytes() {
for original in [
br#"{"providers":{},"note":"keep"}"#.as_slice(),
br#"{/* leading */"providers":{"a":{"v":1},"z":{"v":2}},"note":"keep"}"#,
] {
let first = install(Some(original));
let mut current = value(&first.bytes);
current["unrelated"] = true.into();
let rendered = serde_json::to_vec_pretty(¤t).unwrap();
let restored = first.restore.restore(Some(&rendered)).unwrap().unwrap();
let mut expected = current;
for model in models() {
expected["providers"]
.as_object_mut()
.unwrap()
.remove(&provider(&model.alias));
}
assert_eq!(value(&restored), expected);
}
// A changed file must take the conditional removal path, preserving the complete foreign
// byte sequence even when the user reordered the owned provider among other members.
let first = configure(
AgentKindV1::Qoder,
Some(br#"{"model":{"name":"auto"},"providers":{}}"#),
PROVIDER,
ENDPOINT,
&models()[..1],
&token(3),
None,
)
.unwrap();
let provider =
serde_json::to_string(&value(&first.bytes)["providers"][&first_provider()]).unwrap();
let owned = format!("\"{}\" : {provider}", first_provider());
for (members, expected) in [
(
" $OWNED /* own */ ,\n \"a\" : 1 ,\t\"z\":2 ",
" /* own */ \n \"a\" : 1 ,\t\"z\":2 ",
),
(
" \"a\" : 1 , /* middle */ $OWNED ,\t\"z\":2 ",
" \"a\" : 1 , /* middle */ \t\"z\":2 ",
),
(
" \"a\" : 1 ,\t\"z\":2 , /* last */ $OWNED /* end */ ",
" \"a\" : 1 ,\t\"z\":2 /* last */ /* end */ ",
),
] {
let wrap = |members: &str| {
format!("{{\r\n \"providers\" : {{{members}}}, // user\r\n \"outside\":true\r\n}}")
};
let current = wrap(&members.replace("$OWNED", &owned));
assert_ne!(
CanonicalDigest::of_bytes(current.as_bytes()),
first.restore.rendered_digest
);
let restored = first
.restore
.restore(Some(current.as_bytes()))
.unwrap()
.unwrap();
assert_eq!(restored.as_slice(), wrap(expected).as_bytes());
}
// The parser also accepts comments after the last value before its comma.
let source = br#"{"a":1/*a*/,"b":2/*b*/,"c":3/*c*/}"#;
for key in ["a", "b", "c"] {
let doc = Document::parse(source).unwrap();
let edited = doc.edit(&doc.root, key, None).unwrap();
assert!(value(&edited).get(key).is_none());
assert!(std::str::from_utf8(&edited).unwrap().contains("/*b*/"));
}
}
#[test]
fn ambiguous_or_malformed_documents_fail_without_normalizing_foreign_settings() {
for bytes in [
br#"{"providers":{},"providers":{}}"#.as_slice(),
br#"{"foreign":{"same":1,"same":2}}"#,
br#"{"foreign":{"same":1,"\u0073ame":2}}"#,
br#"{"foreign":[1,]}"#,
br#"{"providers":{ /* unfinished}"#,
br#"{"providers":[]}"#,
br#"{"model":{"name":"auto"}} trailing"#,
] {
assert!(
configure(
hiroute_domain::AgentKindV1::Qoder,
Some(bytes),
PROVIDER,
ENDPOINT,
&models(),
&token(3),
None
)
.is_err()
);
}
for separator in ["\r", "\u{2028}", "\u{2029}"] {
let ambiguous = format!(
"{{\"model\":{{\"name\":\"auto\"}} // c{separator},\"providers\":{{\"user\":{{}}}}\n}}"
);
assert!(
configure(
hiroute_domain::AgentKindV1::Qoder,
Some(ambiguous.as_bytes()),
PROVIDER,
ENDPOINT,
&models(),
&token(3),
None
)
.is_err()
);
}
let unicode = "\u{feff}{\"标签\":\"值 \\\" // /*\", /* 注释 */ \"providers\":{}}";
let edit = install(Some(unicode.as_bytes()));
assert_eq!(
edit.restore
.restore(Some(&edit.bytes))
.unwrap()
.unwrap()
.as_slice(),
unicode.as_bytes()
);
let mut bounded = b"{}".to_vec();
bounded.resize(LIMIT, b' ');
assert!(Document::parse(&bounded).is_ok());
bounded.push(b' ');
assert!(Document::parse(&bounded).is_err());
}
#[test]
fn declarations_reject_unknown_budget_duplicate_alias_and_unowned_namespace() {
let mut selected = models();
selected.push(selected[0].clone());
assert!(
validate_declaration(
hiroute_domain::AgentKindV1::Qoder,
PROVIDER,
ENDPOINT,
&selected
)
.is_err()
);
assert!(
validate_declaration(
hiroute_domain::AgentKindV1::Qoder,
"hiroute-worker-123",
ENDPOINT,
&models()
)
.is_err()
);
assert!(
validate_declaration(
hiroute_domain::AgentKindV1::Qoder,
PROVIDER,
"https://external.example/v1",
&models()
)
.is_err()
);
selected = models();
selected[0].max_output_tokens = 32_000; // the exact 32K/32K zero-threshold regression
assert!(
validate_declaration(
hiroute_domain::AgentKindV1::Qoder,
PROVIDER,
ENDPOINT,
&selected
)
.is_err()
);
assert!(
validate_declaration(hiroute_domain::AgentKindV1::Qoder, PROVIDER, ENDPOINT, &[]).is_err()
);
}
#[test]
fn per_plan_protocols_keep_provider_identity_and_restore_both_without_foreign_changes() {
for kind in [AgentKindV1::Qoder, AgentKindV1::Pi] {
let endpoint = if kind == AgentKindV1::Pi {
"http://127.0.0.1:4321/v1"
} else {
ENDPOINT
};
let original = br#"{"providers":{"foreign":{"apiKey":"keep"}}}"#;
let mut models = models();
models[1].protocol = hiroute_domain::AgentIngressProtocolV1::Messages;
let first = configure(
kind,
Some(original),
PROVIDER,
endpoint,
&models,
&token(3),
None,
)
.unwrap();
let document = value(&first.bytes);
assert_eq!(document["providers"].as_object().unwrap().len(), 3);
let key = if kind == AgentKindV1::Pi {
"api"
} else {
"protocol"
};
assert_eq!(
document["providers"][provider(&models[0].alias)][key],
"openai-responses"
);
assert_eq!(
document["providers"][provider(&models[1].alias)][key],
if kind == AgentKindV1::Pi {
"anthropic-messages"
} else {
"anthropic"
}
);
if kind == AgentKindV1::Pi {
// Native SDK request paths must resolve to the public Gateway endpoints.
let responses = document["providers"][provider(&models[0].alias)]["baseUrl"]
.as_str()
.unwrap();
let messages = document["providers"][provider(&models[1].alias)]["baseUrl"]
.as_str()
.unwrap();
assert_eq!(
format!("{responses}/responses"),
"http://127.0.0.1:4321/v1/responses"
);
assert_eq!(
format!("{messages}/v1/messages"),
"http://127.0.0.1:4321/v1/messages"
);
}
let untouched = document["providers"][provider(&models[1].alias)].clone();
models[0].protocol = hiroute_domain::AgentIngressProtocolV1::Messages;
let next = configure(
kind,
Some(&first.bytes),
PROVIDER,
endpoint,
&models,
&token(3),
Some(&first.restore),
)
.unwrap();
assert_eq!(
value(&next.bytes)["providers"][provider(&models[1].alias)],
untouched
);
let recovered = Restore::decode(&next.restore.encode().unwrap()).unwrap();
assert_eq!(
recovered
.restore(Some(&next.bytes))
.unwrap()
.unwrap()
.as_slice(),
original
);
}
}
#[test]
fn historical_single_provider_record_restores_and_upgrades_without_claiming_foreign_nodes() {
let original = br#"{"providers":{"foreign":{"keep":true}}}"#;
let old_provider = json!({"type":"openai-compatible","protocol":"openai-responses","apiKey":"historical-owned-token","models":[{"model":"plan-branch-cheap"}]});
let mut old_file = value(original);
old_file["providers"][PROVIDER] = old_provider.clone();
let old_bytes = serde_json::to_vec(&old_file).unwrap();
// Historical V1 wire layout, independent of the current Restore serializer.
let header = serde_json::to_vec(&json!({"schema":"hiroute.qoder-native-restore/v1","provider_id":PROVIDER,"provider_digest":digest(&old_provider).unwrap(),"rendered_digest":CanonicalDigest::of_bytes(&old_bytes),"original_exists":true})).unwrap();
let mut envelope = (header.len() as u32).to_le_bytes().to_vec();
envelope.extend(header);
envelope.extend(original);
let old = Restore::decode(&envelope).unwrap();
assert_eq!(
old.restore(Some(&old_bytes)).unwrap().unwrap().as_slice(),
original
);
let upgraded = configure(
AgentKindV1::Qoder,
Some(&old_bytes),
PROVIDER,
ENDPOINT,
&models(),
&token(7),
Some(&old),
)
.unwrap();
assert!(value(&upgraded.bytes)["providers"].get(PROVIDER).is_none());
assert_eq!(
value(&upgraded.bytes)["providers"]
.as_object()
.unwrap()
.len(),
3
);
assert_eq!(
upgraded
.restore
.restore(Some(&upgraded.bytes))
.unwrap()
.unwrap()
.as_slice(),
original
);
let mut selected = old_file;
selected["model"] = json!({"name":format!("{PROVIDER}/plan-branch-cheap")});
assert!(
configure(
AgentKindV1::Qoder,
Some(&serde_json::to_vec(&selected).unwrap()),
PROVIDER,
ENDPOINT,
&models(),
&token(7),
Some(&old)
)
.is_err()
);
}