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 super::*;
use hiroute_application::compiler::{FreeCandidateEvidenceV1, OrderingPriceFactV1};
use hiroute_domain::{
ComputeCredentialSelectionV2, ComputeManagementProvenanceV2, ConnectionOrigin,
MaterializationState,
};
pub(in crate::control::runtime) fn materialize_registered_management_candidate(
fact: &ComputeManagementCompilationFactV2,
catalog: &TrustedReleaseCatalog,
) -> Option<CandidateCompilationFactV1> {
let ComputeManagementProvenanceV2::Registered {
connection_option_id,
..
} = &fact.provenance
else {
return None;
};
if fact.eligibility != ComputeManagementEligibilityV2::CatalogMatched {
return None;
}
let resolved = catalog
.resolve_connection_option(connection_option_id)
.ok()?;
if resolved.connector.runtime_kind != ConnectorRuntimeKind::BuiltinNative
|| resolved.option.origin == ConnectionOrigin::AgentSubscription
{
return None;
}
let Some(model_id) = fact.catalog_configuration_id.as_deref() else {
eprintln!("registered management routing candidate has no catalog model id");
return None;
};
let data = catalog.model_data();
let Some(mut model) = data.model(model_id).cloned() else {
eprintln!("registered management routing candidate model is absent from current catalog");
return None;
};
let mut capabilities = data
.model_endpoint_capabilities
.iter()
.filter(|capability| {
capability.model_configuration_id == model_id
&& capability.upstream_model_id == fact.upstream_model_id
&& capability.connector_id == resolved.connector.connector_id
&& capability.connector_revision == resolved.connector.revision
&& capability.endpoint_profile_id == resolved.endpoint_profile.endpoint_profile_id
&& capability.endpoint_profile_revision == resolved.endpoint_profile.revision
&& capability.upstream_protocol == fact.target.upstream_protocol
&& capability.required_adapter_ref == fact.target.protocol_profile_id
&& capability.required_adapter_revision == fact.target.protocol_profile_revision
});
let Some(capability) = capabilities.next().cloned() else {
eprintln!("registered management routing candidate has no exact current capability");
return None;
};
if capabilities.next().is_some() {
return None;
}
let endpoint = resolved
.endpoint_profile
.protocol_endpoints
.iter()
.find(|endpoint| {
endpoint.protocol_endpoint_id == capability.protocol_endpoint_id
&& endpoint.protocol == capability.upstream_protocol
&& endpoint.adapter_ref == capability.required_adapter_ref
&& endpoint.adapter_revision == capability.required_adapter_revision
})
.cloned();
let Some(endpoint) = endpoint else {
eprintln!("registered management routing candidate has no exact current endpoint");
return None;
};
let authentication =
native_endpoint_authentication(resolved.connector.authentication, &endpoint)?;
if fact.authentication != authentication {
return None;
}
if fact.target.scheme != "https"
|| fact.target.port != 443
|| endpoint.base_url.strip_prefix("https://") != Some(fact.target.authority.as_str())
|| endpoint.request_path != fact.target.request_path
|| fact.target.validate().is_err()
{
return None;
}
let mut reasoning = catalog
.native_reasoning()
.iter()
.find(|reasoning| reasoning.model_configuration_id == model_id)?
.clone();
if hiroute_integrations::compute::saved_native_capability_digest(
&fact.upstream_model_id,
&fact.capabilities,
)
.as_ref()
!= Some(&fact.capability_evidence_digest)
|| fact
.capabilities
.native_reasoning
.value
.as_ref()
.is_some_and(|r| r != &fact.native_reasoning)
{
return None;
}
let effective = hiroute_integrations::compute::resolve_managed_defaults(
catalog,
&fact.capabilities,
&fact.default_preferences,
&capability,
&model,
&reasoning,
)
.ok()?;
model.capabilities.tool = effective.tool.value?;
model.capabilities.vision = effective.vision.value?;
model.capabilities.streaming = effective.streaming.value?;
model.capabilities.context_tokens = effective.context_tokens.value?;
model.capabilities.max_output_tokens = effective.max_output_tokens.value?;
reasoning.capability = effective.native_reasoning.value?;
let mut offers = data.offers.iter().filter(|offer| {
offer.endpoint_profile_id == resolved.endpoint_profile.endpoint_profile_id
&& offer.endpoint_profile_revision == resolved.endpoint_profile.revision
&& offer.service_offering_id == resolved.endpoint_profile.service_offering_id
&& offer.entitlement_id == resolved.endpoint_profile.entitlement_id
&& offer.usage_scope == resolved.endpoint_profile.usage_scope
&& offer.region_id == resolved.endpoint_profile.region_id
&& offer
.model_configuration_ids
.iter()
.any(|id| id == model_id)
&& offer.billing_class == resolved.option.billing_class
});
let Some(offer) = offers.next() else {
eprintln!("registered management routing candidate has no exact current offer");
return None;
};
if offers.next().is_some() {
return None;
}
let Ok(destination) = fact.target.credential_destination() else {
eprintln!("registered management routing candidate has an invalid credential destination");
return None;
};
let mut destinations = std::collections::BTreeSet::from([destination.clone()]);
for saved in &fact.additional_native_endpoints {
if !resolved
.endpoint_profile
.protocol_endpoints
.iter()
.any(|endpoint| {
crate::control::runtime::model_connections::registered_endpoint_matches_saved_extra(
saved, &resolved, endpoint,
)
})
{
return None;
}
destinations.insert(saved.target.credential_destination().ok()?);
}
let ComputeManagementCredentialCompilationV2::Native { ordered } = &fact.credential else {
return None;
};
if ordered.is_empty() || ordered.len() > MAX_CREDENTIAL_REFS {
return None;
}
let identity = CanonicalDigest::of(&(&fact.source_id, &fact.source_lineage_digest)).ok()?;
let suffix = &identity.as_str()["sha256:".len()..][..24];
let mut credential_refs = Vec::new();
for selection in ordered {
selection.validate_for(&authentication).ok()?;
credential_refs.push(match selection {
ComputeCredentialSelectionV2::Credential { credential_ref } => {
if credential_ref.owner_scope() != format!("source/{}", fact.source_id)
|| credential_ref.subject() != "hirouted"
|| credential_ref.purpose() != "provider-auth"
|| credential_ref.generation() == 0
|| credential_ref.allowed_destinations() != &destinations
{
return None;
}
credential_ref.credential_id().to_owned()
}
ComputeCredentialSelectionV2::NoCredential => format!("credential/none/{suffix}"),
});
}
let execution = materialize_candidate_execution(
&resolved,
&model,
&capability,
&endpoint,
&reasoning,
None,
None,
);
let Some(mut execution) = execution else {
eprintln!("registered management routing candidate protocol facts are not materializable");
return None;
};
execution.protocol_profiles = registered_native_protocol_profiles(
fact,
&resolved,
&model,
&capability,
&endpoint,
&reasoning,
)?;
let ordering_price =
if let Some(price) = data.price_rates.iter().find(|price| {
price.offer_ref == offer.offer_id && price.model_configuration_id == model_id
}) {
Some(OrderingPriceFactV1 {
price_rate_id: price.price_rate_id.clone(),
price_rate_revision: price.revision,
offer_ref: price.offer_ref.clone(),
model_configuration_id: price.model_configuration_id.clone(),
currency: price.currency.clone(),
input_micros_per_million: price.input_micros_per_million,
output_micros_per_million: price.output_micros_per_million,
frozen_digest: CanonicalDigest::of(price).ok()?,
})
} else {
None
};
let free_evidence = if offer.billing_class == BillingClass::Free {
let free = data.free_offers.iter().find(|free| {
free.offer_ref == offer.offer_id
&& free.model_configuration_ids.iter().any(|id| id == model_id)
})?;
Some(FreeCandidateEvidenceV1 {
free_offer_id: free.free_offer_id.clone(),
free_offer_revision: free.revision,
offer_ref: free.offer_ref.clone(),
access: free.access,
evidence_digest: free
.direct_verification_evidence
.as_ref()
.map(|value| CanonicalDigest::of_bytes(value.as_bytes()))
.unwrap_or_else(|| CanonicalDigest::of_bytes(b"api-key-required")),
})
} else {
None
};
let candidate = CandidateCompilationFactV1 {
authority: CandidateFactAuthorityV1::RegisteredCatalog,
connection_option_id: connection_option_id.clone(),
offer_revision: offer.revision,
binding: SourceBindingV1 {
binding_id: fact.binding_id.clone(),
revision: fact.binding_revision,
source_id: fact.source_id.clone(),
source_revision: fact.source_revision,
source_identity_digest: fact.source_lineage_digest.clone(),
model_data_bundle_version: data.bundle_version.clone(),
capability_slice_version: data.capability_slice_version.clone(),
offer_ref: offer.offer_id.clone(),
offer_evidence_digest: offer.evidence_digest.clone(),
billing_class: offer.billing_class,
model_configuration_id: model_id.into(),
upstream_model_id: fact.upstream_model_id.clone(),
capability_id: capability.capability_id.clone(),
credential_pool_id: (authentication != GatewayAuthenticationSemanticsV1::None)
.then(|| format!("pool/compute-management/{suffix}")),
},
model,
capability,
protocol_endpoint: endpoint,
connector_runtime: execution.connector_runtime,
operational_target: execution.operational_target,
native_transport_model: execution.native_transport_model,
protocol_profiles: execution.protocol_profiles,
credential_refs,
credential_destination_ref: Some(destination),
source_state: MaterializationState::Ready,
inventory_model_matched: true,
reasoning: reasoning.capability,
// Configuration-scoped ratings remain in the current rating snapshot and are not
// collapsed into this legacy model-level compiler field.
rating: None,
ordering_price,
free_evidence,
};
if let Err(error) = candidate.validate() {
eprintln!("registered management routing candidate is invalid: {error}; {candidate:#?}");
return None;
}
Some(candidate)
}
/// Each saved endpoint is individually checked against the current option above. Model-level
/// catalog capability qualifies the shared model facts, not each protocol endpoint.
fn registered_native_protocol_profiles(
fact: &ComputeManagementCompilationFactV2,
resolved: &ResolvedConnectionOptionV1,
model: &ModelDefinitionV1,
primary_capability: &ModelEndpointCapabilityV1,
primary_endpoint: &ProtocolEndpointV1,
reasoning: &ModelNativeReasoningV1,
) -> Option<Vec<GatewayCandidateProtocolProfileV1>> {
let connector = ProtocolConnectorFacts {
provider_id: resolved.endpoint_profile.provider_platform_id.clone(),
endpoint_id: resolved.endpoint_profile.endpoint_profile_id.clone(),
entitlement_id: resolved.endpoint_profile.entitlement_id.clone(),
connector_id: resolved.connector.connector_id.clone(),
connector_revision: resolved.connector.revision.to_string(),
};
let primary_target = GatewayOperationalTargetV1::RegisteredHttps {
uri: format!(
"{}{}",
primary_endpoint.base_url, primary_endpoint.request_path
),
};
let mut faces = vec![ProtocolFace {
protocol: primary_endpoint.protocol,
request_path: primary_endpoint.request_path.clone(),
authentication: primary_endpoint.authentication_semantics.clone()?,
required_headers: primary_endpoint.required_headers.clone(),
native_target: Some(GatewayNativeProfileTargetV2 {
operational_target: primary_target,
credential_destination_ref: fact.target.credential_destination().ok()?,
}),
adapter_ref: Some(primary_endpoint.adapter_ref.clone()),
adapter_revision: Some(primary_endpoint.adapter_revision),
}];
for saved in &fact.additional_native_endpoints {
let endpoint = resolved
.endpoint_profile
.protocol_endpoints
.iter()
.find(|endpoint| {
crate::control::runtime::model_connections::registered_endpoint_matches_saved_extra(
saved, resolved, endpoint,
)
})?;
faces.push(ProtocolFace {
protocol: endpoint.protocol,
request_path: endpoint.request_path.clone(),
authentication: endpoint.authentication_semantics.clone()?,
required_headers: endpoint.required_headers.clone(),
native_target: Some(GatewayNativeProfileTargetV2 {
operational_target: GatewayOperationalTargetV1::RegisteredHttps {
uri: format!("{}{}", endpoint.base_url, endpoint.request_path),
},
credential_destination_ref: saved.target.credential_destination().ok()?,
}),
adapter_ref: Some(endpoint.adapter_ref.clone()),
adapter_revision: Some(endpoint.adapter_revision),
});
}
protocol_profiles(
&connector,
model,
primary_capability,
reasoning,
&fact.upstream_model_id,
ConnectorRuntimeKind::BuiltinNative,
&faces,
)
}