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.

16.5 KB
Raw Blame
//! Deterministic bridge from saved management truth to local compiler inputs.

use hiroute_domain::{
    ComputeCredentialSelectionV2, ComputeManagedCapabilitiesV2, ComputeManagedModelV2,
    ComputeManagementFactBasisV2, ComputeManagementMembershipV2, ComputeManagementProvenanceV2,
    ComputeManagementSourceV2, ComputeManagementTargetV2, ComputeNativeEndpointV3,
    GatewayAuthenticationSemanticsV1, MaterializationState, NativeReasoningCapabilityV1,
};
use thiserror::Error;

use super::mutation_support::{managed_binding_id, map_capabilities, map_membership};
use super::{ComputeCandidateFactsV2, ComputeCandidateModelFactsV2, ComputeCandidateProvenanceV2};

#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum ComputeManagementEligibilityV2 {
    CatalogMatched,
    RuntimeQualified,
    UserConfirmed,
    NativeObserved,
    ConnectorVerified,
}

#[derive(Clone, Debug, Eq, PartialEq)]
pub enum ComputeManagementCredentialCompilationV2 {
    Native {
        ordered: Vec<ComputeCredentialSelectionV2>,
    },
    ConnectorOwned {
        connector_id: String,
        account_ref: String,
        validation_ref: String,
        validation_revision: u64,
    },
}

/// One source-local model fact ready for the central routing snapshot join.
///
/// This value deliberately does not masquerade as a Registry bundle. The central compiler
/// writer can merge it with ratings, prices, plan references, and shared schema changes.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct ComputeManagementCompilationFactV2 {
    pub source_id: String,
    pub source_revision: u64,
    pub source_lineage_digest: hiroute_domain::CanonicalDigest,
    pub binding_id: String,
    pub binding_revision: u64,
    pub model_ref: String,
    pub upstream_model_id: String,
    pub display_name: String,
    pub catalog_configuration_id: Option<String>,
    pub eligibility: ComputeManagementEligibilityV2,
    pub provenance: ComputeManagementProvenanceV2,
    pub target: ComputeManagementTargetV2,
    pub authentication: GatewayAuthenticationSemanticsV1,
    pub additional_native_endpoints: Vec<ComputeNativeEndpointV3>,
    pub capabilities: ComputeManagedCapabilitiesV2,
    pub default_preferences: std::collections::BTreeMap<
        hiroute_domain::ModelDefaultFieldV1,
        hiroute_domain::ModelDefaultPreferenceV1,
    >,
    pub capability_evidence_digest: hiroute_domain::CanonicalDigest,
    pub native_reasoning: NativeReasoningCapabilityV1,
    pub credential: ComputeManagementCredentialCompilationV2,
}

pub fn compile_compute_management_source(
    source: &ComputeManagementSourceV2,
) -> Result<Vec<ComputeManagementCompilationFactV2>, ComputeManagementCompilationErrorV2> {
    source
        .validate()
        .map_err(|_| ComputeManagementCompilationErrorV2::InvalidSource)?;
    if source.state != MaterializationState::Ready {
        return Err(ComputeManagementCompilationErrorV2::NotReady);
    }
    let credential = compile_credential(source)?;
    source
        .models
        .iter()
        .filter(|model| model.execution_eligible)
        .map(|model| {
            compile_model(
                source,
                model,
                eligibility(source, model)?,
                credential.clone(),
            )
        })
        .collect()
}

