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
//! Replaceable public facts. Installed registry and free-offer authority are never serialized here.
use super::*;
use crate::CanonicalDigest;
use serde::{Deserialize, Serialize};
use serde_json::Value;
use std::collections::{BTreeMap, BTreeSet};
mod time_windows;
pub const OFFICIAL_MODEL_DATA_SCHEMA: &str = "hiroute.official-model-data/v1";
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct OfficialModelDataV1 {
pub schema: String,
pub models: Vec<ModelDefinitionV1>,
pub model_endpoint_capabilities: Vec<ModelEndpointCapabilityV1>,
pub offers: Vec<OfferV1>,
pub price_rates: Vec<PriceRateV1>,
pub rating_snapshot: RatingSnapshotV2,
pub metadata_catalog: ModelMetadataCatalogV1,
pub pricing_facts: Vec<DocumentedModelPriceV1>,
pub connection_hints: Vec<OfficialConnectionHintV1>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct OfficialModelSnapshotV1 {
pub data_revision: u64,
pub data_digest: CanonicalDigest,
pub data: OfficialModelDataV1,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct DocumentedModelPriceV1 {
pub pricing_key: String,
pub product_key: String,
pub model_key: String,
pub upstream_model_id: String,
pub currency: String,
pub unit: String,
pub price_state: String,
pub schedules: Vec<DocumentedPriceScheduleV1>,
pub evidence_refs: Vec<String>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct DocumentedPriceScheduleV1 {
pub schedule_key: String,
/// Conditions remain descriptive until the valuation engine proves it can evaluate them.
pub condition: BTreeMap<String, Value>,
pub application: String,
pub rates: BTreeMap<String, String>,
}
#[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
#[serde(deny_unknown_fields)]
pub struct OfficialConnectionHintV1 {
pub connection_option_id: String,
pub provider_id: String,
pub name: BTreeMap<String, String>,
pub description: BTreeMap<String, String>,
pub documentation_url: String,
}
impl OfficialModelSnapshotV1 {
pub fn validate(&self) -> Result<(), ComputeContractError> {
self.data.validate()?;
if self.data_revision == 0
|| CanonicalDigest::of(&self.data)
.map_err(|_| ComputeContractError::InvalidModelData)?
!= self.data_digest
{
return Err(ComputeContractError::InvalidModelData);
}
Ok(())
}
}
fn unique<'a>(
ids: impl Iterator<Item = &'a str>,
) -> Result<BTreeSet<&'a str>, ComputeContractError> {
let mut result = BTreeSet::new();
for id in ids {
if id.is_empty() || id.len() > 256 || !result.insert(id) {
return Err(ComputeContractError::InvalidModelData);
}
}
Ok(result)
}
impl OfficialModelDataV1 {
pub fn from_release(data: &ReleaseModelDataBundleV2) -> Self {
Self {
schema: OFFICIAL_MODEL_DATA_SCHEMA.into(),
models: data.data.models.clone(),
model_endpoint_capabilities: data.data.model_endpoint_capabilities.clone(),
offers: data.data.offers.clone(),
price_rates: data.data.price_rates.clone(),
rating_snapshot: data.rating_snapshot.clone(),
metadata_catalog: data.metadata_catalog.clone(),
pricing_facts: vec![],
connection_hints: vec![],
}
}
/// Internal closure is independent of whether this client implements an external adapter.
pub fn validate(&self) -> Result<(), ComputeContractError> {
if self.schema != OFFICIAL_MODEL_DATA_SCHEMA
|| self.models.len() > 16_384
|| self.model_endpoint_capabilities.len() > 16_384
|| self.offers.len() > 16_384
|| self.price_rates.len() > 50_000
|| self.pricing_facts.len() > 50_000
|| self.connection_hints.len() > 1_000
{
return Err(ComputeContractError::InvalidModelData);
}
self.metadata_catalog.validate()?;
self.rating_snapshot.validate()?;
let models = unique(
self.models
.iter()
.map(|m| m.model_configuration_id.as_str()),
)?;
unique(
self.model_endpoint_capabilities
.iter()
.map(|c| c.capability_id.as_str()),
)?;
let offers = unique(self.offers.iter().map(|o| o.offer_id.as_str()))?;
unique(self.price_rates.iter().map(|p| p.price_rate_id.as_str()))?;
if self.models.iter().any(|m| {
m.revision == 0
|| m.display_name.trim().is_empty()
|| m.capabilities.context_tokens == 0
|| m.capabilities.max_output_tokens == 0
}) || self.model_endpoint_capabilities.iter().any(|c| {
c.revision == 0
|| c.required_adapter_revision == 0
|| !models.contains(c.model_configuration_id.as_str())
}) || self.offers.iter().any(|o| {
o.revision == 0
|| o.model_configuration_ids.is_empty()
|| o.model_configuration_ids
.iter()
.any(|id| !models.contains(id.as_str()))
}) || self.price_rates.iter().any(|p| {
!models.contains(p.model_configuration_id.as_str())
|| !offers.contains(p.offer_ref.as_str())
}) {
return Err(ComputeContractError::CrossReference);
}
let native = unique(
self.rating_snapshot
.models
.iter()
.map(|m| m.model_configuration_id.as_str()),
)?;
if models != native
|| CanonicalDigest::of(&self.models)
.map_err(|_| ComputeContractError::InvalidModelData)?
!= self.rating_snapshot.model_catalog_digest
{
return Err(ComputeContractError::CrossReference);
}
let metadata = &self.metadata_catalog;
let evidence: BTreeSet<_> = metadata
.evidence_sources
.iter()
.map(|v| v.source_key.as_str())
.collect();
let products: BTreeSet<_> = metadata
.access_products
.iter()
.map(|v| v.product_key.as_str())
.collect();
let canonical: BTreeSet<_> = metadata
.canonical_models
.iter()
.map(|v| v.model_key.as_str())
.collect();
unique(self.pricing_facts.iter().map(|p| p.pricing_key.as_str()))?;
unique(
self.connection_hints
.iter()
.map(|h| h.connection_option_id.as_str()),
)?;
let mut price_scopes = BTreeSet::new();
for price in &self.pricing_facts {
if !price_scopes.insert((
&price.product_key,
&price.model_key,
&price.upstream_model_id,
&price.currency,
)) {
return Err(ComputeContractError::DuplicateIdentity);
}
if !products.contains(price.product_key.as_str())
|| !canonical.contains(price.model_key.as_str())
|| price.currency.len() != 3
|| !price.currency.bytes().all(|c| c.is_ascii_uppercase())
|| price.unit != "per-1m-tokens"
|| price.schedules.len() > 64
|| price.evidence_refs.is_empty()
|| price
.evidence_refs
.iter()
.any(|e| !evidence.contains(e.as_str()))
{
return Err(ComputeContractError::CrossReference);
}
unique(price.schedules.iter().map(|s| s.schedule_key.as_str()))?;
for schedule in &price.schedules {
schedule.compiled_time_windows()?;
if schedule
.condition
.get("kind")
.and_then(Value::as_str)
.is_none()
|| schedule.application.is_empty()
|| schedule.rates.is_empty()
|| schedule.rates.values().any(|rate| !valid_decimal(rate))
{
return Err(ComputeContractError::InvalidModelData);
}
}
}
for hint in &self.connection_hints {
if !hint.documentation_url.starts_with("https://")
|| hint.name.is_empty()
|| hint.provider_id.is_empty()
{
return Err(ComputeContractError::InvalidModelData);
}
}
Ok(())
}
}
fn valid_decimal(value: &str) -> bool {
let mut parts = value.split('.');
let whole = parts.next().unwrap_or("");
let fraction = parts.next();
!whole.is_empty()
&& whole.bytes().all(|b| b.is_ascii_digit())
&& fraction.is_none_or(|f| !f.is_empty() && f.bytes().all(|b| b.is_ascii_digit()))
&& parts.next().is_none()
&& value.len() <= 64
}