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
//! Complete descriptive reads. Pagination never holds the feed lock or performs network I/O.
use super::*;
use serde::{Deserialize, Serialize};
use serde_json::Value;
const RESPONSE_BUDGET: usize = 1024 * 1024;
#[derive(Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
struct Cursor {
snapshot: ModelMetadataSnapshotRefV1,
kind: Option<String>,
search: Option<String>,
after: (String, String),
}
fn capture(adapter: &LocalControlAdapter) -> Result<Arc<ReleaseCatalogSnapshot>, ErrorCode> {
adapter
.current_catalog()
.ok_or(ErrorCode::ChangePreviewStale)
}
fn identity(catalog: &ReleaseCatalogSnapshot) -> ModelMetadataSnapshotRefV1 {
let selected = catalog.official_snapshot();
ModelMetadataSnapshotRefV1 {
generation: catalog.generation,
data_revision: selected.data_revision,
data_digest: selected.data_digest,
}
}
fn records(catalog: &ReleaseCatalogSnapshot) -> Result<Vec<ModelMetadataEntryV1>, ErrorCode> {
let snapshot = catalog.official_snapshot();
let mut body = serde_json::to_value(&snapshot.data).map_err(|_| ErrorCode::Internal)?;
let mut result = Vec::new();
let origin = if catalog.official_data_from_feed() {
"website_cache"
} else {
"embedded"
};
let mut add = |kind: &str, field: &mut Value, key: &str| -> Result<(), ErrorCode> {
let Some(values) = field.as_array_mut() else {
return Err(ErrorCode::Internal);
};
for value in values.drain(..) {
let id = value
.get(key)
.and_then(Value::as_str)
.ok_or(ErrorCode::Internal)?;
let id = if kind == "rating" {
format!(
"{id}/{}",
CanonicalDigest::of(&value["native_configuration"])
.map_err(|_| ErrorCode::Internal)?
)
} else {
id.to_owned()
};
let supported = kind == "model"
&& catalog
.model_data()
.model_endpoint_capabilities
.iter()
.any(|c| {
c.model_configuration_id == id
&& catalog.model_data().offers.iter().any(|o| {
o.endpoint_profile_id == c.endpoint_profile_id
&& o.model_configuration_ids.contains(&id)
})
});
result.push(ModelMetadataEntryV1 {
kind: kind.into(),
key: id,
origin: origin.into(),
qualification: if supported {
"locally_supported"
} else {
"descriptive_only"
}
.into(),
value,
});
}
Ok(())
};
for (kind, field, key) in [
("model", "models", "model_configuration_id"),
("capability", "model_endpoint_capabilities", "capability_id"),
("offer", "offers", "offer_id"),
("legacy_price", "price_rates", "price_rate_id"),
("price", "pricing_facts", "pricing_key"),
(
"connection_hint",
"connection_hints",
"connection_option_id",
),
] {
add(kind, &mut body[field], key)?;
}
add(
"rating",
&mut body["rating_snapshot"]["records"],
"model_configuration_id",
)?;
add(
"native_reasoning",
&mut body["rating_snapshot"]["models"],
"model_configuration_id",
)?;
for (kind, field, key) in [
("evidence_source", "evidence_sources", "source_key"),
("client_run", "client_runs", "source_key"),
("access_product", "access_products", "product_key"),
("canonical_model", "canonical_models", "model_key"),
("endpoint_binding", "endpoint_bindings", "binding_key"),
("dynamic_route", "dynamic_routes", "route_key"),
("inference_rule", "inference_rules", "rule_key"),
("provider", "provider_records", "provider_record_key"),
("model_metadata", "model_records", "model_record_key"),
] {
add(kind, &mut body["metadata_catalog"][field], key)?;
}
result.sort_by(|a, b| (&a.kind, &a.key).cmp(&(&b.kind, &b.key)));
Ok(result)
}
pub(super) fn list(
adapter: &LocalControlAdapter,
request: ListModelMetadataV1,
) -> Result<ModelMetadataPageV1, ErrorCode> {
page(capture(adapter)?, request)
}
fn page(
catalog: Arc<ReleaseCatalogSnapshot>,
request: ListModelMetadataV1,
) -> Result<ModelMetadataPageV1, ErrorCode> {
if request.kind.as_ref().is_some_and(|s| s.len() > 64)
|| request.search.as_ref().is_some_and(|s| s.len() > 256)
|| request.cursor.as_ref().is_some_and(|s| s.len() > 4096)
{
return Err(ErrorCode::InvalidArguments);
}
let size = request.page_size.unwrap_or(50);
if size == 0 || size > 100 {
return Err(ErrorCode::InvalidArguments);
}
let snapshot = identity(&catalog);
let search = request.search.map(|s| s.to_lowercase());
let after = if let Some(cursor) = &request.cursor {
let cursor: Cursor =
serde_json::from_str(cursor).map_err(|_| ErrorCode::InvalidArguments)?;
if cursor.snapshot != snapshot {
return Err(ErrorCode::ChangePreviewStale);
}
if cursor.kind != request.kind || cursor.search != search {
return Err(ErrorCode::InvalidArguments);
}
Some(cursor.after)
} else {
None
};
let all: Vec<_> = records(&catalog)?
.into_iter()
.filter(|r| {
request.kind.as_ref().is_none_or(|kind| &r.kind == kind)
&& search.as_ref().is_none_or(|s| {
r.key.to_lowercase().contains(s)
|| r.value.to_string().to_lowercase().contains(s)
})
})
.collect();
let start = if let Some(after) = after {
all.iter()
.position(|r| (&r.kind, &r.key) == (&after.0, &after.1))
.ok_or(ErrorCode::InvalidArguments)?
+ 1
} else {
0
};
let total = all.len();
let mut bytes = 4096;
let mut page = Vec::new();
for entry in all.into_iter().skip(start).take(size as usize) {
let count = serde_json::to_vec(&entry)
.map_err(|_| ErrorCode::Internal)?
.len();
if bytes + count > RESPONSE_BUDGET {
break;
}
bytes += count;
page.push(entry);
}
let complete = start + page.len() == total;
let next_cursor = if complete {
None
} else {
let last = page.last().ok_or(ErrorCode::Internal)?;
Some(
serde_json::to_string(&Cursor {
snapshot: snapshot.clone(),
kind: request.kind,
search,
after: (last.kind.clone(), last.key.clone()),
})
.map_err(|_| ErrorCode::Internal)?,
)
};
let response = ModelMetadataPageV1 {
snapshot,
records: page,
total,
next_cursor,
complete,
};
if serde_json::to_vec(&response)
.map_err(|_| ErrorCode::Internal)?
.len()
> RESPONSE_BUDGET
{
return Err(ErrorCode::Internal);
}
Ok(response)
}
pub(super) fn get(
adapter: &LocalControlAdapter,
request: GetModelMetadataV1,
) -> Result<ModelMetadataDetailV1, ErrorCode> {
detail(capture(adapter)?, request)
}
fn detail(
catalog: Arc<ReleaseCatalogSnapshot>,
request: GetModelMetadataV1,
) -> Result<ModelMetadataDetailV1, ErrorCode> {
// Rating identities include a bounded model ID and the native-configuration digest.
if request.kind.len() > 64 || request.key.len() > 512 {
return Err(ErrorCode::InvalidArguments);
}
let snapshot = identity(&catalog);
if request
.snapshot
.as_ref()
.is_some_and(|expected| expected != &snapshot)
{
return Err(ErrorCode::ChangePreviewStale);
}
let record = records(&catalog)?
.into_iter()
.find(|r| r.kind == request.kind && r.key == request.key)
.ok_or(ErrorCode::InvalidArguments)?;
Ok(ModelMetadataDetailV1 { snapshot, record })
}
#[cfg(test)]
mod tests {
use super::*;
use std::collections::BTreeSet;
fn current() -> Arc<ReleaseCatalogSnapshot> {
Arc::new(ReleaseCatalogSnapshot {
catalog: crate::release_catalog::current_fixture_catalog(),
generation: 1,
accepted_sequence: 0,
})
}
#[test]
fn complete_metadata_pages_have_no_loss_and_old_generation_cursors_conflict() {
let catalog = current();
let expected: BTreeSet<_> = records(&catalog)
.unwrap()
.into_iter()
.map(|r| (r.kind, r.key))
.collect();
let mut actual = BTreeSet::new();
let mut cursor = None;
loop {
let response = page(
catalog.clone(),
ListModelMetadataV1 {
page_size: Some(100),
cursor: cursor.clone(),
..Default::default()
},
)
.unwrap();
assert_eq!(response.total, expected.len());
for record in response.records {
assert!(actual.insert((record.kind, record.key)));
}
if response.complete {
assert!(response.next_cursor.is_none());
break;
}
cursor = response.next_cursor;
}
assert_eq!(actual, expected);
let first = page(
catalog.clone(),
ListModelMetadataV1 {
page_size: Some(1),
..Default::default()
},
)
.unwrap();
let mut next = (*catalog).clone();
next.generation += 1;
let result = page(
Arc::new(next),
ListModelMetadataV1 {
cursor: first.next_cursor,
..Default::default()
},
);
assert!(matches!(result, Err(ErrorCode::ChangePreviewStale)));
}
#[test]
fn metadata_response_budget_continues_instead_of_truncating() {
let base = crate::release_catalog::current_fixture_catalog();
let mut snapshot = base.official_snapshot();
for price in &mut snapshot.data.pricing_facts {
for i in 0..12 {
price.schedules[0]
.condition
.insert(format!("detail_{i}"), Value::String("x".repeat(16_000)));
}
}
snapshot.data_revision += 1;
snapshot.data_digest = CanonicalDigest::of(&snapshot.data).unwrap();
let payload = hiroute_integrations::model_feed::FeedPayload::from_snapshot(
snapshot,
1,
"2026-10-21T00:00:00Z".into(),
"1".repeat(40),
vec![],
);
let admitted =
hiroute_integrations::model_feed::admit(&base, &payload, env!("CARGO_PKG_VERSION"))
.unwrap();
let catalog = Arc::new(ReleaseCatalogSnapshot {
catalog: base.with_feed(&admitted).unwrap(),
generation: 2,
accepted_sequence: 1,
});
let first = page(
catalog.clone(),
ListModelMetadataV1 {
kind: Some("price".into()),
page_size: Some(100),
..Default::default()
},
)
.unwrap();
assert!(!first.complete);
assert!(serde_json::to_vec(&first).unwrap().len() <= RESPONSE_BUDGET);
let second = page(
catalog,
ListModelMetadataV1 {
kind: Some("price".into()),
cursor: first.next_cursor.clone(),
page_size: Some(100),
..Default::default()
},
)
.unwrap();
assert!(second.complete);
assert_eq!(first.records.len() + second.records.len(), first.total);
}
#[test]
fn model_metadata_detail_accepts_full_compound_rating_identities() {
let base = crate::release_catalog::current_fixture_catalog();
let mut snapshot = base.official_snapshot();
let old = snapshot.data.rating_snapshot.records[0]
.model_configuration_id
.clone();
let long = format!("model.{}", "x".repeat(245));
for model in &mut snapshot.data.models {
if model.model_configuration_id == old {
model.model_configuration_id = long.clone();
}
}
snapshot
.data
.models
.sort_by(|a, b| a.model_configuration_id.cmp(&b.model_configuration_id));
for cap in &mut snapshot.data.model_endpoint_capabilities {
if cap.model_configuration_id == old {
cap.model_configuration_id = long.clone();
}
}
for price in &mut snapshot.data.price_rates {
if price.model_configuration_id == old {
price.model_configuration_id = long.clone();
}
}
for offer in &mut snapshot.data.offers {
for id in &mut offer.model_configuration_ids {
if id == &old {
*id = long.clone();
}
}
offer.model_configuration_ids.sort();
}
for native in &mut snapshot.data.rating_snapshot.models {
if native.model_configuration_id == old {
native.model_configuration_id = long.clone();
}
}
for rating in &mut snapshot.data.rating_snapshot.records {
if rating.model_configuration_id == old {
rating.model_configuration_id = long.clone();
}
}
snapshot
.data
.rating_snapshot
.models
.sort_by(|a, b| a.model_configuration_id.cmp(&b.model_configuration_id));
snapshot
.data
.rating_snapshot
.records
.sort_by(|a, b| a.model_configuration_id.cmp(&b.model_configuration_id));
snapshot.data.rating_snapshot.model_catalog_digest =
CanonicalDigest::of(&snapshot.data.models).unwrap();
snapshot.data.rating_snapshot.digest =
snapshot.data.rating_snapshot.computed_digest().unwrap();
snapshot.data_revision += 1;
snapshot.data_digest = CanonicalDigest::of(&snapshot.data).unwrap();
let payload = hiroute_integrations::model_feed::FeedPayload::from_snapshot(
snapshot,
2,
"2026-10-21T00:00:00Z".into(),
"1".repeat(40),
vec![],
);
let admitted =
hiroute_integrations::model_feed::admit(&base, &payload, env!("CARGO_PKG_VERSION"))
.unwrap();
let catalog = Arc::new(ReleaseCatalogSnapshot {
catalog: base.with_feed(&admitted).unwrap(),
generation: 2,
accepted_sequence: 2,
});
let row = records(&catalog)
.unwrap()
.into_iter()
.find(|r| r.kind == "rating" && r.key.starts_with(&long))
.unwrap();
assert!(row.key.len() > 256);
let response = detail(
catalog.clone(),
GetModelMetadataV1 {
kind: row.kind.clone(),
key: row.key.clone(),
snapshot: Some(identity(&catalog)),
},
)
.unwrap();
assert_eq!(response.record, row);
}
}