/// Compile a checked Codex subscription model for one Agent connection without adding it to the
/// durable source or the general Plan candidate set. The caller must obtain `checked` through the
/// retained-validation join for this exact saved source and re-intersect the result with live CPA.
pub fn compile_connection_only_codex_model(
    source: &ComputeManagementSourceV2,
    checked: &ComputeCandidateFactsV2,
    model: &ComputeCandidateModelFactsV2,
) -> Result<ComputeManagementCompilationFactV2, ComputeManagementCompilationErrorV2> {
    let (
        ComputeManagementProvenanceV2::ConnectorOwned {
            connector_id,
            account_ref,
        },
        ComputeCandidateProvenanceV2::ConnectorOwned {
            connector_id: checked_connector,
            account_ref: checked_account,
        },
    ) = (&source.provenance, &checked.provenance)
    else {
        return Err(ComputeManagementCompilationErrorV2::AuthorizationMissing);
    };
    if connector_id != checked_connector
        || account_ref != checked_account
        || !model.selectable
        || model.reason.is_some()
        || model.membership != hiroute_application_api::ComputeModelMembershipV2::Catalog
        || model.catalog_configuration_id.is_none()
        || source
            .models
            .iter()
            .any(|saved| saved.model_ref == model.model_ref)
        || !checked.models.iter().any(|candidate| candidate == model)
    {
        return Err(ComputeManagementCompilationErrorV2::EligibilityMismatch);
    }
    let binding_id = managed_binding_id(&source.source_id, &model.model_ref)
        .map_err(|_| ComputeManagementCompilationErrorV2::InvalidSource)?;
    let mut connection_source = source.clone();
    connection_source.models.push(ComputeManagedModelV2 {
        model_ref: model.model_ref.clone(),
        binding_id: binding_id.clone(),
        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: map_membership(model.membership),
        execution_eligible: true,
        capabilities: map_capabilities(&model.capabilities),
        capability_evidence_digest: model.capability_evidence_digest.clone(),
    });
    compile_compute_management_source(&connection_source)?
        .into_iter()
        .find(|fact| fact.binding_id == binding_id)
        .ok_or(ComputeManagementCompilationErrorV2::InvalidSource)
}

fn compile_model(
    source: &ComputeManagementSourceV2,
    model: &ComputeManagedModelV2,
    eligibility: ComputeManagementEligibilityV2,
    credential: ComputeManagementCredentialCompilationV2,
) -> Result<ComputeManagementCompilationFactV2, ComputeManagementCompilationErrorV2> {
    let capabilities = &model.capabilities;
    if (eligibility == ComputeManagementEligibilityV2::CatalogMatched
        || matches!(
            source.provenance,
            ComputeManagementProvenanceV2::ConnectorOwned { .. }
        ))
        && (capabilities.tool.value.is_none()
            || capabilities.vision.value.is_none()
            || capabilities.streaming.value.is_none()
            || capabilities.context_tokens.value.is_none()
            || capabilities.max_output_tokens.value.is_none())
    {
        return Err(ComputeManagementCompilationErrorV2::UnknownCapability);
    }
    if eligibility == ComputeManagementEligibilityV2::UserConfirmed
        && (model.membership != ComputeManagementMembershipV2::UserDeclared
            || model.catalog_configuration_id.is_some()
            || [
                capabilities.tool.basis,
                capabilities.vision.basis,
                capabilities.streaming.basis,
                capabilities.context_tokens.basis,
                capabilities.max_output_tokens.basis,
                capabilities.native_reasoning.basis,
            ]
            .into_iter()
            .any(|basis| {
                !matches!(
                    basis,
                    ComputeManagementFactBasisV2::UserDeclared
                        | ComputeManagementFactBasisV2::Unknown
                )
            }))
    {
        return Err(ComputeManagementCompilationErrorV2::EligibilityMismatch);
    }
    if eligibility == ComputeManagementEligibilityV2::RuntimeQualified
        && (!matches!(
            model.membership,
            ComputeManagementMembershipV2::Observed | ComputeManagementMembershipV2::UserDeclared
        ) || model.catalog_configuration_id.is_some()
            || capability_bases(capabilities).into_iter().any(|basis| {
                !matches!(
                    basis,
                    ComputeManagementFactBasisV2::RuntimeFallback
                        | ComputeManagementFactBasisV2::Unknown
                        | ComputeManagementFactBasisV2::UserDeclared
                )
            }))
    {
        return Err(ComputeManagementCompilationErrorV2::EligibilityMismatch);
    }
    if matches!(
        source.provenance,
        ComputeManagementProvenanceV2::ConnectorOwned { .. }
    ) && (capabilities.native_reasoning.value.is_none()
        || (eligibility == ComputeManagementEligibilityV2::RuntimeQualified
            && capability_bases(capabilities)
                .into_iter()
                .any(|basis| basis != ComputeManagementFactBasisV2::RuntimeFallback)))
    {
        return Err(ComputeManagementCompilationErrorV2::UnknownCapability);
    }
    if eligibility == ComputeManagementEligibilityV2::NativeObserved
        && !native_observed_model(source, model)
    {
        return Err(ComputeManagementCompilationErrorV2::EligibilityMismatch);
    }
    let native_reasoning = capabilities
        .native_reasoning
        .value
        .clone()
        .unwrap_or_else(|| NativeReasoningCapabilityV1::Toggle {
            parameter: "enable_thinking".into(),
        });
    native_reasoning
        .validate()
        .map_err(|_| ComputeManagementCompilationErrorV2::UnknownCapability)?;
    Ok(ComputeManagementCompilationFactV2 {
        source_id: source.source_id.clone(),
        source_revision: source.revision,
        source_lineage_digest: source.lineage_digest.clone(),
        binding_id: model.binding_id.clone(),
        binding_revision: model.revision,
        model_ref: model.model_ref.clone(),
        upstream_model_id: model.upstream_model_id.clone(),
        display_name: model.display_name.clone(),
        catalog_configuration_id: model.catalog_configuration_id.clone(),
        eligibility,
        provenance: source.provenance.clone(),
        target: source.target.clone(),
        authentication: source.authentication.clone(),
        additional_native_endpoints: source.additional_native_endpoints.clone(),
        capabilities: capabilities.clone(),
        default_preferences: Default::default(),
        capability_evidence_digest: model.capability_evidence_digest.clone(),
        native_reasoning,
        credential,
    })
}

