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.

17.7 KB
Raw Blame
//! Protected candidateization of one exact local registered configuration.

use hiroute_application::ProtectedInputPort;
use hiroute_application::compute_management::{
    ComputeCandidatePort, ProtectedInputSourceDescriptorV1,
};
use hiroute_application::control::{ComputeManagementControlError, ControlReadError};
use hiroute_application_api::{
    ComputeCandidateRefV2, ComputeCandidateViewV2, ComputeModelMembershipV2,
    PrepareDiscoveredModelConnectionRequestV1,
};
use hiroute_domain::{
    AuthenticationKind, BillingClass, CanonicalDigest, ConnectionOrigin,
    GatewayAuthenticationSemanticsV1, UpstreamProtocol,
};
use hiroute_integrations::{
    AgentDiscoveryOutcomeV1, ModelConnectionBaseKindV1, ModelConnectionProbeCancellationV1,
    NativeConnectionProvenanceInputV1, NativeConnectionQualificationV1,
    NativeModelConnectionCredentialV1, NativeModelConnectionDraftV1, NativeModelDeclarationV1,
};

use super::super::compute_routing::{AuthorizedComputeDiscoveryV1, authorized_compute_discovery};
use super::LocalControlAdapter;

const CLAUDE_AGENT_ID: &str = "agent_claude_default";
const CONNECTION_OPTION_ID: &str = "zhipu.coding-plan.cn.v1";
const ENDPOINT_PROFILE_ID: &str = "endpoint.zhipu.coding-plan.cn.v1";
const DISCOVERED_PROTOCOL_ENDPOINT_ID: &str = "endpoint.zhipu.coding-plan.cn.v1.messages";
const ROUTING_PROTOCOL_ENDPOINT_ID: &str = "endpoint.zhipu.coding-plan.cn.v1.responses";
const MODEL_CONFIGURATION_ID: &str = "model.zhipu.glm-5.3";
const UPSTREAM_MODEL_ID: &str = "glm-5.3";
const MESSAGES_ADAPTER_ID: &str = "adapter.anthropic-messages.v1";
const RESPONSES_ADAPTER_ID: &str = "adapter.openai-responses.v1";

impl LocalControlAdapter {
    pub(super) fn prepare_discovered_candidate(
        &self,
        request: PrepareDiscoveredModelConnectionRequestV1,
    ) -> Result<ComputeCandidateViewV2, ComputeManagementControlError> {
        if !request.valid() {
            return Err(ComputeManagementControlError::Invalid);
        }
        {
            let preparations = self
                .prepared_discoveries
                .lock()
                .map_err(|_| ComputeManagementControlError::Unavailable)?;
            if let Some(bound) = preparations.get(&request.prepare_id) {
                if bound != &request {
                    return Err(ComputeManagementControlError::Conflict);
                }
            } else if preparations.len() >= 256 {
                return Err(ComputeManagementControlError::Unavailable);
            }
        }
        let lock_key = format!("prepare-discovery/{}", request.prepare_id);
        {
            let mut preparations = self
                .model_connection_cancellations
                .lock()
                .map_err(|_| ComputeManagementControlError::Unavailable)?;
            if preparations.len() >= 256 || preparations.contains_key(&lock_key) {
                return Err(ComputeManagementControlError::Conflict);
            }
            preparations.insert(
                lock_key.clone(),
                ModelConnectionProbeCancellationV1::default(),
            );
        }
        let prepared = self.prepare_discovered_candidate_inner(request.clone());
        self.model_connection_cancellations
            .lock()
            .map_err(|_| ComputeManagementControlError::Unavailable)?
            .remove(&lock_key);
        if prepared.is_ok() {
            let mut preparations = self
                .prepared_discoveries
                .lock()
                .map_err(|_| ComputeManagementControlError::Unavailable)?;
            match preparations.get(&request.prepare_id) {
                Some(bound) if bound != &request => {
                    return Err(ComputeManagementControlError::Conflict);
                }
                Some(_) => {}
                None if preparations.len() < 256 => {
                    preparations.insert(request.prepare_id.clone(), request);
                }
                None => return Err(ComputeManagementControlError::Unavailable),
            }
        }
        prepared
    }

