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
//! Service-owned reconstruction for an exact durable Native source recheck.
use super::{LocalControlAdapter, map_port};
use hiroute_application::control::ComputeManagementControlError;
use hiroute_application_api::{
ComputeCandidateRefV2, ComputeCatalogProvenanceViewV1, ComputeModelMembershipV2,
RegisteredModelConnectionCheckRequestV1, SavedModelConnectionCheckRequestV1,
};
use hiroute_domain::{
ComputeManagementFactBasisV2, ComputeManagementMembershipV2, ComputeManagementProvenanceV2,
ComputeManagementRepositoryPort, ComputeManagementSourceV2, GatewayAuthenticationSemanticsV1,
PortErrorCode, ProtectedSecret, SecretStorePort, VerifiedSecretSubjectV1,
};
use hiroute_integrations::{
ModelConnectionBaseKindV1, NativeCandidateFactBasisV1, NativeCandidateFactValueV1,
NativeConnectionProvenanceInputV1, NativeConnectionQualificationV1,
NativeModelCapabilityDeclarationV1, NativeModelConnectionDraftV1, NativeModelDeclarationV1,
};
pub(super) struct SavedCredentialMaterial {
pub(super) credential_id: String,
pub(super) generation: u64,
pub(super) secret: ProtectedSecret,
}
pub(super) struct SavedModelConnectionPreparation {
pub(super) candidate: ComputeCandidateRefV2,
pub(super) draft: NativeModelConnectionDraftV1,
pub(super) credential: Option<SavedCredentialMaterial>,
}
impl LocalControlAdapter {
pub(super) fn prepare_saved_model_connection(
&self,
request: &SavedModelConnectionCheckRequestV1,
) -> Result<SavedModelConnectionPreparation, ComputeManagementControlError> {
let source = self
.stores_lock()
.map_err(|_| ComputeManagementControlError::Unavailable)?
.control()
.compute_management_source(&request.source_id)
.map_err(map_port)?
.ok_or(ComputeManagementControlError::NotFound)?;
source
.validate()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
if source.revision != request.expected_source_revision {
return Err(ComputeManagementControlError::Conflict);
}
if request
.candidate_ref
.as_ref()
.is_some_and(|candidate_ref| candidate_ref != &source.last_candidate_ref)
{
return Err(ComputeManagementControlError::SavedSourceMismatch);
}
if !source.provenance.is_native() {
return Err(ComputeManagementControlError::Invalid);
}
let candidate = ComputeCandidateRefV2 {
candidate_ref: source.last_candidate_ref.clone(),
candidate_revision: source.last_candidate_revision,
};
candidate
.validate_shape()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let draft = match &source.provenance {
ComputeManagementProvenanceV2::Registered { .. } => {
self.saved_registered_draft(request, &source, &candidate)?
}
ComputeManagementProvenanceV2::UserConfigured { .. } => saved_user_draft(
request,
&source,
self.current_catalog()
.as_deref()
.map(|snapshot| &snapshot.catalog),
)?,
ComputeManagementProvenanceV2::ConnectorOwned { .. } => {
return Err(ComputeManagementControlError::Invalid);
}
};
let credential = self.resolve_saved_model_credential(&source)?;
Ok(SavedModelConnectionPreparation {
candidate,
draft,
credential,
})
}
fn saved_registered_draft(
&self,
request: &SavedModelConnectionCheckRequestV1,
source: &ComputeManagementSourceV2,
candidate: &ComputeCandidateRefV2,
) -> Result<NativeModelConnectionDraftV1, ComputeManagementControlError> {
let ComputeManagementProvenanceV2::Registered {
connection_option_id,
..
} = &source.provenance
else {
return Err(ComputeManagementControlError::Corrupt);
};
let catalog = self
.current_catalog()
.ok_or(ComputeManagementControlError::Unavailable)?;
let provenance = catalog
.compute_catalog_provenance()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let registered = RegisteredModelConnectionCheckRequestV1 {
inference_model_id: None,
models: Vec::new(),
connection_option_id: connection_option_id.clone(),
display_name: Some(source.display_name.clone()),
expected_catalog: ComputeCatalogProvenanceViewV1 {
product_release: provenance.product_release,
catalog_binding_id: provenance.catalog_binding_id,
release_sequence: provenance.release_sequence,
connector_registry_digest: provenance.connector_registry_digest,
model_data_digest: provenance.model_data_digest,
cross_reference_digest: provenance.cross_reference_digest,
},
candidate_ref: Some(candidate.candidate_ref.clone()),
lineage_ref: format!("saved-source/{}", source.source_id),
edit_revision: request.edit_revision,
check_id: request.check_id.clone(),
input_candidate: candidate.clone(),
existing_source_id: Some(source.source_id.clone()),
expected_source_revision: Some(source.revision),
};
let mut draft = self
.trusted_registered_draft_for_saved_source(®istered, source)
.map_err(|error| match error {
ComputeManagementControlError::RegisteredSourceMismatch => {
ComputeManagementControlError::SavedSourceMismatch
}
other => other,
})?;
let NativeConnectionProvenanceInputV1::Registered {
connection_option_id: current_option,
..
} = &draft.provenance
else {
return Err(ComputeManagementControlError::Corrupt);
};
if current_option != connection_option_id {
return Err(ComputeManagementControlError::SavedSourceMismatch);
}
self.validate_registered_source_identity(source, &draft)
.map_err(|error| match error {
ComputeManagementControlError::RegisteredSourceMismatch => {
ComputeManagementControlError::SavedSourceMismatch
}
other => other,
})?;
let preferences = self
.stores_lock()
.map_err(|_| ComputeManagementControlError::Unavailable)?
.control()
.source_default_preferences(&source.source_id)
.map_err(map_port)?;
let effective = super::defaults::project_source(&catalog, source, &preferences);
for saved in &effective.models {
if let Some(declared) = draft.models.iter_mut().find(|declared| {
declared.upstream_model_id == saved.upstream_model_id
&& declared.catalog_configuration_id == saved.catalog_configuration_id
}) {
declared.capabilities = saved_model(saved)?.capabilities;
}
}
let base_url = draft.base_url.clone();
let request_path = draft.request_path_override.clone().unwrap_or_default();
for model in &source.models {
if model.catalog_configuration_id.is_none()
&& !draft
.models
.iter()
.any(|declared| declared.upstream_model_id == model.upstream_model_id)
{
let mut declaration = saved_model(model)?;
super::saved_prefill::fill_unknown_registered_model(
&mut declaration,
catalog.model_metadata(),
&base_url,
&request_path,
draft.protocol,
);
draft.models.push(declaration);
}
}
// Offer current same-product declarations for explicit append. These are not
// account inventory or verified inference, and never replace saved members.
for declaration in super::saved_prefill::registered_product_candidates(
catalog.model_metadata(),
&base_url,
&request_path,
draft.protocol,
) {
if !draft
.models
.iter()
.any(|model| model.upstream_model_id == declaration.upstream_model_id)
{
draft.models.push(declaration);
}
}
draft.trusted_lineage_digest = Some(source.lineage_digest.clone());
Ok(draft)
}
fn resolve_saved_model_credential(
&self,
source: &ComputeManagementSourceV2,
) -> Result<Option<SavedCredentialMaterial>, ComputeManagementControlError> {
if matches!(
source.authentication,
GatewayAuthenticationSemanticsV1::None
) {
return Ok(None);
}
let credential = source
.credentials
.iter()
.filter(|credential| credential.enabled)
.min_by_key(|credential| credential.ordinal)
.ok_or(ComputeManagementControlError::ActionRequired)?;
let destination = source
.target
.credential_destination()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let subject = VerifiedSecretSubjectV1::from_authenticated_transport(
"hirouted",
format!("source/{}", source.source_id),
)
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let generation = credential.credential.generation();
let secret = self
.stores_lock()
.map_err(|_| ComputeManagementControlError::Unavailable)?
.secrets()
.resolve_secret(
&subject,
&credential.credential,
"provider-auth",
&destination,
generation,
)
.map_err(|error| match error.code {
PortErrorCode::Conflict => ComputeManagementControlError::Conflict,
PortErrorCode::NotFound => ComputeManagementControlError::ActionRequired,
PortErrorCode::PermissionDenied | PortErrorCode::InvalidData => {
ComputeManagementControlError::SavedSourceMismatch
}
PortErrorCode::Corrupt => ComputeManagementControlError::Corrupt,
_ => ComputeManagementControlError::Unavailable,
})?;
Ok(Some(SavedCredentialMaterial {
credential_id: credential.credential.credential_id().to_owned(),
generation,
secret,
}))
}
}
fn saved_user_draft(
request: &SavedModelConnectionCheckRequestV1,
source: &ComputeManagementSourceV2,
catalog: Option<&hiroute_integrations::TrustedReleaseCatalog>,
) -> Result<NativeModelConnectionDraftV1, ComputeManagementControlError> {
let descriptor = source
.native_recheck
.as_ref()
.ok_or(ComputeManagementControlError::RecheckContextUnavailable)?;
descriptor
.validate()
.map_err(|_| ComputeManagementControlError::Corrupt)?;
let ComputeManagementProvenanceV2::UserConfigured {
configuration_revision,
..
} = &source.provenance
else {
return Err(ComputeManagementControlError::Corrupt);
};
Ok(NativeModelConnectionDraftV1 {
display_template_id: descriptor.display_template_id.clone(),
inference_model_id: None,
candidate_ref: Some(source.last_candidate_ref.clone()),
lineage_ref: format!("saved-source/{}", source.source_id),
trusted_lineage_digest: Some(source.lineage_digest.clone()),
display_name: source.display_name.clone(),
existing_source_id: Some(source.source_id.clone()),
edit_revision: request.edit_revision,
check_id: request.check_id.clone(),
base_url: source_origin(source),
base_kind: ModelConnectionBaseKindV1::ApiRoot,
request_path_override: Some(source.target.request_path.clone()),
inventory_path_override: descriptor.inventory_path.clone(),
protocol: source.target.upstream_protocol,
protocol_profile_id: source.target.protocol_profile_id.clone(),
protocol_profile_revision: source.target.protocol_profile_revision,
protocol_header_semantics: descriptor.protocol_header_semantics.clone(),
authentication: source.authentication.clone(),
additional_native_endpoints: source.additional_native_endpoints.clone(),
provenance: NativeConnectionProvenanceInputV1::UserConfigured {
configuration_revision: *configuration_revision,
},
qualification: NativeConnectionQualificationV1 {
free_access: None,
evidence_ref: None,
},
runtime_fallback_denied_model_ids: super::runtime_fallback_denied_model_ids(catalog),
models: source
.models
.iter()
.map(saved_model)
.collect::<Result<Vec<_>, _>>()?,
})
}
fn source_origin(source: &ComputeManagementSourceV2) -> String {
let authority =
if source.target.authority.contains(':') && !source.target.authority.starts_with('[') {
format!("[{}]", source.target.authority)
} else {
source.target.authority.clone()
};
format!(
"{}://{}:{}",
source.target.scheme, authority, source.target.port
)
}
fn saved_model(
model: &hiroute_domain::ComputeManagedModelV2,
) -> Result<NativeModelDeclarationV1, ComputeManagementControlError> {
Ok(NativeModelDeclarationV1 {
upstream_model_id: model.upstream_model_id.clone(),
display_name: model.display_name.clone(),
catalog_configuration_id: model.catalog_configuration_id.clone(),
membership: match model.membership {
ComputeManagementMembershipV2::Catalog => ComputeModelMembershipV2::Catalog,
ComputeManagementMembershipV2::Observed => ComputeModelMembershipV2::Observed,
ComputeManagementMembershipV2::UserDeclared => ComputeModelMembershipV2::UserDeclared,
},
capabilities: NativeModelCapabilityDeclarationV1 {
tool: saved_fact(&model.capabilities.tool)?,
vision: saved_fact(&model.capabilities.vision)?,
streaming: saved_fact(&model.capabilities.streaming)?,
context_tokens: saved_fact(&model.capabilities.context_tokens)?,
max_output_tokens: saved_fact(&model.capabilities.max_output_tokens)?,
native_reasoning: saved_fact(&model.capabilities.native_reasoning)?,
},
})
}
fn saved_fact<T: Clone>(
fact: &hiroute_domain::ComputeManagementFactValueV2<T>,
) -> Result<NativeCandidateFactValueV1<T>, ComputeManagementControlError> {
let basis = match fact.basis {
ComputeManagementFactBasisV2::RegisteredCatalog => {
NativeCandidateFactBasisV1::RegisteredCatalog
}
ComputeManagementFactBasisV2::RuntimeFallback => {
NativeCandidateFactBasisV1::RuntimeFallback
}
ComputeManagementFactBasisV2::Observed => NativeCandidateFactBasisV1::Observed,
ComputeManagementFactBasisV2::UserDeclared => NativeCandidateFactBasisV1::UserDeclared,
ComputeManagementFactBasisV2::Unknown => NativeCandidateFactBasisV1::Unknown,
ComputeManagementFactBasisV2::ConnectorVerified => {
return Err(ComputeManagementControlError::Corrupt);
}
};
Ok(NativeCandidateFactValueV1 {
value: fact.value.clone(),
basis,
})
}
#[cfg(test)]
mod tests {
use super::*;
use std::sync::{
Arc,
atomic::{AtomicUsize, Ordering},
};
use hiroute_application::control::ComputeManagementControlPort;
use hiroute_domain::{
COMPUTE_MANAGEMENT_SOURCE_SCHEMA_V2, CanonicalDigest, ComputeManagedCapabilitiesV2,
ComputeManagedCredentialV2, ComputeManagedModelV2, ComputeManagementFactBasisV2,
ComputeManagementFactValueV2, ComputeManagementMembershipV2, ComputeManagementTargetV2,
ConnectorRegistryBundleV1, CredentialRefV1, MaterializationState, OperationId,
ReleaseFactsManifestV2, ReleaseModelDataBundleV2, SecretMutationV1, SecretStorePort,
WorkspaceId,
};
use hiroute_integrations::{
ModelConnectionProbeCredentialV1, ModelConnectionTargetInputV1,
ModelDirectoryHttpResponseV1, ModelDirectoryTransportErrorV1, ModelDirectoryTransportV1,
NormalizedModelConnectionTargetV1, normalize_model_connection_target,
};
const TEST_NAME: &str = "control::runtime::model_connections::saved::tests::registered_source_recheck_reconstructs_current_identity_after_restart";
#[derive(Clone, Default)]
struct CountingTransport(Arc<AtomicUsize>);
impl ModelDirectoryTransportV1 for CountingTransport {
fn get(
&self,
target: &NormalizedModelConnectionTargetV1,
_query: Option<&str>,
_credential: Option<ModelConnectionProbeCredentialV1<'_>>,
_timeout: std::time::Duration,
_response_limit: usize,
) -> Result<ModelDirectoryHttpResponseV1, ModelDirectoryTransportErrorV1> {
assert_eq!(target.candidate_target.authority, "dashscope.aliyuncs.com");
assert_eq!(target.inventory_path.as_deref(), Some("/api/v1/models"));
self.0.fetch_add(1, Ordering::SeqCst);
Ok(ModelDirectoryHttpResponseV1 {
status: 200,
body: br#"{"data":[]}"#.to_vec(),
truncated: false,
})
}
}
fn registered_request(
catalog: &hiroute_integrations::TrustedReleaseCatalog,
) -> RegisteredModelConnectionCheckRequestV1 {
let provenance = catalog.compute_catalog_provenance().unwrap();
RegisteredModelConnectionCheckRequestV1 {
inference_model_id: None,
models: Vec::new(),
connection_option_id: "bailian.payg.cn.v1".into(),
display_name: Some("团队百炼 · 生产".into()),
expected_catalog: ComputeCatalogProvenanceViewV1 {
product_release: provenance.product_release,
catalog_binding_id: provenance.catalog_binding_id,
release_sequence: provenance.release_sequence,
connector_registry_digest: provenance.connector_registry_digest,
model_data_digest: provenance.model_data_digest,
cross_reference_digest: provenance.cross_reference_digest,
},
candidate_ref: Some("candidate/native/bailian-saved".into()),
lineage_ref: "lineage/bailian-saved".into(),
edit_revision: 1,
check_id: "check/bailian-saved/1".into(),
input_candidate: ComputeCandidateRefV2 {
candidate_ref: "candidate/native/bailian-saved".into(),
candidate_revision: 3,
},
existing_source_id: None,
expected_source_revision: None,
}
}
fn upgraded_catalog_with_new_preferred_bailian_endpoint()
-> hiroute_integrations::TrustedReleaseCatalog {
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("../..");
let mut registry: ConnectorRegistryBundleV1 = serde_json::from_slice(
&std::fs::read(
root.join("assets/release-facts/current/bundle/connector-registry.json"),
)
.unwrap(),
)
.unwrap();
let mut release: ReleaseModelDataBundleV2 = serde_json::from_slice(
&std::fs::read(root.join("assets/release-facts/current/bundle/model-data.json"))
.unwrap(),
)
.unwrap();
let mut manifest: ReleaseFactsManifestV2 = serde_json::from_slice(
&std::fs::read(root.join("assets/release-facts/current/bundle/manifest.json")).unwrap(),
)
.unwrap();
let profile = registry
.endpoint_profiles
.iter_mut()
.find(|profile| profile.endpoint_profile_id == "endpoint.bailian.payg.cn.v1")
.unwrap();
let current = profile
.protocol_endpoints
.iter_mut()
.find(|endpoint| endpoint.protocol_endpoint_id == "endpoint.bailian.payg.cn.v1.chat")
.unwrap();
current.stable_preference = 10;
let mut preferred = current.clone();
preferred.protocol_endpoint_id = "endpoint.bailian.payg.cn.v1.chat-preferred".into();
preferred.base_url = "https://preferred-dashscope.example.test".into();
preferred.stable_preference = 0;
profile.protocol_endpoints.push(preferred);
let old_capabilities = release
.data
.model_endpoint_capabilities
.iter()
.filter(|capability| {
capability.protocol_endpoint_id == "endpoint.bailian.payg.cn.v1.chat"
})
.cloned()
.collect::<Vec<_>>();
for mut capability in old_capabilities {
capability.capability_id.push_str(".preferred");
capability.protocol_endpoint_id = "endpoint.bailian.payg.cn.v1.chat-preferred".into();
release.data.model_endpoint_capabilities.push(capability);
}
manifest.catalog_id = "hiroute-mvp-current-upgraded".into();
manifest.sequence += 1;
let registry_bytes = serde_json::to_vec(®istry).unwrap();
let model_data_bytes = serde_json::to_vec(&release).unwrap();
manifest.connector_registry_digest = CanonicalDigest::of_bytes(®istry_bytes);
manifest.model_data_digest = CanonicalDigest::of_bytes(&model_data_bytes);
manifest.cross_reference_digest = release.cross_reference_digest(®istry).unwrap();
let manifest_bytes = serde_json::to_vec(&manifest).unwrap();
let catalog = hiroute_integrations::TrustedReleaseCatalog::load_release_facts(
&manifest_bytes,
®istry_bytes,
&model_data_bytes,
)
.unwrap();
let mut snapshot = crate::release_catalog::current_fixture_catalog().official_snapshot();
snapshot.data.model_endpoint_capabilities = release.data.model_endpoint_capabilities;
snapshot.data_revision += 1;
snapshot.data_digest = CanonicalDigest::of(&snapshot.data).unwrap();
catalog.with_embedded_official_data(snapshot).unwrap()
}
fn registered_fact<T: Clone>(
fact: &NativeCandidateFactValueV1<T>,
) -> ComputeManagementFactValueV2<T> {
assert_eq!(fact.basis, NativeCandidateFactBasisV1::RegisteredCatalog);
ComputeManagementFactValueV2 {
value: fact.value.clone(),
basis: ComputeManagementFactBasisV2::RegisteredCatalog,
}
}
fn source_from_registered_draft(
draft: &NativeModelConnectionDraftV1,
) -> ComputeManagementSourceV2 {
let normalized = normalize_model_connection_target(ModelConnectionTargetInputV1 {
base_url: &draft.base_url,
base_kind: draft.base_kind,
protocol: draft.protocol,
request_path_override: draft.request_path_override.as_deref(),
inventory_path_override: draft.inventory_path_override.as_deref(),
protocol_profile_id: &draft.protocol_profile_id,
protocol_profile_revision: draft.protocol_profile_revision,
protocol_header_semantics: &draft.protocol_header_semantics,
authentication: &draft.authentication,
})
.unwrap();
let NativeConnectionProvenanceInputV1::Registered {
connection_option_id,
registry_version,
catalog_digest,
} = &draft.provenance
else {
panic!("fixture draft must remain registered");
};
let model = &draft.models[0];
let source = ComputeManagementSourceV2 {
schema: COMPUTE_MANAGEMENT_SOURCE_SCHEMA_V2.into(),
source_id: "source/registered-bailian".into(),
revision: 5,
lineage_digest: CanonicalDigest::of_bytes(b"saved-registered-lineage"),
display_name: draft.display_name.clone(),
provenance: ComputeManagementProvenanceV2::Registered {
connection_option_id: connection_option_id.clone(),
registry_version: registry_version.clone(),
catalog_digest: catalog_digest.clone(),
},
target: ComputeManagementTargetV2 {
scheme: normalized.candidate_target.scheme,
authority: normalized.candidate_target.authority,
port: normalized.candidate_target.port,
request_path: normalized.candidate_target.request_path,
upstream_protocol: normalized.candidate_target.upstream_protocol,
protocol_profile_id: normalized.candidate_target.protocol_profile_id,
protocol_profile_revision: normalized.candidate_target.protocol_profile_revision,
},
authentication: draft.authentication.clone(),
state: MaterializationState::NeedsCredential,
models: vec![ComputeManagedModelV2 {
model_ref: "model/registered-bailian".into(),
binding_id: "binding/registered-bailian".into(),
revision: 1,
upstream_model_id: model.upstream_model_id.clone(),
display_name: model.display_name.clone(),
catalog_configuration_id: model.catalog_configuration_id.clone(),
membership: ComputeManagementMembershipV2::Catalog,
execution_eligible: true,
capabilities: ComputeManagedCapabilitiesV2 {
tool: registered_fact(&model.capabilities.tool),
vision: registered_fact(&model.capabilities.vision),
streaming: registered_fact(&model.capabilities.streaming),
context_tokens: registered_fact(&model.capabilities.context_tokens),
max_output_tokens: registered_fact(&model.capabilities.max_output_tokens),
native_reasoning: registered_fact(&model.capabilities.native_reasoning),
},
capability_evidence_digest: CanonicalDigest::of_bytes(
b"saved-registered-capabilities",
),
}],
native_recheck: Some(hiroute_domain::ComputeNativeRecheckDescriptorV2 {
display_template_id: None,
inventory_path: draft.inventory_path_override.clone(),
protocol_header_semantics: draft.protocol_header_semantics.clone(),
}),
additional_native_endpoints: Vec::new(),
credentials: Vec::new(),
validation: None,
last_candidate_ref: "candidate/native/bailian-saved".into(),
last_candidate_revision: 3,
};
source.validate().unwrap();
source
}
fn attach_saved_credential(
runtime: &super::super::super::ProductionControlRuntime,
source: &mut ComputeManagementSourceV2,
) {
let destination = source.target.credential_destination().unwrap();
let key_id = "credential/registered-bailian-primary";
let secret = ProtectedSecret::new(b"saved-registered-test-secret".to_vec()).unwrap();
let pending = CredentialRefV1::new(
key_id,
format!("source/{}", source.source_id),
"hirouted",
"provider-auth",
[destination.clone()],
0,
)
.unwrap();
let stores = runtime.adapter.stores_lock().unwrap();
let fingerprint = stores.secrets().fingerprint(&secret).unwrap();
let mutation = SecretMutationV1::upsert(
pending,
0,
"registered-bailian-primary",
Some(fingerprint.clone()),
)
.unwrap();
let effect = stores
.secrets()
.apply_secret(
&OperationId::parse("op_60606060606060606060606060606060").unwrap(),
&mutation,
Some(&secret),
)
.unwrap();
stores.secrets().activate_secret(&effect).unwrap();
source.credentials = vec![ComputeManagedCredentialV2 {
key_id: key_id.into(),
credential: CredentialRefV1::new(
key_id,
format!("source/{}", source.source_id),
"hirouted",
"provider-auth",
[destination],
1,
)
.unwrap(),
fingerprint,
ordinal: 0,
enabled: true,
}];
source.state = MaterializationState::Ready;
source.validate().unwrap();
}
fn user_fact<T>(value: T) -> ComputeManagementFactValueV2<T> {
ComputeManagementFactValueV2 {
value: Some(value),
basis: ComputeManagementFactBasisV2::UserDeclared,
}
}
fn user_source() -> ComputeManagementSourceV2 {
let source = ComputeManagementSourceV2 {
schema: COMPUTE_MANAGEMENT_SOURCE_SCHEMA_V2.into(),
source_id: "source/user-configured".into(),
revision: 4,
lineage_digest: CanonicalDigest::of_bytes(b"saved-user-lineage"),
display_name: "Saved custom API".into(),
provenance: ComputeManagementProvenanceV2::UserConfigured {
configuration_revision: 6,
evidence_digest: CanonicalDigest::of_bytes(b"saved-user-evidence"),
},
target: ComputeManagementTargetV2 {
scheme: "http".into(),
authority: "127.0.0.1".into(),
port: 8_812,
request_path: "/custom/responses".into(),
upstream_protocol: hiroute_domain::UpstreamProtocol::Responses,
protocol_profile_id: "profile/custom-responses".into(),
protocol_profile_revision: 3,
},
authentication: GatewayAuthenticationSemanticsV1::None,
state: MaterializationState::Ready,
models: vec![ComputeManagedModelV2 {
model_ref: "model/custom".into(),
binding_id: "binding/custom".into(),
revision: 2,
upstream_model_id: "custom-model-v2".into(),
display_name: "Custom Model V2".into(),
catalog_configuration_id: None,
membership: ComputeManagementMembershipV2::UserDeclared,
execution_eligible: true,
capabilities: ComputeManagedCapabilitiesV2 {
tool: user_fact(false),
vision: user_fact(true),
streaming: user_fact(true),
context_tokens: user_fact(65_536),
max_output_tokens: user_fact(8_192),
native_reasoning: user_fact(
hiroute_domain::NativeReasoningCapabilityV1::Fixed {
profile: "provider-default".into(),
},
),
},
capability_evidence_digest: CanonicalDigest::of_bytes(b"saved-user-capabilities"),
}],
native_recheck: Some(hiroute_domain::ComputeNativeRecheckDescriptorV2 {
display_template_id: None,
inventory_path: Some("/custom/models".into()),
protocol_header_semantics: hiroute_domain::GatewayHeaderSemanticsV1 {
content_type: "application/json".into(),
required_headers: vec![("anthropic-version".into(), "2023-06-01".into())],
forbidden_forward_headers: vec!["authorization".into()],
},
}),
additional_native_endpoints: Vec::new(),
credentials: Vec::new(),
validation: None,
last_candidate_ref: "candidate/native/custom-saved".into(),
last_candidate_revision: 8,
};
source.validate().unwrap();
source
}
#[test]
fn user_configured_recheck_restores_exact_saved_target_and_context() {
let source = user_source();
let request = SavedModelConnectionCheckRequestV1 {
source_id: source.source_id.clone(),
expected_source_revision: source.revision,
candidate_ref: Some(source.last_candidate_ref.clone()),
edit_revision: 11,
check_id: "check/custom-saved/11".into(),
};
let draft = saved_user_draft(&request, &source, None).unwrap();
assert_eq!(draft.base_url, "http://127.0.0.1:8812");
assert_eq!(
draft.request_path_override.as_deref(),
Some("/custom/responses")
);
assert_eq!(
draft.inventory_path_override.as_deref(),
Some("/custom/models")
);
assert_eq!(
draft.protocol_header_semantics,
source
.native_recheck
.as_ref()
.unwrap()
.protocol_header_semantics
);
assert_eq!(draft.models.len(), 1);
assert_eq!(draft.models[0].upstream_model_id, "custom-model-v2");
assert_eq!(
draft.trusted_lineage_digest,
Some(source.lineage_digest.clone())
);
assert_eq!(draft.existing_source_id, Some(source.source_id.clone()));
let mut legacy = source;
legacy.native_recheck = None;
legacy.validate().unwrap();
assert!(matches!(
saved_user_draft(&request, &legacy, None),
Err(ComputeManagementControlError::RecheckContextUnavailable)
));
}
#[test]
fn registered_source_recheck_reconstructs_current_identity_after_restart() {
if crate::test_support::isolated_agent_home(TEST_NAME) {
return;
}
let root = tempfile::tempdir().unwrap();
let catalog = crate::release_catalog::current_fixture_catalog();
let runtime = super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
catalog.clone(),
)
.unwrap();
let registered = registered_request(&catalog);
let initial = runtime
.adapter
.trusted_registered_draft(®istered)
.unwrap();
let source = source_from_registered_draft(&initial);
let saved = SavedModelConnectionCheckRequestV1 {
source_id: source.source_id.clone(),
expected_source_revision: source.revision,
candidate_ref: Some(source.last_candidate_ref.clone()),
edit_revision: 7,
check_id: "check/bailian-saved/recheck".into(),
};
let candidate = ComputeCandidateRefV2 {
candidate_ref: source.last_candidate_ref.clone(),
candidate_revision: source.last_candidate_revision,
};
let before_restart = runtime
.adapter
.saved_registered_draft(&saved, &source, &candidate)
.unwrap();
assert_eq!(before_restart.display_name, "团队百炼 · 生产");
assert_eq!(
before_restart.trusted_lineage_digest,
Some(source.lineage_digest.clone())
);
assert_eq!(
source
.native_recheck
.as_ref()
.unwrap()
.inventory_path
.as_deref(),
Some("/api/v1/models")
);
assert!(matches!(
&before_restart.provenance,
NativeConnectionProvenanceInputV1::Registered { .. }
));
drop(runtime);
let reopened = super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
catalog,
)
.unwrap();
let after_restart = reopened
.adapter
.saved_registered_draft(&saved, &source, &candidate)
.unwrap();
assert_eq!(after_restart.display_name, before_restart.display_name);
assert_eq!(after_restart.base_url, before_restart.base_url);
assert_eq!(after_restart.models, before_restart.models);
assert_eq!(
after_restart.existing_source_id,
Some(source.source_id.clone())
);
let mut cross_source = source.clone();
cross_source.target.request_path = "/v1/substituted".into();
cross_source.validate().unwrap();
assert!(matches!(
reopened
.adapter
.saved_registered_draft(&saved, &cross_source, &candidate),
Err(ComputeManagementControlError::SavedSourceMismatch)
));
let mut catalog_a_source = source;
let ComputeManagementProvenanceV2::Registered {
registry_version,
catalog_digest,
..
} = &mut catalog_a_source.provenance
else {
unreachable!();
};
registry_version.push_str("-catalog-a");
*catalog_digest = CanonicalDigest::of_bytes(b"catalog-a");
catalog_a_source.validate().unwrap();
let upgraded = reopened
.adapter
.saved_registered_draft(&saved, &catalog_a_source, &candidate)
.unwrap();
assert_eq!(upgraded.display_name, before_restart.display_name);
assert_eq!(upgraded.base_url, before_restart.base_url);
assert!(matches!(
upgraded.provenance,
NativeConnectionProvenanceInputV1::Registered {
registry_version,
..
} if registry_version == reopened
.adapter
.current_catalog()
.unwrap()
.registry()
.registry_version
));
}
#[test]
fn saved_registered_recheck_prefills_only_unknown_product_capabilities() {
if crate::test_support::isolated_agent_home(
"control::runtime::model_connections::saved::tests::saved_registered_recheck_prefills_only_unknown_product_capabilities",
) {
return;
}
let root = tempfile::tempdir().unwrap();
let catalog = crate::release_catalog::current_fixture_catalog();
let runtime = super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
catalog.clone(),
)
.unwrap();
let mut source = source_from_registered_draft(
&runtime
.adapter
.trusted_registered_draft(®istered_request(&catalog))
.unwrap(),
);
fn unknown<T>() -> ComputeManagementFactValueV2<T> {
ComputeManagementFactValueV2 {
value: None,
basis: ComputeManagementFactBasisV2::Unknown,
}
}
for (index, id) in [
"deepseek-v4-flash",
"deepseek-v4.1-flash",
"my-private-model",
]
.into_iter()
.enumerate()
{
let mut model = source.models[0].clone();
model.model_ref = format!("model/saved-unknown-{index}");
model.binding_id = format!("binding/saved-unknown-{index}");
model.upstream_model_id = id.into();
model.display_name = id.into();
model.catalog_configuration_id = None;
model.membership = ComputeManagementMembershipV2::UserDeclared;
model.capabilities = ComputeManagedCapabilitiesV2 {
tool: unknown(),
vision: unknown(),
streaming: unknown(),
context_tokens: unknown(),
max_output_tokens: unknown(),
native_reasoning: unknown(),
};
if id == "deepseek-v4-flash" {
model.capabilities.tool = ComputeManagementFactValueV2 {
value: Some(false),
basis: ComputeManagementFactBasisV2::UserDeclared,
};
}
source.models.push(model);
}
source.validate().unwrap();
let original_endpoints = source.additional_native_endpoints.clone();
let original_credentials = source.credentials.clone();
let request = SavedModelConnectionCheckRequestV1 {
source_id: source.source_id.clone(),
expected_source_revision: source.revision,
candidate_ref: Some(source.last_candidate_ref.clone()),
edit_revision: 7,
check_id: "check/bailian-saved/unknown-prefill".into(),
};
let candidate = ComputeCandidateRefV2 {
candidate_ref: source.last_candidate_ref.clone(),
candidate_revision: source.last_candidate_revision,
};
let draft = runtime
.adapter
.saved_registered_draft(&request, &source, &candidate)
.unwrap();
assert_eq!(draft.additional_native_endpoints, original_endpoints);
assert_eq!(source.credentials, original_credentials);
assert!(
draft.models.iter().any(|model| !source
.models
.iter()
.any(|saved| saved.upstream_model_id == model.upstream_model_id)),
"saved-source check must retain unselected product candidates for append"
);
for (id, vision) in [("deepseek-v4-flash", false), ("deepseek-v4.1-flash", true)] {
let model = draft
.models
.iter()
.find(|model| model.upstream_model_id == id)
.unwrap();
assert_eq!(model.capabilities.vision.value, Some(vision), "{id}");
assert_eq!(
model.capabilities.vision.basis,
NativeCandidateFactBasisV1::UserDeclared
);
assert_eq!(model.catalog_configuration_id, None);
}
let v4 = draft
.models
.iter()
.find(|model| model.upstream_model_id == "deepseek-v4-flash")
.unwrap();
assert_eq!(v4.capabilities.tool.value, Some(false));
let private = draft
.models
.iter()
.find(|model| model.upstream_model_id == "my-private-model")
.unwrap();
assert_eq!(private.capabilities.context_tokens.value, Some(200_000));
assert_eq!(private.capabilities.max_output_tokens.value, Some(32_768));
assert_eq!(private.capabilities.vision.value, Some(false));
assert_eq!(private.capabilities.tool.value, Some(true));
}
#[test]
fn saved_registered_recheck_keeps_exact_endpoint_when_upgrade_adds_a_new_preference() {
if crate::test_support::isolated_agent_home(
"control::runtime::model_connections::saved::tests::saved_registered_recheck_keeps_exact_endpoint_when_upgrade_adds_a_new_preference",
) {
return;
}
let root = tempfile::tempdir().unwrap();
let initial_catalog = crate::release_catalog::current_fixture_catalog();
let initial_runtime =
super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
initial_catalog.clone(),
)
.unwrap();
let source = source_from_registered_draft(
&initial_runtime
.adapter
.trusted_registered_draft(®istered_request(&initial_catalog))
.unwrap(),
);
drop(initial_runtime);
let upgraded_catalog = upgraded_catalog_with_new_preferred_bailian_endpoint();
let upgraded_runtime =
super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
upgraded_catalog.clone(),
)
.unwrap();
let new_default = upgraded_runtime
.adapter
.trusted_registered_draft(®istered_request(&upgraded_catalog))
.unwrap();
assert_eq!(
new_default.base_url,
"https://preferred-dashscope.example.test"
);
let request = SavedModelConnectionCheckRequestV1 {
source_id: source.source_id.clone(),
expected_source_revision: source.revision,
candidate_ref: Some(source.last_candidate_ref.clone()),
edit_revision: 8,
check_id: "check/bailian-saved/upgraded".into(),
};
let candidate = ComputeCandidateRefV2 {
candidate_ref: source.last_candidate_ref.clone(),
candidate_revision: source.last_candidate_revision,
};
let recheck = upgraded_runtime
.adapter
.saved_registered_draft(&request, &source, &candidate)
.unwrap();
assert_eq!(recheck.base_url, "https://dashscope.aliyuncs.com");
assert_eq!(
recheck.request_path_override.as_deref(),
Some("/compatible-mode/v1/chat/completions")
);
assert_eq!(
recheck.inventory_path_override.as_deref(),
Some("/api/v1/models")
);
}
#[test]
fn saved_registered_recheck_rejects_changed_inventory_or_static_headers() {
if crate::test_support::isolated_agent_home(
"control::runtime::model_connections::saved::tests::saved_registered_recheck_rejects_changed_inventory_or_static_headers",
) {
return;
}
let root = tempfile::tempdir().unwrap();
let catalog = crate::release_catalog::current_fixture_catalog();
let runtime = super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
catalog.clone(),
)
.unwrap();
let source = source_from_registered_draft(
&runtime
.adapter
.trusted_registered_draft(®istered_request(&catalog))
.unwrap(),
);
let request = SavedModelConnectionCheckRequestV1 {
source_id: source.source_id.clone(),
expected_source_revision: source.revision,
candidate_ref: Some(source.last_candidate_ref.clone()),
edit_revision: 9,
check_id: "check/bailian-saved/incompatible".into(),
};
let candidate = ComputeCandidateRefV2 {
candidate_ref: source.last_candidate_ref.clone(),
candidate_revision: source.last_candidate_revision,
};
let mut changed_inventory = source.clone();
changed_inventory
.native_recheck
.as_mut()
.unwrap()
.inventory_path = Some("/api/v2/models".into());
changed_inventory.validate().unwrap();
assert!(matches!(
runtime
.adapter
.saved_registered_draft(&request, &changed_inventory, &candidate),
Err(ComputeManagementControlError::SavedSourceMismatch)
));
let mut changed_headers = source;
changed_headers
.native_recheck
.as_mut()
.unwrap()
.protocol_header_semantics
.required_headers
.push(("anthropic-version".into(), "2023-06-01".into()));
changed_headers.validate().unwrap();
assert!(matches!(
runtime
.adapter
.saved_registered_draft(&request, &changed_headers, &candidate),
Err(ComputeManagementControlError::SavedSourceMismatch)
));
}
#[test]
fn saved_registered_recheck_fences_descriptors_then_keeps_endpoint_after_upgrade() {
if crate::test_support::isolated_agent_home(
"control::runtime::model_connections::saved::tests::saved_registered_recheck_fences_descriptors_then_keeps_endpoint_after_upgrade",
) {
return;
}
let root = tempfile::tempdir().unwrap();
let storage = root.path().join("storage");
let catalog = crate::release_catalog::current_fixture_catalog();
let transport = Arc::new(CountingTransport::default());
let calls = Arc::clone(&transport.0);
let runtime =
super::super::super::ProductionControlRuntime::open_with_release_catalog_and_model_transport(
&storage,
catalog.clone(),
transport.clone(),
)
.unwrap();
let mut source = source_from_registered_draft(
&runtime
.adapter
.trusted_registered_draft(®istered_request(&catalog))
.unwrap(),
);
attach_saved_credential(&runtime, &mut source);
source.native_recheck.as_mut().unwrap().inventory_path = Some("/api/v2/models".into());
source.validate().unwrap();
let connection = rusqlite::Connection::open(storage.join("live/control.db")).unwrap();
let owner = "op_50505050505050505050505050505050";
let owner_digest = CanonicalDigest::of_bytes(b"descriptor-mismatch-owner");
connection
.execute(
"INSERT INTO operations(
operation_id,workspace_id,principal,operation_kind,idempotency_key,
request_digest,accepted_change_digest,state,generation,operation_json,
created_at,updated_at
) VALUES (?1,?2,'desktop','fixture.management','descriptor-mismatch',
?3,?3,'succeeded',0,'{}',0,0)",
rusqlite::params![
owner,
WorkspaceId::default().as_str(),
owner_digest.as_str()
],
)
.unwrap();
connection
.execute(
"INSERT INTO compute_management_sources(
workspace_id,source_id,lineage_digest,revision,source_json,
owner_operation_id,updated_at
) VALUES (?1,?2,?3,?4,?5,?6,unixepoch())",
rusqlite::params![
WorkspaceId::default().as_str(),
source.source_id,
source.lineage_digest.as_str(),
source.revision,
serde_json::to_string(&source).unwrap(),
owner,
],
)
.unwrap();
let request = SavedModelConnectionCheckRequestV1 {
source_id: source.source_id.clone(),
expected_source_revision: source.revision,
candidate_ref: Some(source.last_candidate_ref.clone()),
edit_revision: 10,
check_id: "check/bailian-saved/pre-network".into(),
};
assert!(matches!(
ComputeManagementControlPort::check_saved_model_connection(
runtime.adapter.as_ref(),
request.clone()
),
Err(ComputeManagementControlError::SavedSourceMismatch)
));
assert_eq!(calls.load(Ordering::SeqCst), 0);
let descriptor = source.native_recheck.as_mut().unwrap();
descriptor.inventory_path = Some("/api/v1/models".into());
descriptor
.protocol_header_semantics
.required_headers
.push(("anthropic-version".into(), "2023-06-01".into()));
source.validate().unwrap();
connection
.execute(
"UPDATE compute_management_sources SET source_json=?1 WHERE source_id=?2",
rusqlite::params![serde_json::to_string(&source).unwrap(), source.source_id],
)
.unwrap();
let mut header_request = request.clone();
header_request.edit_revision += 1;
header_request.check_id = "check/bailian-saved/pre-network-header".into();
assert!(matches!(
ComputeManagementControlPort::check_saved_model_connection(
runtime.adapter.as_ref(),
header_request
),
Err(ComputeManagementControlError::SavedSourceMismatch)
));
assert_eq!(calls.load(Ordering::SeqCst), 0);
source
.native_recheck
.as_mut()
.unwrap()
.protocol_header_semantics
.required_headers
.clear();
source.validate().unwrap();
connection
.execute(
"UPDATE compute_management_sources SET source_json=?1 WHERE source_id=?2",
rusqlite::params![serde_json::to_string(&source).unwrap(), source.source_id],
)
.unwrap();
drop(connection);
drop(runtime);
let upgraded =
super::super::super::ProductionControlRuntime::open_with_release_catalog_and_model_transport(
&storage,
upgraded_catalog_with_new_preferred_bailian_endpoint(),
transport,
)
.unwrap();
let checked = ComputeManagementControlPort::check_saved_model_connection(
upgraded.adapter.as_ref(),
SavedModelConnectionCheckRequestV1 {
edit_revision: 12,
check_id: "check/bailian-saved/upgraded-network".into(),
..request
},
)
.unwrap();
assert_eq!(checked.target.authority, "dashscope.aliyuncs.com");
assert_eq!(
checked.target.request_path,
"/compatible-mode/v1/chat/completions"
);
assert_eq!(calls.load(Ordering::SeqCst), 1);
}
#[test]
fn saved_embedded_fact_changes_do_not_block_rename_or_removing_another_member() {
use hiroute_application_api::*;
const NAME: &str = "control::runtime::model_connections::saved::tests::saved_embedded_fact_changes_do_not_block_rename_or_removing_another_member";
if crate::test_support::isolated_agent_home(NAME) {
return;
}
let root = tempfile::tempdir().unwrap();
let catalog = crate::release_catalog::current_fixture_catalog();
let runtime = super::super::super::ProductionControlRuntime::open_with_release_catalog(
root.path(),
catalog.clone(),
)
.unwrap();
let mut source = source_from_registered_draft(
&runtime
.adapter
.trusted_registered_draft(®istered_request(&catalog))
.unwrap(),
);
attach_saved_credential(&runtime, &mut source);
source.models[0].capabilities.context_tokens.value = Some(123_456);
let mut other = source.models[0].clone();
other.model_ref = "model/second-saved-member".into();
other.binding_id = "binding/second-saved-member".into();
other.upstream_model_id = "second-native-model".into();
other.catalog_configuration_id = None;
source.models.push(other.clone());
source.validate().unwrap();
let connection = rusqlite::Connection::open(root.path().join("live/control.db")).unwrap();
let digest = CanonicalDigest::of_bytes(b"saved-lifecycle-owner");
let owner = "op_51515151515151515151515151515151";
connection.execute("INSERT INTO operations(operation_id,workspace_id,principal,operation_kind,idempotency_key,request_digest,accepted_change_digest,state,generation,operation_json,created_at,updated_at)
VALUES(?1,?2,'desktop','fixture.management','saved-lifecycle',?3,?3,'succeeded',0,'{}',0,0)", rusqlite::params![owner,WorkspaceId::default().as_str(),digest.as_str()]).unwrap();
connection.execute("INSERT INTO compute_management_sources(workspace_id,source_id,lineage_digest,revision,source_json,owner_operation_id,updated_at)
VALUES(?1,?2,?3,?4,?5,?6,0)",rusqlite::params![WorkspaceId::default().as_str(),source.source_id,source.lineage_digest.as_str(),source.revision,serde_json::to_string(&source).unwrap(),owner]).unwrap();
drop(connection);
for (edit, selected_model_refs) in [
(
ComputeManagementEditV1::Rename {
display_name: "Renamed saved connection".into(),
},
vec![],
),
(
ComputeManagementEditV1::RemoveModels,
vec![other.model_ref.clone()],
),
] {
let snapshot = runtime
.adapter
.compute_management_snapshot(&ComputeManagementQueryV2::default())
.unwrap();
let change = ComputeManagementChangeV2 {
schema: COMPUTE_MANAGEMENT_CHANGE_SCHEMA_V2.into(),
subject: ComputeManagementSubjectV2::SavedSource {
source_id: source.source_id.clone(),
},
expected_revisions: snapshot.revisions,
selected_model_refs,
intent: ComputeManagementIntentV2::SaveReady,
edit: Some(edit),
key_edits: vec![],
validation: None,
};
assert!(
runtime.adapter.preview_compute_save(change).is_ok(),
"unchanged embedded members retain their saved facts"
);
}
}
}