Skip to content

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.

41.1 KB
Raw Blame
use hiroute_application::compiler::{
    AgentPlanCompilationFactsV1, CandidateCompilationFactV1, CandidateFactScope,
    FreeCandidateEvidenceV1, OrderingPriceFactV1,
};
use hiroute_application::control::{
    ControlReadError, RoutingCompilationSnapshotV1, RoutingFactsPort,
};
use hiroute_domain::{
    AGENT_PLAN_COMPILER_REVISION_V1, AGENT_PLAN_FACTS_SCHEMA_V1, AgentPlanFactRefsV1,
    AuthenticationKind, CanonicalDigest, ComputeManagementRepositoryPort, ControlRepositoryPort,
    MaterializationState, PriceTrackingMode, PublicationRepositoryPort, SourceOrigin, WorkspaceId,
};

use super::LocalControlAdapter;
use hiroute_application_api::PlanCandidateUnavailableReasonV1 as UnavailableReason;

#[path = "routing_candidates.rs"]
mod candidates;
use candidates::CandidateDiagnostics;

impl RoutingFactsPort for LocalControlAdapter {
    fn try_active_publication(
        &self,
        workspace: &WorkspaceId,
        deadline: std::time::Instant,
    ) -> Result<
        hiroute_application::control::ControlReadAttempt<
            Option<hiroute_domain::GatewayPublicationV1>,
        >,
        ControlReadError,
    > {
        use hiroute_application::control::ControlReadAttempt;
        let stores = match self.stores.try_lock() {
            Ok(stores) => stores,
            Err(std::sync::TryLockError::WouldBlock) => return Ok(ControlReadAttempt::Busy),
            Err(std::sync::TryLockError::Poisoned(_)) => return Err(ControlReadError::Unavailable),
        };
        if std::time::Instant::now() >= deadline {
            return Err(ControlReadError::Unavailable);
        }
        let publication = stores
            .control()
            .active_publication(workspace)
            .map_err(super::map_port)?;
        let verified = publication
            .as_ref()
            .map(hiroute_domain::PublicationRecordV1::verify)
            .transpose()
            .map_err(|_| ControlReadError::Corrupt)?;
        Ok(ControlReadAttempt::Ready(verified))
    }

