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
//! Explicit connection lifecycle; legacy saves keep their replacement-selection semantics.
use super::*;
use hiroute_application_api::{ComputeManagementEditV1, ComputeSaveChangeViewV2};
use hiroute_domain::{ComputeManagementSourceV2, RevisionSetV1};
impl<C, R, S, I> ComputeManagementPlanner<'_, C, R, S, I>
where
C: ComputeCandidatePort,
R: ComputeManagementRepositoryPort,
S: SecretStorePort,
I: ProtectedInputPort,
{
pub(super) fn validate_name_edit(
&self,
change: &ComputeManagementChangeV2,
resolved: &ResolvedSubject,
sources: &[ComputeManagementSourceV2],
) -> Result<(), ComputeManagementPlanningErrorV2> {
if let Some(ComputeManagementEditV1::Rename { display_name }) = &change.edit {
let name = display_name.trim();
if sources.iter().any(|source| {
source.source_id != resolved.source_id && source.display_name.trim() == name
}) {
return Err(ComputeManagementPlanningErrorV2::InvalidChange);
}
}
Ok(())
}
pub(super) fn preview_lifecycle(
&self,
change: ComputeManagementChangeV2,
resolved: ResolvedSubject,
revisions: RevisionSetV1,
) -> Result<ComputeManagementPreparedPreviewV2, ComputeManagementPlanningErrorV2> {
let current = resolved
.current
.as_ref()
.ok_or(ComputeManagementPlanningErrorV2::SourceNotFound)?;
let mut source = current.clone();
source.revision = source
.revision
.checked_add(1)
.ok_or(ComputeManagementPlanningErrorV2::InvalidChange)?;
let mut secrets = Vec::new();
let mut discovery_guards = Vec::new();
let desired = match change
.edit
.as_ref()
.ok_or(ComputeManagementPlanningErrorV2::InvalidChange)?
{
ComputeManagementEditV1::Rename { display_name } => {
source.display_name = display_name.trim().to_owned();
Some(source)
}
ComputeManagementEditV1::RemoveModels => {
let selected = select_saved_models(current, &change.selected_model_refs)?;
source.models.retain(|model| {
!selected
.iter()
.any(|removed| removed.binding_id == model.binding_id)
});
if source.models.is_empty() {
return Err(ComputeManagementPlanningErrorV2::ModelNotSelectable);
}
Some(source)
}
ComputeManagementEditV1::Delete => {
for key in ¤t.credentials {
if self.secrets.generation(&key.credential)? != key.credential.generation() {
return Err(ComputeManagementPlanningErrorV2::CredentialConflict);
}
secrets.push(
SecretMutationV1::delete(
key.credential.clone(),
key.credential.generation(),
)
.map_err(|_| ComputeManagementPlanningErrorV2::InvalidKeyEdit)?,
);
}
None
}
ComputeManagementEditV1::AppendModels => {
let candidate = resolved
.candidate
.as_ref()
.ok_or(ComputeManagementPlanningErrorV2::InvalidCandidate)?;
if candidate.existing_source_id.as_deref() != Some(current.source_id.as_str()) {
return Err(ComputeManagementPlanningErrorV2::LineageConflict);
}
ensure_unique_nonempty(&change.selected_model_refs)?;
let mut additions = Vec::new();
for reference in &change.selected_model_refs {
let member = candidate
.models
.iter()
.find(|model| &model.model_ref == reference);
if current.models.iter().any(|old| {
&old.model_ref == reference
|| member
.is_some_and(|new| new.upstream_model_id == old.upstream_model_id)
}) {
continue;
}
member.ok_or(ComputeManagementPlanningErrorV2::ModelNotSelectable)?;
additions.push(reference.clone());
}
if candidate.validation.as_ref() != change.validation.as_ref() {
return Err(ComputeManagementPlanningErrorV2::ValidationConflict);
}
// Validate the checked connection identity even when every selected member already
// exists. Append cannot quietly replace the endpoint, credentials or provenance.
let target = candidate
.target
.as_ref()
.ok_or(ComputeManagementPlanningErrorV2::InvalidCandidate)?;
if target.scheme != current.target.scheme
|| target.authority != current.target.authority
|| target.port != current.target.port
|| target.request_path != current.target.request_path
|| target.upstream_protocol != current.target.upstream_protocol
|| target.protocol_profile_id != current.target.protocol_profile_id
|| target.protocol_profile_revision != current.target.protocol_profile_revision
|| candidate.authentication.as_ref() != Some(¤t.authentication)
|| candidate.additional_native_endpoints != current.additional_native_endpoints
{
return Err(ComputeManagementPlanningErrorV2::LineageConflict);
}
self.materialize_primary_candidate_key(
candidate,
Some(current),
&change,
&mut source,
&mut secrets,
&mut discovery_guards,
)?;
if !additions.is_empty() {
source.models.extend(select_candidate_models(
¤t.source_id,
Some(current),
candidate,
&additions,
change.intent,
)?);
}
source.validation = map_validation(candidate.validation.as_ref());
source.last_candidate_ref = candidate.candidate.candidate_ref.clone();
source.last_candidate_revision = candidate.candidate.candidate_revision;
Some(source)
}
};
if let Some(source) = &desired {
source
.validate()
.map_err(|_| ComputeManagementPlanningErrorV2::InvalidCandidate)?;
}
self.seal_preview(
change,
Some(current),
desired,
resolved
.candidate
.as_ref()
.map(|facts| facts.candidate.clone()),
revisions,
secrets,
discovery_guards,
)
}
#[allow(clippy::too_many_arguments)]
pub(super) fn seal_preview(
&self,
change: ComputeManagementChangeV2,
current: Option<&ComputeManagementSourceV2>,
desired: Option<ComputeManagementSourceV2>,
candidate: Option<ComputeCandidateRefV2>,
revisions: RevisionSetV1,
secrets: Vec<SecretMutationV1>,
discovery_guards: Vec<ComputePreparedDiscoveryGuardV1>,
) -> Result<ComputeManagementPreparedPreviewV2, ComputeManagementPlanningErrorV2> {
let source = desired
.as_ref()
.or(current)
.ok_or(ComputeManagementPlanningErrorV2::SourceNotFound)?;
let changes = if let Some(desired) = &desired {
preview_changes(current, desired)
} else {
let mut changes = vec![ComputeSaveChangeViewV2 {
resource_kind: "compute_source".into(),
resource_id: source.source_id.clone(),
action: "delete".into(),
}];
changes.extend(source.models.iter().map(|model| ComputeSaveChangeViewV2 {
resource_kind: "model_binding".into(),
resource_id: model.binding_id.clone(),
action: "remove".into(),
}));
changes.extend(
source
.credentials
.iter()
.map(|key| ComputeSaveChangeViewV2 {
resource_kind: "credential_key".into(),
resource_id: key.key_id.clone(),
action: "remove".into(),
}),
);
changes
};
let removed: Vec<_> = changes
.iter()
.filter(|change| change.resource_kind == "model_binding" && change.action == "remove")
.map(|change| change.resource_id.clone())
.collect();
let affected_plan_refs = if removed.is_empty() {
Vec::new()
} else {
self.repository
.compute_management_references(&self.workspace, &removed)?
};
let spec = ChangeSpecV1 {
schema_version: CHANGE_SPEC_SCHEMA_V1,
command_id: "compute.connection.apply".into(),
resource_id: Some(source.source_id.clone()),
desired_state: serde_json::to_value(&change)
.map_err(|_| ComputeManagementPlanningErrorV2::InvalidChange)?,
};
let plan = TransactionPlanV1::from_compute_management_change(
spec.clone(),
current,
desired,
secrets,
)
.map_err(|_| ComputeManagementPlanningErrorV2::InvalidChange)?;
// Keep the released save digest unchanged. The writer re-reads references atomically;
// a preview is descriptive and never grants permission to bypass that read.
let accept_digest = CanonicalDigest::of(&(
"hiroute.compute-management-preview/v2",
&spec,
&revisions,
plan.control(),
plan.secrets(),
))
.map_err(|_| ComputeManagementPlanningErrorV2::InvalidChange)?;
Ok(ComputeManagementPreparedPreviewV2 {
result: ComputeSavePreviewV2 {
candidate,
validation: change.validation,
spec,
accept_digest,
expected_revisions: revisions,
changes,
affected_plan_refs,
},
plan,
discovery_guards,
})
}
}