    fn prepare_discovered_candidate_inner(
        &self,
        request: PrepareDiscoveredModelConnectionRequestV1,
    ) -> Result<ComputeCandidateViewV2, ComputeManagementControlError> {
        let catalog = self
            .current_catalog()
            .ok_or(ComputeManagementControlError::Unavailable)?;
        let discoveries = self
            .refresh_discovery()
            .map_err(|_| ComputeManagementControlError::DiscoveryUnavailable)?;
        let mut authorized = Vec::new();
        let mut recognized_configuration = false;
        for discovery in &discoveries {
            let is_claude = match &discovery.outcome {
                AgentDiscoveryOutcomeV1::Supported { installation } => {
                    installation.agent_id == CLAUDE_AGENT_ID
                }
                AgentDiscoveryOutcomeV1::ReportOnly { agent_id, .. } => agent_id == CLAUDE_AGENT_ID,
            };
            recognized_configuration |= is_claude
                && (discovery.claude_configuration.is_some()
                    || discovery.configuration_issue.is_some()
                    || discovery.discovered_credential.is_some());
            match authorized_compute_discovery(&catalog, discovery) {
                Ok(Some(candidate)) => authorized.push(candidate),
                Ok(None) => {}
                Err(ControlReadError::Corrupt) => {
                    return Err(ComputeManagementControlError::Corrupt);
                }
                Err(_) => return Err(ComputeManagementControlError::Unavailable),
            }
        }
        let current_exists = !authorized.is_empty();
        let Some(discovery) = authorized.into_iter().find(|candidate| {
            candidate.discovery.discovery_ref == request.discovery.discovery_ref
                && candidate.discovery.discovery_revision == request.discovery.discovery_revision
        }) else {
            let sources: Vec<_> = self
                .scanner
                .pi_api_sources()
                .unwrap_or_default()
                .into_iter()
                .chain(self.scanner.dsh_api_sources().unwrap_or_default())
                .chain(self.scanner.opencode_api_sources().unwrap_or_default())
                .collect();
            let mut sources = sources;
            sources.extend(self.claude_api_point_sources(&catalog).unwrap_or_default());
            sources.extend(
                self.hermes_source_facts()
                    .map(|facts| facts.sources)
                    .unwrap_or_default(),
            );
            let native_exists = !sources.is_empty();
            if let Some(point) = hiroute_integrations::native_api_connection_points(sources)
                .into_iter()
                .find(|point| super::points::point_discovery(point, &catalog) == request.discovery)
            {
                return self.prepare_native_point_candidate(point, &request.prepare_id);
            }
            if let Some(source) = self
                .scanner
                .pi_api_sources()
                // An unreadable unrelated source must not replace the selected
                // discovery result (including stale/forged Claude handles).
                // No matching Pi source still fails below; no candidate is created.
                .unwrap_or_default()
                .into_iter()
                .chain(self.scanner.dsh_api_sources().unwrap_or_default())
                .chain(self.scanner.opencode_api_sources().unwrap_or_default())
                .find(|source| super::pi_discovered::pi_discovery(source) == request.discovery)
            {
                return self.prepare_native_api_candidate(source, &request.prepare_id);
            }
            return Err(if current_exists || native_exists {
                ComputeManagementControlError::DiscoveryChanged
            } else if recognized_configuration {
                ComputeManagementControlError::DiscoveryNotImportable
            } else {
                ComputeManagementControlError::DiscoveryUnavailable
            });
        };
        self.validate_discovered_allowlist(&discovery)?;

        let descriptor = ProtectedInputSourceDescriptorV1::DiscoveredConfig {
            scanner_id: discovery.credential.scanner_id.clone(),
            scanner_version: discovery.credential.scanner_version.clone(),
            source_ref: discovery.credential.discovered_source_ref.clone(),
            field_selector: discovery.credential.field_selector.clone(),
            observed_revision: discovery.credential.observed_revision,
        };
        let input_slot = super::super::mutation::protected_input_slot(&discovery.credential)
            .map_err(|_| ComputeManagementControlError::Corrupt)?;
        // This is the only prepare-time credential access. It reopens the exact no-follow source,
        // checks its revision, and immediately drops the bytes after candidate registration.
        let secret = self
            .read_secret(&input_slot)
            .map_err(|_| ComputeManagementControlError::DiscoveryChanged)?;
        let candidate_digest = CanonicalDigest::of(&(
            "hiroute.discovered-model-candidate/v1",
            &discovery.evidence_digest,
            &request.prepare_id,
        ))
        .map_err(|_| ComputeManagementControlError::Corrupt)?;
        let candidate = ComputeCandidateRefV2 {
            candidate_ref: format!(
                "candidate/native-discovery/{}",
                candidate_digest.as_str().trim_start_matches("sha256:")
            ),
            candidate_revision: 1,
        };
        if let Ok(view) = self
            .model_connections
            .candidate_port()
            .get_compute_candidate(&candidate)
        {
            return Ok(view);
        }
        self.model_connections
            .reserve_candidate_ref(&candidate)
            .map_err(|_| ComputeManagementControlError::Conflict)?;
        let draft =
            self.discovered_registered_draft(&discovery, &candidate, &request.prepare_id)?;
        self.model_connections
            .prepare_registered_discovery(
                draft,
                NativeModelConnectionCredentialV1::Protected {
                    descriptor,
                    input_slot,
                    secret: &secret,
                },
                discovery.evidence_digest,
            )
            .map_err(|_| ComputeManagementControlError::Corrupt)
    }