    fn publication_checkpoint_snapshot(
        &self,
        workspace: &WorkspaceId,
    ) -> Result<
        (
            hiroute_domain::PublicationRecordV1,
            hiroute_domain::RevisionSetV1,
        ),
        ControlReadError,
    > {
        let (record, revisions) = {
            let stores = self.stores_lock().map_err(super::map_port)?;
            let control = stores.control();
            control
                .require_plan_version_recovery_ready(workspace)
                .map_err(|_| ControlReadError::Unavailable)?;
            if control
                .prepared_publication(workspace)
                .map_err(super::map_port)?
                .is_some()
            {
                return Err(ControlReadError::Unavailable);
            }
            (
                control
                    .active_publication(workspace)
                    .map_err(super::map_port)?
                    .ok_or(ControlReadError::Unavailable)?,
                control
                    .current_revisions(workspace)
                    .map_err(super::map_port)?,
            )
        };
        record
            .verify_current()
            .map_err(|_| ControlReadError::Corrupt)?;
        if !self
            .publication_is_installed(&record)
            .map_err(super::map_port)?
        {
            return Err(ControlReadError::Unavailable);
        }
        let stores = self.stores_lock().map_err(super::map_port)?;
        stores
            .control()
            .require_plan_version_recovery_ready(workspace)
            .map_err(|_| ControlReadError::Unavailable)?;
        if stores
            .control()
            .prepared_publication(workspace)
            .map_err(super::map_port)?
            .is_some()
        {
            return Err(ControlReadError::SnapshotChanged);
        }
        if stores
            .control()
            .active_publication(workspace)
            .map_err(super::map_port)?
            .as_ref()
            != Some(&record)
            || stores
                .control()
                .current_revisions(workspace)
                .map_err(super::map_port)?
                != revisions
        {
            return Err(ControlReadError::SnapshotChanged);
        }
        Ok((record, revisions))
    }
    fn plan_lifecycle_snapshot(
        &self,
        workspace: &WorkspaceId,
        change: &hiroute_application_api::PlanLifecycleChangeV1,
    ) -> Result<hiroute_application::routing::PlanLifecycleSnapshotV1, ControlReadError> {
        use hiroute_domain::{AgentPlanReferenceKind, AgentPlanReferenceReadPort};
        // All Plan, Agent and retention writers share this store owner. Apply repeats this
        // read under the existing writer/admission barrier before installing the publication.
        let stores = self.stores_lock().map_err(super::map_port)?;
        let control = stores.control();
        let head = control
            .plan_head(workspace, &change.plan_id)
            .map_err(|_| ControlReadError::Corrupt)?
            .ok_or(ControlReadError::NotFound)?;
        let version = control
            .lookup_exact_plan_version(&head.reference)
            .map_err(|_| ControlReadError::Corrupt)?;
        let publication = control
            .active_publication(workspace)
            .map_err(super::map_port)?
            .ok_or(ControlReadError::Unavailable)?
            .verify()
            .map_err(|_| ControlReadError::Corrupt)?;
        let references = control
            .agent_plan_references(workspace, &change.plan_id)
            .map_err(super::map_port)?;
        let has_version_holds = control
            .plan_has_retained_versions(workspace, &change.plan_id)
            .map_err(|_| ControlReadError::Unavailable)?;
        Ok(hiroute_application::routing::PlanLifecycleSnapshotV1 {
            head,
            version,
            publication,
            expected_revisions: control
                .current_revisions(workspace)
                .map_err(super::map_port)?,
            references_digest: references.facts_digest,
            has_agent_references: !references.references.is_empty(),
            has_default_model_reference: references
                .references
                .iter()
                .any(|reference| reference.kind == AgentPlanReferenceKind::DefaultModel),
            has_version_holds,
        })
    }

    fn decision_services(
        &self,
        workspace: &WorkspaceId,
    ) -> Result<Vec<hiroute_domain::DecisionServiceV1>, ControlReadError> {
        self.stores_lock()
            .map_err(super::map_port)?
            .control()
            .decision_services(workspace)
            .map_err(super::map_port)
    }
    fn decision_service(
        &self,
        workspace: &WorkspaceId,
        id: &str,
        revision: u64,
    ) -> Result<Option<hiroute_domain::DecisionServiceV1>, ControlReadError> {
        self.stores_lock()
            .map_err(super::map_port)?
            .control()
            .decision_service(workspace, id, revision)
            .map_err(super::map_port)
    }
    fn claude_client_capability_preview(
        &self,
        plan: &hiroute_domain::CompiledAgentPlanV1,
    ) -> Result<hiroute_application_api::ClaudeClientCapabilityPreviewV1, ControlReadError> {
        Ok(hiroute_integrations::agents::claude_plan_capability_preview(plan))
    }

    fn codex_client_capability_preview(
        &self,
        plan: &hiroute_domain::CompiledAgentPlanV1,
    ) -> Result<hiroute_application_api::CodexClientCapabilityPreviewV1, ControlReadError> {
        Ok(hiroute_integrations::agents::codex_plan_capability_preview(
            plan,
        ))
    }

