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 serde_json::json;
use super::*;
use crate::TrustedReleaseCatalog;
fn catalog() -> TrustedReleaseCatalog {
TrustedReleaseCatalog::load_release_facts(
include_bytes!("../../../../assets/release-facts/current/bundle/manifest.json"),
include_bytes!("../../../../assets/release-facts/current/bundle/connector-registry.json"),
include_bytes!("../../../../assets/release-facts/current/bundle/model-data.json"),
)
.unwrap()
}
fn empty() -> FeedPayload {
FeedPayload::from_snapshot(
catalog().official_snapshot(),
43,
"2026-10-18T00:00:00Z".into(),
"0123456789abcdef0123456789abcdef01234567".into(),
vec![],
)
}
fn seal(payload: &mut FeedPayload) {
payload.data.rating_snapshot.model_catalog_digest =
hiroute_domain::CanonicalDigest::of(&payload.data.models).unwrap();
payload.data.rating_snapshot.digest = payload.data.rating_snapshot.computed_digest().unwrap();
payload.data_digest = hiroute_domain::CanonicalDigest::of(&payload.data).unwrap();
}
#[test]
fn model_feed_direct_payload_validation_and_exact_byte_identity() {
let bytes = serde_json::to_vec(&empty()).unwrap();
let parsed = parse_feed(&bytes).unwrap();
assert_eq!(parsed.payload, empty());
assert_eq!(
parsed.payload_digest,
hiroute_domain::CanonicalDigest::of_bytes(&bytes)
);
let mut reformatted = bytes.clone();
reformatted.push(b'\n');
assert_eq!(parse_feed(&reformatted).unwrap().payload, parsed.payload);
assert_ne!(
parse_feed(&reformatted).unwrap().payload_digest,
parsed.payload_digest
);
for invalid in [
b"not JSON".as_slice(),
b"null",
b"{}",
br#"{"schema":"hiroute.model-feed.envelope/v1","payload":"e30=","signatures":[]}"#,
] {
assert_eq!(
parse_feed(invalid).unwrap_err().kind,
FeedFailureKind::Schema
);
}
}
#[test]
fn model_feed_size_schema_and_duplicate_fields_are_checked() {
assert_eq!(
parse_feed(&vec![0; MAX_MODEL_FEED_BYTES + 1])
.unwrap_err()
.kind,
FeedFailureKind::Size
);
let mut boundary = serde_json::to_vec(&empty()).unwrap();
boundary.resize(MAX_MODEL_FEED_BYTES, b' ');
assert!(parse_feed(&boundary).is_ok());
let duplicate = String::from_utf8(serde_json::to_vec(&empty()).unwrap())
.unwrap()
.replace("\"sequence\":43", "\"sequence\":42,\"sequence\":43");
assert_eq!(
parse_feed(duplicate.as_bytes()).unwrap_err().kind,
FeedFailureKind::Schema
);
let mut unknown = serde_json::to_value(empty()).unwrap();
unknown["unknown"] = json!(true);
assert_eq!(
parse_feed(&serde_json::to_vec(&unknown).unwrap())
.unwrap_err()
.kind,
FeedFailureKind::Schema
);
}
#[test]
fn model_feed_forbidden_or_unknown_payload_content_rejected() {
for kind in [
"rating",
"free_offer",
"connector",
"endpoint_profile",
"connection_option",
] {
let mut value = serde_json::to_value(empty()).unwrap();
value["records"] = json!([{"kind":kind,"min_client_version":"0.3.2","included_on":"2026-10-18","record":{}}]);
assert_eq!(
parse_feed(&serde_json::to_vec(&value).unwrap())
.unwrap_err()
.kind,
FeedFailureKind::Schema
);
}
let mut payload = empty();
payload.schema = "hiroute.model-feed/v99".into();
assert!(payload.validate().is_err());
payload = empty();
payload.issued_at = "2026-02-30T00:00:00Z".into();
assert!(payload.validate().is_err());
}
#[test]
fn complete_snapshot_corrects_existing_model_and_prices_without_changing_authority() {
let current = catalog();
let mut payload = empty();
payload.data.models[0].capabilities.context_tokens += 100;
payload.data.price_rates[0].input_micros_per_million += 1;
seal(&mut payload);
let admission = admit(¤t, &payload, "0.3.2").unwrap();
assert_eq!(admission.counts.unresolved, 0);
let effective = current.with_feed(&admission).unwrap();
assert_eq!(effective.model_data().models, payload.data.models);
assert_eq!(effective.model_data().price_rates, payload.data.price_rates);
assert_eq!(effective.rating_snapshot(), &payload.data.rating_snapshot);
assert_eq!(effective.registry(), current.registry());
assert_eq!(
effective.current_release_model_data(),
current.current_release_model_data()
);
}
#[test]
fn unsupported_external_adapter_keeps_complete_descriptions_and_rating_identity() {
let current = catalog();
let mut payload = empty();
payload.data.model_endpoint_capabilities[0].required_adapter_ref = "adapter.future".into();
seal(&mut payload);
let admission = admit(¤t, &payload, "0.3.2").unwrap();
assert!(admission.counts.unresolved > 0);
let effective = current.with_feed(&admission).unwrap();
assert_eq!(effective.model_metadata(), &payload.data.metadata_catalog);
assert_eq!(effective.rating_snapshot(), &payload.data.rating_snapshot);
assert!(
!effective
.model_data()
.model_endpoint_capabilities
.iter()
.any(|c| c.required_adapter_ref == "adapter.future")
);
payload.data.model_endpoint_capabilities[0].model_configuration_id =
"missing-internal-model".into();
seal(&mut payload);
assert!(admit(¤t, &payload, "0.3.2").is_err());
}
#[test]
fn complete_snapshot_allows_withdrawal_but_cannot_change_entitlement() {
let current = catalog();
let mut payload = empty();
let index = payload
.data
.offers
.iter()
.position(|o| o.model_configuration_ids.len() > 1)
.unwrap();
let removed = payload.data.offers[index]
.model_configuration_ids
.pop()
.unwrap();
let offer = payload.data.offers[index].offer_id.clone();
payload
.data
.price_rates
.retain(|p| p.offer_ref != offer || p.model_configuration_id != removed);
seal(&mut payload);
assert!(admit(¤t, &payload, "0.3.2").is_ok());
payload.data.offers[index].usage_scope = "ungranted-scope".into();
seal(&mut payload);
assert!(admit(¤t, &payload, "0.3.2").is_err());
}
#[test]
fn complete_snapshot_rejects_same_body_digest_mismatch_duplicates_and_nested_escaped_keys() {
let mut payload = empty();
payload.data.models[0].capabilities.tool = !payload.data.models[0].capabilities.tool;
assert!(payload.validate().is_err());
payload = empty();
payload.data.models.push(payload.data.models[0].clone());
seal(&mut payload);
assert!(payload.validate().is_err());
let bytes = serde_json::to_string(&empty()).unwrap();
let duplicate = bytes.replacen("\"tool\":", "\"to\\u006fl\":false,\"tool\":", 1);
assert!(parse_feed(duplicate.as_bytes()).is_err());
}
#[test]
fn model_feed_rejects_invalid_dates_and_links() {
for date in ["2026-02-30", "2026-13-01", "2026-00-01", "not-a-date"] {
assert!(!valid_date(date));
}
assert!(valid_date("2024-02-29"));
assert!(!valid_date("2025-02-29"));
for url in [
"https://hiroute.ai.evil/",
"https://hiroute.ai@evil/",
"http://hiroute.ai/",
"https://hiroute.ai/\\evil",
"https://hiroute.ai/\n",
] {
assert!(!valid_featured_url(url));
}
}
#[test]
fn generated_complete_body_preserves_documented_prices_and_exceeds_old_delta_bound() {
let snapshot: hiroute_domain::OfficialModelSnapshotV1 = serde_json::from_slice(include_bytes!(
"../../../../assets/release-facts/current/bundle/official-model-data.json"
))
.unwrap();
let current = catalog()
.with_embedded_official_data(snapshot.clone())
.unwrap();
assert_eq!(current.official_snapshot(), snapshot);
assert!(!snapshot.data.pricing_facts.is_empty());
assert!(!snapshot.data.connection_hints.is_empty());
let mut payload = FeedPayload::from_snapshot(
snapshot,
1,
"2026-10-18T00:00:00Z".into(),
"1".repeat(40),
vec![],
);
for price in payload.data.pricing_facts.iter_mut().take(3) {
for i in 0..10 {
price.schedules[0].condition.insert(
format!("description_{i}"),
serde_json::Value::String("x".repeat(10_000)),
);
}
}
seal(&mut payload);
let bytes = serde_json::to_vec(&payload).unwrap();
assert!(bytes.len() > 2 * 1024 * 1024);
assert_eq!(parse_feed(&bytes).unwrap().payload.data, payload.data);
}