    pub(super) fn validate_discovered_allowlist(
        &self,
        discovery: &AuthorizedComputeDiscoveryV1,
    ) -> Result<(), ComputeManagementControlError> {
        let fact = &discovery.fact;
        if fact.agent_id != CLAUDE_AGENT_ID
            || fact.connection_option_id != CONNECTION_OPTION_ID
            || fact.endpoint_profile_id != ENDPOINT_PROFILE_ID
            || fact.model_configuration_id != MODEL_CONFIGURATION_ID
            || fact.observed_model_id != UPSTREAM_MODEL_ID
            || discovery.credential.field_selector != "env.ANTHROPIC_AUTH_TOKEN"
        {
            return Err(ComputeManagementControlError::DiscoveryNotImportable);
        }
        Ok(())
    }

    fn discovered_registered_draft(
        &self,
        discovery: &AuthorizedComputeDiscoveryV1,
        candidate: &ComputeCandidateRefV2,
        prepare_id: &str,
    ) -> Result<NativeModelConnectionDraftV1, ComputeManagementControlError> {
        let catalog = self
            .current_catalog()
            .ok_or(ComputeManagementControlError::Unavailable)?;
        let provenance = catalog
            .compute_catalog_provenance()
            .map_err(|_| ComputeManagementControlError::Corrupt)?;
        let resolved = catalog
            .resolve_connection_option(CONNECTION_OPTION_ID)
            .map_err(|_| ComputeManagementControlError::RegisteredOptionUnavailable)?;
        if resolved.option.origin != ConnectionOrigin::NativeApi
            || resolved.option.billing_class != BillingClass::Subscription
            || resolved.connector.connector_id != "connector.zhipu.p0"
            || resolved.connector.authentication != AuthenticationKind::ProviderApiKey
            || resolved.connector.catalog_adapter_ref != "catalog.zhipu.p0"
            || resolved.connector.catalog_adapter_revision != 1
            || resolved.endpoint_profile.endpoint_profile_id != ENDPOINT_PROFILE_ID
        {
            return Err(ComputeManagementControlError::RegisteredOptionUnavailable);
        }
        let discovered_endpoint = resolved
            .endpoint_profile
            .protocol_endpoints
            .iter()
            .find(|endpoint| {
                endpoint.protocol_endpoint_id == DISCOVERED_PROTOCOL_ENDPOINT_ID
                    && endpoint.protocol == UpstreamProtocol::Messages
                    && endpoint.adapter_ref == MESSAGES_ADAPTER_ID
                    && endpoint.adapter_revision == 1
            })
            .ok_or(ComputeManagementControlError::RegisteredOptionUnavailable)?;
        let endpoint = resolved
            .endpoint_profile
            .protocol_endpoints
            .iter()
            .find(|endpoint| {
                endpoint.protocol_endpoint_id == ROUTING_PROTOCOL_ENDPOINT_ID
                    && endpoint.protocol == UpstreamProtocol::Responses
                    && endpoint.adapter_ref == RESPONSES_ADAPTER_ID
                    && endpoint.adapter_revision == 1
                    && endpoint.authentication_semantics
                        == Some(GatewayAuthenticationSemanticsV1::Bearer)
            })
            .ok_or(ComputeManagementControlError::RegisteredOptionUnavailable)?;
        let capability = catalog
            .model_data()
            .model_endpoint_capabilities
            .iter()
            .find(|capability| {
                capability.model_configuration_id == MODEL_CONFIGURATION_ID
                    && capability.upstream_model_id == UPSTREAM_MODEL_ID
                    && capability.connector_id == resolved.connector.connector_id
                    && capability.connector_revision == resolved.connector.revision
                    && capability.endpoint_profile_id == ENDPOINT_PROFILE_ID
                    && capability.endpoint_profile_revision == resolved.endpoint_profile.revision
                    && capability.protocol_endpoint_id == ROUTING_PROTOCOL_ENDPOINT_ID
                    && capability.upstream_protocol == UpstreamProtocol::Responses
                    && capability.required_adapter_ref == RESPONSES_ADAPTER_ID
                    && capability.required_adapter_revision == 1
            })
            .ok_or(ComputeManagementControlError::RegisteredOptionUnavailable)?;
        let model = catalog
            .model_data()
            .model(MODEL_CONFIGURATION_ID)
            .ok_or(ComputeManagementControlError::Corrupt)?;
        let reasoning = catalog
            .native_reasoning()
            .iter()
            .find(|value| value.model_configuration_id == MODEL_CONFIGURATION_ID)
            .ok_or(ComputeManagementControlError::Corrupt)?;
        let registered_base_url = format!(
            "{}{}",
            discovered_endpoint.base_url, discovered_endpoint.request_path
        )
        .strip_suffix("/v1/messages")
        .ok_or(ComputeManagementControlError::Corrupt)?
        .to_owned();
        if discovery.fact.endpoint_profile_revision != resolved.endpoint_profile.revision
            || discovery.fact.registered_base_url != registered_base_url
            || discovery.fact.configuration_revision == 0
            || capability.evidence_digest == CanonicalDigest::of_bytes(&[])
        {
            return Err(ComputeManagementControlError::DiscoveryChanged);
        }
        Ok(NativeModelConnectionDraftV1 {
            display_template_id: None,
            inference_model_id: None,
            candidate_ref: Some(candidate.candidate_ref.clone()),
            lineage_ref: discovery.discovery.discovery_ref.clone(),
            trusted_lineage_digest: None,
            display_name: resolved.option.display_name.clone(),
            existing_source_id: None,
            edit_revision: discovery.discovery.discovery_revision,
            check_id: prepare_id.to_owned(),
            base_url: endpoint.base_url.clone(),
            base_kind: ModelConnectionBaseKindV1::ApiRoot,
            request_path_override: Some(endpoint.request_path.clone()),
            inventory_path_override: endpoint.inventory_path.clone(),
            protocol: UpstreamProtocol::Responses,
            protocol_profile_id: endpoint.adapter_ref.clone(),
            protocol_profile_revision: endpoint.adapter_revision,
            protocol_header_semantics: super::registered_endpoint_header_semantics(endpoint),
            authentication: GatewayAuthenticationSemanticsV1::Bearer,
            additional_native_endpoints: super::registered::registered_additional_endpoints(
                &resolved, endpoint,
            )?,
            provenance: NativeConnectionProvenanceInputV1::Registered {
                connection_option_id: CONNECTION_OPTION_ID.into(),
                registry_version: catalog.registry().registry_version.clone(),
                catalog_digest: provenance.cross_reference_digest,
            },
            qualification: NativeConnectionQualificationV1 {
                free_access: None,
                evidence_ref: None,
            },
            runtime_fallback_denied_model_ids: super::runtime_fallback_denied_model_ids(Some(
                &catalog,
            )),
            models: vec![NativeModelDeclarationV1 {
                upstream_model_id: UPSTREAM_MODEL_ID.into(),
                display_name: model.display_name.clone(),
                catalog_configuration_id: Some(MODEL_CONFIGURATION_ID.into()),
                membership: ComputeModelMembershipV2::Catalog,
                capabilities: super::registered::capability_declaration(
                    &catalog, capability, model, reasoning,
                ),
            }],
        })
    }
}