    fn plan_draft_snapshot(
        &self,
        workspace: &WorkspaceId,
        change: &hiroute_domain::PlanDraftChangeV1,
    ) -> Result<hiroute_application::routing::PlanDraftSnapshotV1, ControlReadError> {
        let stores = self.stores_lock().map_err(super::map_port)?;
        let control = stores.control();
        let first = control
            .current_revisions(workspace)
            .map_err(super::map_port)?;
        let draft = control
            .plan_draft(workspace, &change.draft_id)
            .map_err(|_| ControlReadError::Corrupt)?;
        let legacy_source = match &change.action {
            hiroute_domain::PlanDraftActionV1::Save { draft } => match &draft.plan_id {
                Some(plan_id)
                    if control
                        .plan_head(workspace, plan_id)
                        .map_err(|_| ControlReadError::Corrupt)?
                        .is_none() =>
                {
                    let record = control
                        .active_publication(workspace)
                        .map_err(super::map_port)?
                        .ok_or(ControlReadError::Unavailable)?;
                    let publication = record.verify().map_err(|_| ControlReadError::Corrupt)?;
                    let compiled = publication
                        .plans
                        .iter()
                        .find(|p| p.agent_plan_id() == plan_id)
                        .ok_or(ControlReadError::Unavailable)?;
                    Some(
                        hiroute_domain::PlanVersionV1::from_unversioned_compiled_recovery(
                            workspace.clone(),
                            compiled.clone(),
                        )
                        .map_err(|_| ControlReadError::Corrupt)?,
                    )
                }
                _ => None,
            },
            _ => None,
        };
        let second = control
            .current_revisions(workspace)
            .map_err(super::map_port)?;
        if first != second {
            return Err(ControlReadError::SnapshotChanged);
        }
        Ok(hiroute_application::routing::PlanDraftSnapshotV1 {
            workspace: workspace.clone(),
            draft,
            legacy_source,
            expected_revisions: second,
        })
    }

    fn resolve_model_ratings(
        &self,
        query: &hiroute_application_api::ResolveModelRatingsV1,
    ) -> Result<
        hiroute_application_api::ResolveModelRatingsResultV1,
        hiroute_application::model_catalog::RatingQueryError,
    > {
        self.plan_model_ratings()?.resolve(query)
    }

    fn free_plan_suggestions(
        &self,
        workspace: &WorkspaceId,
        requirements: &hiroute_domain::CapabilityRequirementsV1,
        selections: &std::collections::BTreeMap<String, hiroute_domain::ReasoningSelectionV1>,
        snapshot: hiroute_application_api::RatingSnapshotSelectionV1,
    ) -> Result<hiroute_application::routing::FreeSuggestionsV1, ControlReadError> {
        let facts = self.routing_compilation_snapshot(workspace)?;
        // Missing rating data does not remove otherwise legal suggestions.
        let ratings = self.plan_model_ratings().unwrap_or_default();
        hiroute_application::routing::suggest_free(
            &facts.facts,
            requirements,
            selections,
            &ratings,
            snapshot,
        )
        .map_err(|error| match error {
            hiroute_application::compiler::AgentPlanCompilerError::RatingSnapshotUnavailable => {
                ControlReadError::Unavailable
            }
            _ => ControlReadError::Corrupt,
        })
    }

    fn plan_authoring_snapshot(
        &self,
        workspace: &WorkspaceId,
        change: &hiroute_application_api::PlanContentChangeV2,
    ) -> Result<hiroute_application::routing::PlanAuthoringSnapshotV2, ControlReadError> {
        self.plan_content_snapshot(workspace, change)
    }

    fn routing_compilation_snapshot(
        &self,
        workspace_id: &WorkspaceId,
    ) -> Result<RoutingCompilationSnapshotV1, ControlReadError> {
        let first = self.routing_snapshot(workspace_id)?;
        let second = self.routing_snapshot(workspace_id)?;
        // Both reads are independent. Compare the complete inputs without temporary encoding.
        if first.unavailable_candidates != second.unavailable_candidates
            || first.facts != second.facts
            || first.expected_revisions != second.expected_revisions
            || first.active_publication != second.active_publication
        {
            return Err(ControlReadError::SnapshotChanged);
        }
        Ok(second)
    }
}

