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
//! Resolve current defaults only after the caller has established exact source/endpoint authority.
use super::TrustedReleaseCatalog;
use hiroute_domain::*;
mod scoped;
pub use scoped::*;
use std::collections::BTreeMap;
pub fn resolve_managed_defaults(
catalog: &TrustedReleaseCatalog,
saved: &ComputeManagedCapabilitiesV2,
preferences: &BTreeMap<ModelDefaultFieldV1, ModelDefaultPreferenceV1>,
capability: &ModelEndpointCapabilityV1,
model: &ModelDefinitionV1,
reasoning: &ModelNativeReasoningV1,
) -> Result<ComputeManagedCapabilitiesV2, ComputeContractError> {
if capability.model_configuration_id != model.model_configuration_id
|| reasoning.model_configuration_id != model.model_configuration_id
{
return Err(ComputeContractError::InvalidModelData);
}
let official = official_capability_defaults(catalog, capability, model, reasoning);
let mut result = saved.clone();
macro_rules! resolve {
($field:ident, $key:ident, $value:expr) => {
let follow = match preferences.get(&ModelDefaultFieldV1::$key) {
Some(ModelDefaultPreferenceV1::PreserveSaved) => false,
Some(ModelDefaultPreferenceV1::FollowOfficial { locator }) => {
if saved.$field.basis == ComputeManagementFactBasisV2::ConnectorVerified {
return Err(ComputeContractError::InvalidModelData);
}
if locator.model_configuration_id != capability.model_configuration_id
|| locator.upstream_model_id != capability.upstream_model_id
|| locator.connector_id != capability.connector_id
|| locator.endpoint_profile_id != capability.endpoint_profile_id
|| locator.protocol_endpoint_id != capability.protocol_endpoint_id
{
return Err(ComputeContractError::InvalidModelData);
}
true
}
None => saved.$field.basis == ComputeManagementFactBasisV2::RegisteredCatalog,
};
if follow {
result.$field = ComputeManagementFactValueV2 {
value: $value,
basis: if $value.is_some() {
ComputeManagementFactBasisV2::RegisteredCatalog
} else {
ComputeManagementFactBasisV2::Unknown
},
};
}
};
}
resolve!(tool, Tool, official.tool.value);
resolve!(vision, Vision, official.vision.value);
resolve!(streaming, Streaming, official.streaming.value);
resolve!(context_tokens, ContextTokens, official.context_tokens.value);
resolve!(
max_output_tokens,
MaxOutputTokens,
official.max_output_tokens.value
);
resolve!(
native_reasoning,
NativeReasoning,
official.native_reasoning.value.clone()
);
result
.validate()
.map_err(|_| ComputeContractError::InvalidModelData)?;
Ok(result)
}
/// A withdrawn or mismatched exact default never falls back to the saved default value.
/// Ambiguous legacy provenance may retain its saved meaning until explicitly changed.
pub fn without_current_defaults(
saved: &ComputeManagedCapabilitiesV2,
preferences: &BTreeMap<ModelDefaultFieldV1, ModelDefaultPreferenceV1>,
clear_implicit: bool,
) -> ComputeManagedCapabilitiesV2 {
let mut result = saved.clone();
macro_rules! clear {
($name:ident,$field:ident) => {
if matches!(
preferences.get(&ModelDefaultFieldV1::$field),
Some(ModelDefaultPreferenceV1::FollowOfficial { .. })
) || clear_implicit
&& !preferences.contains_key(&ModelDefaultFieldV1::$field)
&& saved.$name.basis == ComputeManagementFactBasisV2::RegisteredCatalog
{
result.$name = ComputeManagementFactValueV2 {
value: None,
basis: ComputeManagementFactBasisV2::Unknown,
};
}
};
}
clear!(tool, Tool);
clear!(vision, Vision);
clear!(streaming, Streaming);
clear!(context_tokens, ContextTokens);
clear!(max_output_tokens, MaxOutputTokens);
clear!(native_reasoning, NativeReasoning);
result
}
/// Verify a native admission against the saved facts, never against today's defaults.
pub fn saved_native_capability_digest(
upstream: &str,
saved: &ComputeManagedCapabilitiesV2,
) -> Option<CanonicalDigest> {
use crate::{
NativeCandidateFactBasisV1 as Basis, NativeCandidateFactValueV1 as Fact,
NativeModelCapabilityDeclarationV1,
};
fn fact<T: Clone>(saved: &ComputeManagementFactValueV2<T>) -> Option<Fact<T>> {
let basis = match saved.basis {
ComputeManagementFactBasisV2::RegisteredCatalog => Basis::RegisteredCatalog,
ComputeManagementFactBasisV2::RuntimeFallback => Basis::RuntimeFallback,
ComputeManagementFactBasisV2::UserDeclared => Basis::UserDeclared,
ComputeManagementFactBasisV2::Observed => Basis::Observed,
ComputeManagementFactBasisV2::Unknown => Basis::Unknown,
ComputeManagementFactBasisV2::ConnectorVerified => return None,
};
Some(Fact {
value: saved.value.clone(),
basis,
})
}
let declaration = NativeModelCapabilityDeclarationV1 {
tool: fact(&saved.tool)?,
vision: fact(&saved.vision)?,
streaming: fact(&saved.streaming)?,
context_tokens: fact(&saved.context_tokens)?,
max_output_tokens: fact(&saved.max_output_tokens)?,
native_reasoning: fact(&saved.native_reasoning)?,
};
CanonicalDigest::of(&("declared-model-capabilities/v1", upstream, &declaration)).ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn model_defaults_follow_registered_fields_and_preserve_manual_false_and_unknown() {
let catalog = crate::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();
let cap = &catalog.model_data().model_endpoint_capabilities[0];
let model = catalog
.model_data()
.model(&cap.model_configuration_id)
.unwrap();
let reason = catalog
.native_reasoning()
.iter()
.find(|v| v.model_configuration_id == model.model_configuration_id)
.unwrap();
fn registered<T>(v: T) -> ComputeManagementFactValueV2<T> {
ComputeManagementFactValueV2 {
value: Some(v),
basis: ComputeManagementFactBasisV2::RegisteredCatalog,
}
}
let mut saved = ComputeManagedCapabilitiesV2 {
tool: registered(false),
vision: registered(false),
streaming: registered(false),
context_tokens: registered(1234),
max_output_tokens: registered(12),
native_reasoning: registered(reason.capability.clone()),
};
saved.vision.basis = ComputeManagementFactBasisV2::UserDeclared;
saved.streaming = ComputeManagementFactValueV2 {
value: None,
basis: ComputeManagementFactBasisV2::Unknown,
};
let original = saved.clone();
let effective =
resolve_managed_defaults(&catalog, &saved, &BTreeMap::new(), cap, model, reason)
.unwrap();
assert_eq!(
effective.context_tokens.value,
Some(model.capabilities.context_tokens)
);
assert_eq!(effective.vision.value, Some(false));
assert_eq!(effective.streaming.value, None);
assert_eq!(saved, original);
let locator = OfficialModelLocatorV1 {
model_configuration_id: cap.model_configuration_id.clone(),
upstream_model_id: cap.upstream_model_id.clone(),
connector_id: cap.connector_id.clone(),
endpoint_profile_id: cap.endpoint_profile_id.clone(),
protocol_endpoint_id: cap.protocol_endpoint_id.clone(),
};
let mut preferences = BTreeMap::from([
(
ModelDefaultFieldV1::Vision,
ModelDefaultPreferenceV1::FollowOfficial {
locator: locator.clone(),
},
),
(
ModelDefaultFieldV1::ContextTokens,
ModelDefaultPreferenceV1::PreserveSaved,
),
]);
let reset =
resolve_managed_defaults(&catalog, &saved, &preferences, cap, model, reason).unwrap();
assert_eq!(reset.vision.value, Some(model.capabilities.vision));
assert_eq!(reset.context_tokens.value, Some(1234));
let mut wrong = locator;
wrong.upstream_model_id.push_str("-other");
preferences.insert(
ModelDefaultFieldV1::Vision,
ModelDefaultPreferenceV1::FollowOfficial { locator: wrong },
);
assert!(
resolve_managed_defaults(&catalog, &saved, &preferences, cap, model, reason).is_err()
);
}
}