fn eligibility(
    source: &ComputeManagementSourceV2,
    model: &ComputeManagedModelV2,
) -> Result<ComputeManagementEligibilityV2, ComputeManagementCompilationErrorV2> {
    if native_observed_model(source, model) {
        return Ok(ComputeManagementEligibilityV2::NativeObserved);
    }
    if (matches!(
        source.provenance,
        ComputeManagementProvenanceV2::Registered { .. }
    ) || model.membership == ComputeManagementMembershipV2::Observed)
        && matches!(
            model.membership,
            ComputeManagementMembershipV2::Observed | ComputeManagementMembershipV2::UserDeclared
        )
        && model.catalog_configuration_id.is_none()
        && capability_bases(&model.capabilities)
            .into_iter()
            .all(|basis| {
                matches!(
                    basis,
                    ComputeManagementFactBasisV2::RuntimeFallback
                        | ComputeManagementFactBasisV2::Unknown
                        | ComputeManagementFactBasisV2::UserDeclared
                )
            })
    {
        return Ok(ComputeManagementEligibilityV2::RuntimeQualified);
    }
    match &source.provenance {
        ComputeManagementProvenanceV2::Registered { .. } => {
            if model.catalog_configuration_id.is_none()
                || model.membership != ComputeManagementMembershipV2::Catalog
            {
                return Err(ComputeManagementCompilationErrorV2::EligibilityMismatch);
            }
            Ok(ComputeManagementEligibilityV2::CatalogMatched)
        }
        ComputeManagementProvenanceV2::UserConfigured { .. } => {
            Ok(ComputeManagementEligibilityV2::UserConfirmed)
        }
        ComputeManagementProvenanceV2::ConnectorOwned { .. } => {
            Ok(ComputeManagementEligibilityV2::ConnectorVerified)
        }
    }
}