impl LocalControlAdapter {
    fn plan_model_ratings(
        &self,
    ) -> Result<
        hiroute_application::model_catalog::ModelRatings,
        hiroute_application::model_catalog::RatingQueryError,
    > {
        use hiroute_application::model_catalog::{ModelRatings, RatingQueryError};
        let snapshot = self
            .current_catalog()
            .ok_or(RatingQueryError::SnapshotUnavailable)?
            .rating_snapshot()
            .clone();
        let ratings = ModelRatings::default();
        ratings
            .install(snapshot)
            .map_err(|_| RatingQueryError::SnapshotUnavailable)?;
        Ok(ratings)
    }

    fn routing_snapshot(
        &self,
        workspace_id: &WorkspaceId,
    ) -> Result<RoutingCompilationSnapshotV1, ControlReadError> {
        hiroute_diagnostics::publication::measure(
            &self
                .publication_diagnostics
                .lock()
                .map(|p| p.clone())
                .unwrap_or_default(),
            hiroute_diagnostics::publication::PublicationStage::RoutingSnapshot,
            None,
            None,
            || {
                let catalog = self
                    .current_catalog()
                    .ok_or(ControlReadError::SnapshotChanged)?;
                let provenance = catalog
                    .compute_catalog_provenance()
                    .map_err(|_| ControlReadError::Corrupt)?;
                let (management, rows) = {
                    let stores = self.stores_lock().map_err(super::map_port)?;
                    let control = stores.control();
                    (
                        control
                            .compute_management_snapshot(workspace_id)
                            .map_err(super::map_port)?,
                        control.compute_projection_rows().map_err(super::map_port)?,
                    )
                };
                let mut diagnostics =
                    CandidateDiagnostics::new(&management.sources, &rows, &catalog);
                let needs_cpa = rows
                    .iter()
                    .any(|(source, _, _)| source.origin == SourceOrigin::Cpa)
                    || management.sources.iter().any(|source| {
                        source.state == MaterializationState::Ready
                            && matches!(
                                source.provenance,
                                hiroute_domain::ComputeManagementProvenanceV2::ConnectorOwned { .. }
                            )
                    });
                let cpa_batch = if needs_cpa {
                    self.cpa_sources
                        .as_ref()
                        .and_then(|authority| authority.begin_routing_batch().ok())
                } else {
                    None
                };
                let cpa_sources = cpa_batch
                    .as_ref()
                    .map(|batch| self.cpa_candidates_from_sources(batch.sources().to_vec()))
                    .transpose()?
                    .unwrap_or_default();
                let cpa_targets = cpa_batch.as_ref();
                // Batch discovery intentionally preserves healthy siblings. Diagnose each missing
                // saved provider separately, outside the storage lock, without changing its facts.
                let connector_failures = management
                    .sources
                    .iter()
                    .filter_map(|source| {
                        let hiroute_domain::ComputeManagementProvenanceV2::ConnectorOwned {
                            connector_id,
                            account_ref,
                        } = &source.provenance
                        else {
                            return None;
                        };
                        (source.state == MaterializationState::Ready
                            && cpa_targets
                                .and_then(|batch| {
                                    unique_live_cpa_source(
                                        batch.sources(),
                                        connector_id,
                                        account_ref,
                                    )
                                })
                                .is_none())
                        .then(|| {
                            (
                                source.source_id.clone(),
                                self.subscription_routing_unavailability(source),
                            )
                        })
                    })
                    .collect::<std::collections::BTreeMap<_, _>>();
                let stores = self.stores_lock().map_err(super::map_port)?;
                let control = stores.control();
                let mut inventory_refs = Vec::new();
                let mut candidates = Vec::new();
                for (source, binding, inventory) in rows {
                    source
                        .validate_shape()
                        .map_err(|_| ControlReadError::Corrupt)?;
                    if !hiroute_domain::valid_upstream_model_id(&binding.upstream_model_id) {
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::InvalidModelId);
                        continue;
                    }
                    binding
                        .validate_shape()
                        .map_err(|_| ControlReadError::Corrupt)?;
                    if catalog.validate_source(&source, true).is_err()
                        || binding.validate(&source, catalog.model_data()).is_err()
                    {
                        // A structurally valid durable projection can legitimately become stale when a
                        // newer client-bundled catalog removes or revises its exact connector/model/Offer facts.
                        // Exclude only that candidate; persisted corruption was already rejected above.
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::CatalogMismatch);
                        continue;
                    }
                    let Some(model) = catalog
                        .model_data()
                        .model(&binding.model_configuration_id)
                        .cloned()
                    else {
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::CatalogMismatch);
                        continue;
                    };
                    let Some(capability) = catalog
                        .model_data()
                        .model_endpoint_capabilities
                        .iter()
                        .find(|capability| capability.capability_id == binding.capability_id)
                        .cloned()
                    else {
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::CatalogMismatch);
                        continue;
                    };
                    let Ok(resolved) =
                        catalog.resolve_connection_option(&source.connection_option_id)
                    else {
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::CatalogMismatch);
                        continue;
                    };
                    let Some(protocol_endpoint) = resolved
                        .endpoint_profile
                        .protocol_endpoints
                        .iter()
                        .find(|endpoint| {
                            endpoint.protocol_endpoint_id == capability.protocol_endpoint_id
                        })
                        .cloned()
                    else {
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::CatalogMismatch);
                        continue;
                    };
                    let Some(offer) = catalog.model_data().offer(&binding.offer_ref) else {
                        diagnostics
                            .legacy_reason(&binding.binding_id, UnavailableReason::CatalogMismatch);
                        continue;
                    };
                    let mut pool = binding
                        .credential_pool_id
                        .as_deref()
                        .map(|pool_id| control.credential_pool(pool_id))
                        .transpose()
                        .map_err(super::map_port)?
                        .flatten();
                    if pool.is_none() && source.origin == SourceOrigin::Cpa {
                        pool = cpa_sources
                            .iter()
                            .find(|(registered, model_id)| {
                                registered.source.source_id == source.source_id
                                    && model_id == &binding.model_configuration_id
                            })
                            .and_then(|(registered, _)| {
                                catalog
                                    .transient_cpa_credential_pool(registered, &source, &binding)
                                    .ok()
                            });
                    }
                    if let Some(pool) = &pool
                        && (catalog.validate_pool(pool, &source).is_err()
                            || pool.validate_against_binding(&binding).is_err())
                    {
                        diagnostics.legacy_reason(
                            &binding.binding_id,
                            UnavailableReason::CredentialUnavailable,
                        );
                        continue;
                    }
                    let Some(reasoning) = catalog
                        .native_reasoning()
                        .iter()
                        .find(|reasoning| {
                            reasoning.model_configuration_id == binding.model_configuration_id
                        })
                        .cloned()
                    else {
                        diagnostics.legacy_reason(
                            &binding.binding_id,
                            UnavailableReason::CapabilityUnavailable,
                        );
                        continue;
                    };
                    let source_state = match resolved.connector.authentication {
                        AuthenticationKind::None => source.state,
                        _ if source.state == MaterializationState::Disabled => source.state,
                        _ if pool.as_ref().is_some_and(|pool| {
                            pool.credentials.iter().any(|entry| entry.enabled)
                        }) =>
                        {
                            MaterializationState::Ready
                        }
                        _ => MaterializationState::NeedsCredential,
                    };
                    let Some(execution) =
                        super::candidate_execution::materialize_candidate_execution(
                            &resolved,
                            &model,
                            &capability,
                            &protocol_endpoint,
                            &reasoning,
                            pool.as_ref(),
                            cpa_targets,
                        )
                    else {
                        let reason = if source.origin == SourceOrigin::Cpa && cpa_targets.is_none()
                        {
                            UnavailableReason::RuntimeUnavailable
                        } else if source_state == MaterializationState::NeedsCredential {
                            UnavailableReason::CredentialUnavailable
                        } else {
                            UnavailableReason::InvalidConfiguration
                        };
                        diagnostics.legacy_reason(&binding.binding_id, reason);
                        continue;
                    };
                    // The current catalog keeps configuration-scoped ratings separate. Explicit
                    // compilation must not collapse them into this legacy model-level field.
                    let rating = None;
                    let ordering_price = catalog
                        .model_data()
                        .price_rates
                        .iter()
                        .find(|price| {
                            price.offer_ref == binding.offer_ref
                                && price.model_configuration_id == binding.model_configuration_id
                        })
                        .map(|price| {
                            Ok(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)
                                    .map_err(|_| ControlReadError::Corrupt)?,
                            })
                        })
                        .transpose()?;
                    let free_evidence = if binding.billing_class
                        == hiroute_domain::BillingClass::Free
                    {
                        let Some(free) = catalog.model_data().free_offers.iter().find(|free| {
                            free.offer_ref == binding.offer_ref
                                && free
                                    .model_configuration_ids
                                    .contains(&binding.model_configuration_id)
                        }) else {
                            continue;
                        };
                        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
                    };
                    inventory_refs.push((
                        inventory.source_id.clone(),
                        inventory.endpoint_profile_id.clone(),
                        inventory.inventory_revision,
                        inventory.inventory_digest.clone(),
                    ));
                    let inventory_model_matched = inventory
                        .observed_models
                        .iter()
                        .any(|model| model.upstream_model_id == binding.upstream_model_id);
                    candidates.push(CandidateCompilationFactV1 {
                authority:
                    hiroute_application::compiler::CandidateFactAuthorityV1::RegisteredCatalog,
                connection_option_id: source.connection_option_id.clone(),
                offer_revision: offer.revision,
                binding,
                model,
                capability,
                protocol_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: execution.credential_refs,
                credential_destination_ref: None,
                source_state,
                inventory_model_matched,
                reasoning: reasoning.capability,
                rating,
                ordering_price,
                free_evidence,
            });
                }
                for source in management.sources {
                    inventory_refs.push((
                        source.source_id.clone(),
                        "compute-management/v2".into(),
                        source.revision,
                        source.digest().map_err(|_| ControlReadError::Corrupt)?,
                    ));
                    if let hiroute_domain::ComputeManagementProvenanceV2::Registered {
                        connection_option_id,
                        ..
                    } = &source.provenance
                    {
                        let Ok(resolved) = catalog.resolve_connection_option(connection_option_id)
                        else {
                            diagnostics.catalog_mismatch(&source);
                            continue;
                        };
                        if !super::model_connections::registered_source_matches_current_option(
                            &source, &resolved,
                        ) {
                            diagnostics.catalog_mismatch(&source);
                            continue;
                        }
                    }
                    let preferences = control
                        .source_default_preferences(&source.source_id)
                        .map_err(super::map_port)?;
                    let mut compilation = diagnostics.compile_models(&source);
                    for fact in &mut compilation {
                        fact.default_preferences = preferences
                            .get(&fact.binding_id)
                            .cloned()
                            .unwrap_or_default();
                        let candidate = match &fact.provenance {
                    hiroute_domain::ComputeManagementProvenanceV2::ConnectorOwned {
                        connector_id,
                        account_ref,
                    } => cpa_targets
                        .and_then(|batch| {
                            unique_live_cpa_source(batch.sources(), connector_id, account_ref)
                        })
                        .and_then(|registered| {
                            super::candidate_execution::materialize_connector_management_candidate(
                                fact,
                                registered,
                                &catalog,
                                cpa_targets,
                            )
                        }),
                    hiroute_domain::ComputeManagementProvenanceV2::Registered { .. } => {
                        if fact.eligibility
                            == hiroute_application::compute_management::ComputeManagementEligibilityV2::RuntimeQualified
                        {
                            super::candidate_execution::materialize_management_candidate(
                                fact,
                                Some(&catalog),
                            )
                        } else {
                            super::candidate_execution::materialize_registered_management_candidate(
                                fact, &catalog,
                            )
                        }
                    }
                    hiroute_domain::ComputeManagementProvenanceV2::UserConfigured { .. } => {
                        super::candidate_execution::materialize_management_candidate(
                            fact,
                            Some(&catalog),
                        )
                    }
                };
                        if let Some(candidate) = candidate {
                            candidates.push(candidate);
                        } else {
                            diagnostics.materialization_failed(
                                fact,
                                connector_failures
                                    .get(&source.source_id)
                                    .copied()
                                    .unwrap_or(UnavailableReason::InvalidConfiguration),
                            );
                        }
                    }
                }
                inventory_refs.sort();
                candidates
                    .sort_by(|left, right| left.binding.binding_id.cmp(&right.binding.binding_id));
                let inventory_revision = inventory_refs
                    .iter()
                    .map(|value| value.2)
                    .max()
                    .unwrap_or(0);
                let rating_snapshot = catalog.rating_snapshot().clone();
                let facts = AgentPlanCompilationFactsV1 {
                    schema: AGENT_PLAN_FACTS_SCHEMA_V1.into(),
                    compiler_revision: AGENT_PLAN_COMPILER_REVISION_V1.into(),
                    candidate_scope: CandidateFactScope::AllMaterializedBindings,
                    refs: AgentPlanFactRefsV1 {
                        connector_registry_version: catalog.registry().registry_version.clone(),
                        connector_registry_digest: provenance.connector_registry_digest,
                        model_data_bundle_version: catalog.model_data().bundle_version.clone(),
                        model_data_digest: provenance.model_data_digest,
                        capability_slice_version: catalog
                            .model_data()
                            .capability_slice_version
                            .clone(),
                        capability_slice_digest: CanonicalDigest::of(
                            &catalog.model_data().model_endpoint_capabilities,
                        )
                        .map_err(|_| ControlReadError::Corrupt)?,
                        ratings_slice_version: rating_snapshot.version,
                        ratings_slice_digest: rating_snapshot.digest,
                        free_offers_slice_version: catalog
                            .model_data()
                            .free_offers_slice_version
                            .clone(),
                        free_offers_slice_digest: CanonicalDigest::of(
                            &catalog.model_data().free_offers,
                        )
                        .map_err(|_| ControlReadError::Corrupt)?,
                        inventory_revision,
                        inventory_digest: CanonicalDigest::of(&inventory_refs)
                            .map_err(|_| ControlReadError::Corrupt)?,
                        price_tracking: PriceTrackingMode::FollowLatest,
                    },
                    ordering_price_version: catalog.model_data().prices_slice_version.clone(),
                    ordering_price_digest: CanonicalDigest::of(&catalog.model_data().price_rates)
                        .map_err(|_| ControlReadError::Corrupt)?,
                    candidates,
                };
                facts.validate_snapshot().map_err(|error| {
                    eprintln!("routing compilation facts are invalid: {error}");
                    ControlReadError::Corrupt
                })?;
                let revisions = control
                    .current_revisions(workspace_id)
                    .map_err(super::map_port)?;
                let active = control
                    .active_publication(workspace_id)
                    .map_err(super::map_port)?;
                let active_publication = active
                    .as_ref()
                    .map(hiroute_domain::PublicationRecordV1::verify)
                    .transpose()
                    .map_err(|_| ControlReadError::Corrupt)?;
                let mut expected_revisions = revisions;
                expected_revisions
                    .dependencies
                    .insert("feed.model_data".into(), catalog.generation);
                expected_revisions
                    .dependencies
                    .insert("release.registry".into(), provenance.release_sequence);
                expected_revisions
                    .dependencies
                    .insert("release.model_data".into(), provenance.release_sequence);
                // Revalidation can wait for CPA control or lifecycle work. Native
                // grants use this same store mutex and have a shorter ACK deadline.
                drop(stores);
                if let Some(batch) = cpa_batch
                    && !batch.finish().unwrap_or(false)
                {
                    return Err(ControlReadError::SnapshotChanged);
                }
                Ok(RoutingCompilationSnapshotV1 {
                    unavailable_candidates: diagnostics.finish(&facts.candidates),
                    facts,
                    expected_revisions,
                    active_publication,
                })
            },
        )
    }

    #[cfg(test)]
    pub(super) fn routing_cpa_candidates(
        &self,
        needed: bool,
    ) -> Vec<(hiroute_integrations::CpaRegisteredSourceV1, String)> {
        if !needed {
            return Vec::new();
        }
        // A managed connector is an independent execution dependency. Its process or borrowed
        // authorization becoming temporarily unavailable must remove only those candidates, not
        // make unrelated native/API candidates or the plan editor unreadable.
        self.registered_cpa_candidates().unwrap_or_default()
    }
}

