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
//! Fail-closed recovery of presentation-safe facts for a saved native subscription.
use hiroute_application::compute_management::{
ComputeCandidateFactBasisV2, ComputeCandidateFactValueV2, ComputeCandidateFactsV2,
};
use hiroute_application::control::ComputeManagementControlError;
use hiroute_application_api::{
ComputeManagementIntentV2, ComputeManagementSubjectV2, ComputeModelMembershipV2,
};
use hiroute_domain::{
ComputeManagementFactBasisV2, ComputeManagementFactValueV2, ComputeManagementMembershipV2,
ComputeManagementProvenanceV2, ComputeManagementSourceV2, ControlRepositoryPort, OperationId,
OperationState,
};
use hiroute_local_storage::ComputeSubscriptionValidationStateV1;
use super::LocalControlAdapter;
use super::error::map_port;
use super::record::decode_stored;
impl LocalControlAdapter {
/// Returns the immutable checked candidate only when the retained validation, successful save
/// operation, and current saved aggregate still describe the same connector-owned source.
/// Mismatches are ordinary missing presentation facts: the public row remains visible but is
/// projected partial/unknown by the application layer.
pub(in crate::control::runtime) fn retained_subscription_candidate_for_source(
&self,
source: &ComputeManagementSourceV2,
) -> Result<Option<ComputeCandidateFactsV2>, ComputeManagementControlError> {
let Some(validation) = source.validation.as_ref() else {
return Ok(None);
};
let Ok(approval_id) = OperationId::parse(&validation.approval_operation_id) else {
return Ok(None);
};
let (record, save_operation) = {
let stores = self
.stores_lock()
.map_err(|_| ComputeManagementControlError::Unavailable)?;
let Some(record) = stores
.control()
.compute_subscription_validation(&approval_id)
.map_err(map_port)?
else {
return Ok(None);
};
let Some(save_id) = record.save_operation_id.as_deref() else {
return Ok(None);
};
let Ok(save_id) = OperationId::parse(save_id) else {
return Ok(None);
};
let Some(save_operation) = stores
.control()
.load_operation(&save_id)
.map_err(map_port)?
else {
return Ok(None);
};
(record, save_operation)
};
if record.state != ComputeSubscriptionValidationStateV1::Retained
|| save_operation.state != OperationState::Succeeded
|| save_operation.plan.spec().command_id != "compute.connection.apply"
|| save_operation.plan.spec().resource_id.as_deref() != Some(source.source_id.as_str())
{
return Ok(None);
}
let Ok(change) = hiroute_application_api::saved_compute_change(
save_operation.plan.spec().desired_state.clone(),
) else {
return Ok(None);
};
if change.validate_shape().is_err()
|| !change.key_edits.is_empty()
|| !save_intent_matches_source(change.intent, source)
|| change.selected_model_refs
!= source
.models
.iter()
.map(|model| model.model_ref.clone())
.collect::<Vec<_>>()
{
return Ok(None);
}
let ComputeManagementSubjectV2::Candidate { candidate } = &change.subject else {
return Ok(None);
};
let Ok(stored) = decode_stored(&record.record_json) else {
return Ok(None);
};
let Ok(checked) = stored.checked_facts() else {
return Ok(None);
};
if record.operation_id != approval_id.as_str()
|| record.candidate_ref != checked.candidate.candidate_ref
|| record.candidate_revision != checked.candidate.candidate_revision
|| candidate != &checked.candidate
|| change.validation.as_ref() != checked.validation.as_ref()
|| !saved_source_matches_checked(source, &checked)
{
return Ok(None);
}
Ok(Some(checked))
}
}
fn save_intent_matches_source(
intent: ComputeManagementIntentV2,
source: &ComputeManagementSourceV2,
) -> bool {
matches!(
(intent, source.state),
(
ComputeManagementIntentV2::SaveReady,
hiroute_domain::MaterializationState::Ready
) | (
ComputeManagementIntentV2::SaveDisabled,
hiroute_domain::MaterializationState::Disabled
)
)
}
fn saved_source_matches_checked(
source: &ComputeManagementSourceV2,
checked: &ComputeCandidateFactsV2,
) -> bool {
let (
ComputeManagementProvenanceV2::ConnectorOwned {
connector_id,
account_ref,
},
hiroute_application::compute_management::ComputeCandidateProvenanceV2::ConnectorOwned {
connector_id: checked_connector,
account_ref: checked_account,
},
) = (&source.provenance, &checked.provenance)
else {
return false;
};
let Some(target) = checked.target.as_ref() else {
return false;
};
let Some(authentication) = checked.authentication.as_ref() else {
return false;
};
let Some(checked_validation) = checked.validation.as_ref() else {
return false;
};
let validation_matches = source.validation.as_ref().is_some_and(|saved| {
saved.approval_operation_id == checked_validation.approval_operation.operation_id
&& saved.validation_ref == checked_validation.validation_ref
&& saved.validation_revision == checked_validation.validation_revision
});
hiroute_cpa_bridge::CpaAccountKind::from_connector(connector_id).is_some()
&& connector_id == checked_connector
&& account_ref == checked_account
&& source.display_name == checked.display_name
&& source.last_candidate_ref == checked.candidate.candidate_ref
&& source.last_candidate_revision == checked.candidate.candidate_revision
&& source.credentials.is_empty()
&& validation_matches
&& source.target.scheme == target.scheme
&& source.target.authority == target.authority
&& source.target.port == target.port
&& source.target.request_path == target.request_path
&& source.target.upstream_protocol == target.upstream_protocol
&& source.target.protocol_profile_id == target.protocol_profile_id
&& source.target.protocol_profile_revision == target.protocol_profile_revision
&& &source.authentication == authentication
&& source.models.iter().all(|model| {
let candidate = checked
.models
.iter()
.find(|candidate| model.model_ref == candidate.model_ref);
if !model.execution_eligible {
return candidate
.is_none_or(|candidate| !candidate.selectable || candidate.reason.is_some());
}
candidate.is_some_and(|candidate| {
candidate.selectable
&& candidate.reason.is_none()
&& model.model_ref == candidate.model_ref
&& model.upstream_model_id == candidate.upstream_model_id
&& model.display_name == candidate.display_name
&& model.catalog_configuration_id == candidate.catalog_configuration_id
&& membership_matches(model.membership, candidate.membership)
&& model.capability_evidence_digest == candidate.capability_evidence_digest
&& fact_matches(&model.capabilities.tool, &candidate.capabilities.tool)
&& fact_matches(&model.capabilities.vision, &candidate.capabilities.vision)
&& fact_matches(
&model.capabilities.streaming,
&candidate.capabilities.streaming,
)
&& fact_matches(
&model.capabilities.context_tokens,
&candidate.capabilities.context_tokens,
)
&& fact_matches(
&model.capabilities.max_output_tokens,
&candidate.capabilities.max_output_tokens,
)
&& fact_matches(
&model.capabilities.native_reasoning,
&candidate.capabilities.native_reasoning,
)
})
})
}
fn membership_matches(
saved: ComputeManagementMembershipV2,
checked: ComputeModelMembershipV2,
) -> bool {
matches!(
(saved, checked),
(
ComputeManagementMembershipV2::Catalog,
ComputeModelMembershipV2::Catalog
) | (
ComputeManagementMembershipV2::Observed,
ComputeModelMembershipV2::Observed
) | (
ComputeManagementMembershipV2::UserDeclared,
ComputeModelMembershipV2::UserDeclared
)
)
}
fn fact_matches<T: Eq>(
saved: &ComputeManagementFactValueV2<T>,
checked: &ComputeCandidateFactValueV2<T>,
) -> bool {
saved.value == checked.value
&& matches!(
(saved.basis, checked.basis),
(
ComputeManagementFactBasisV2::RegisteredCatalog,
ComputeCandidateFactBasisV2::RegisteredCatalog
) | (
ComputeManagementFactBasisV2::RuntimeFallback,
ComputeCandidateFactBasisV2::RuntimeFallback
) | (
ComputeManagementFactBasisV2::Observed,
ComputeCandidateFactBasisV2::Observed
) | (
ComputeManagementFactBasisV2::UserDeclared,
ComputeCandidateFactBasisV2::UserDeclared
) | (
ComputeManagementFactBasisV2::ConnectorVerified,
ComputeCandidateFactBasisV2::ConnectorVerified
) | (
ComputeManagementFactBasisV2::Unknown,
ComputeCandidateFactBasisV2::Unknown
)
)
}