// A discovered native user source retains source-local authority. The trusted point
// producer may also fill unknown facts or append models from an exact qualified catalog.
// Neither case acquires registered billing, pricing or account authorization.
fn native_observed_model(
    source: &ComputeManagementSourceV2,
    model: &ComputeManagedModelV2,
) -> bool {
    if !matches!(
        source.provenance,
        ComputeManagementProvenanceV2::UserConfigured { .. }
    ) {
        return false;
    }
    let bases = capability_bases(&model.capabilities);
    if model.catalog_configuration_id.is_none() {
        return model.membership == ComputeManagementMembershipV2::Observed
            && bases.into_iter().all(|basis| {
                matches!(
                    basis,
                    ComputeManagementFactBasisV2::Observed
                        | ComputeManagementFactBasisV2::Unknown
                        | ComputeManagementFactBasisV2::UserDeclared
                )
            });
    }
    matches!(
        model.membership,
        ComputeManagementMembershipV2::Observed | ComputeManagementMembershipV2::Catalog
    ) && bases.contains(&ComputeManagementFactBasisV2::RegisteredCatalog)
        && bases.into_iter().all(|basis| {
            matches!(
                basis,
                ComputeManagementFactBasisV2::Observed
                    | ComputeManagementFactBasisV2::Unknown
                    | ComputeManagementFactBasisV2::RegisteredCatalog
            )
        })
        && (model.membership == ComputeManagementMembershipV2::Observed
            || bases
                .into_iter()
                .all(|basis| basis == ComputeManagementFactBasisV2::RegisteredCatalog))
}

fn capability_bases(
    capabilities: &ComputeManagedCapabilitiesV2,
) -> [ComputeManagementFactBasisV2; 6] {
    [
        capabilities.tool.basis,
        capabilities.vision.basis,
        capabilities.streaming.basis,
        capabilities.context_tokens.basis,
        capabilities.max_output_tokens.basis,
        capabilities.native_reasoning.basis,
    ]
}

fn compile_credential(
    source: &ComputeManagementSourceV2,
) -> Result<ComputeManagementCredentialCompilationV2, ComputeManagementCompilationErrorV2> {
    match &source.provenance {
        ComputeManagementProvenanceV2::ConnectorOwned {
            connector_id,
            account_ref,
            ..
        } => {
            let validation = source
                .validation
                .as_ref()
                .ok_or(ComputeManagementCompilationErrorV2::AuthorizationMissing)?;
            Ok(ComputeManagementCredentialCompilationV2::ConnectorOwned {
                connector_id: connector_id.clone(),
                account_ref: account_ref.clone(),
                validation_ref: validation.validation_ref.clone(),
                validation_revision: validation.validation_revision,
            })
        }
        ComputeManagementProvenanceV2::Registered { .. }
        | ComputeManagementProvenanceV2::UserConfigured { .. } => {
            let ordered = match source.authentication {
                GatewayAuthenticationSemanticsV1::None => {
                    vec![ComputeCredentialSelectionV2::NoCredential]
                }
                GatewayAuthenticationSemanticsV1::Bearer
                | GatewayAuthenticationSemanticsV1::ApiKeyHeader { .. } => source
                    .enabled_credentials()
                    .map(|credential| ComputeCredentialSelectionV2::Credential {
                        credential_ref: credential.credential.clone(),
                    })
                    .collect(),
            };
            if ordered.is_empty()
                || ordered
                    .iter()
                    .any(|selection| selection.validate_for(&source.authentication).is_err())
            {
                return Err(ComputeManagementCompilationErrorV2::CredentialMissing);
            }
            Ok(ComputeManagementCredentialCompilationV2::Native { ordered })
        }
    }
}

#[derive(Clone, Copy, Debug, Eq, Error, PartialEq)]
pub enum ComputeManagementCompilationErrorV2 {
    #[error("saved compute source is invalid")]
    InvalidSource,
    #[error("saved compute source is not ready")]
    NotReady,
    #[error("saved compute source has unknown required capability facts")]
    UnknownCapability,
    #[error("saved compute source eligibility is inconsistent")]
    EligibilityMismatch,
    #[error("saved compute source has no valid credential selection")]
    CredentialMissing,
    #[error("saved connector source has no validated authorization")]
    AuthorizationMissing,
}