fn unique_live_cpa_source<'a>(
    sources: &'a [hiroute_integrations::CpaRegisteredSourceV1],
    connector_id: &str,
    account_ref: &str,
) -> Option<&'a hiroute_integrations::CpaRegisteredSourceV1> {
    let kind = hiroute_cpa_bridge::CpaAccountKind::from_connector(connector_id)?;
    let mut matching = sources.iter().filter(|registered| {
        registered.source.connector_id == connector_id
            && registered.source.connection_option_id == kind.connection_option_id()
            && registered.source.identity.account_subject_ref == account_ref
    });
    let source = matching.next()?;
    matching.next().is_none().then_some(source)
}

#[cfg(test)]
mod tests {
    use super::*;
    use hiroute_domain::{CredentialRefV1, InventoryDisposition};
    use hiroute_integrations::{
        CpaAccountMaterializationV1, TrustedReleaseCatalog, register_cpa_account,
    };

    #[test]
    fn observed_cpa_model_without_catalog_projection_keeps_its_live_account_source() {
        const MANIFEST: &[u8] =
            include_bytes!("../../../../../assets/release-facts/current/bundle/manifest.json");
        let catalog = TrustedReleaseCatalog::load_bundled_release_facts(
            MANIFEST,
            MANIFEST,
            include_bytes!(
                "../../../../../assets/release-facts/current/bundle/connector-registry.json"
            ),
            include_bytes!("../../../../../assets/release-facts/current/bundle/model-data.json"),
        )
        .unwrap();
        let source_id = "cpa/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
        let account_ref =
            "account/cpa/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
        for (kind, model) in [
            (
                hiroute_cpa_bridge::CpaAccountKind::Codex,
                "gpt-6-future-text",
            ),
            (
                hiroute_cpa_bridge::CpaAccountKind::Claude,
                "claude-future-text",
            ),
        ] {
            let materialization = CpaAccountMaterializationV1 {
            connector_id: kind.connector_id().into(),
            connection_option_id: kind.connection_option_id().into(),
            endpoint_profile_id: kind.endpoint_profile_id().into(),
            source_id: source_id.into(),
            account_subject: account_ref.into(),
            credential_ref: CredentialRefV1::new(
                "credential/cpa/aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
                format!("source/{source_id}"),
                format!("connector/{}", kind.connector_id()),
                "provider-auth",
                [format!("connection-option/{}", kind.connection_option_id())],
                1,
            )
            .unwrap(),
            observed_model_ids: [model.into()].into_iter().collect(),
        };
            let registered = register_cpa_account(&catalog, &materialization).unwrap();
            assert_eq!(registered.inventory.len(), 1);
            assert_eq!(
                registered.inventory[0].disposition,
                InventoryDisposition::InventoryOnly
            );
            assert!(registered.inventory[0].model_configuration_id.is_none());
            assert_eq!(
                unique_live_cpa_source(
                    std::slice::from_ref(&registered),
                    kind.connector_id(),
                    account_ref
                ),
                Some(&registered),
            );
            assert!(
                unique_live_cpa_source(
                    &[registered.clone(), registered],
                    kind.connector_id(),
                    account_ref
                )
                .is_none()
            );
        }
    }
}