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.

4.4 KB
Raw Blame
use super::*;

#[derive(Clone)]
pub(crate) struct RuntimeAuthority {
    pub(super) adapter: Arc<LocalControlAdapter>,
}
impl ProductionControlRuntime {
    pub(crate) fn protected_authority(&self) -> RuntimeAuthority {
        RuntimeAuthority {
            adapter: self.adapter.clone(),
        }
    }
    pub(crate) fn register_manual_protected_input(
        &self,
        candidate: hiroute_application_api::ComputeCandidateRefV2,
        secret: hiroute_domain::ProtectedSecret,
    ) -> Result<(), String> {
        self.protected_authority()
            .register_manual_protected_input(candidate, secret)
    }
    pub(crate) fn release_manual_protected_input(&self, candidate_ref: &str) -> Result<(), String> {
        self.protected_authority()
            .release_manual_protected_input(candidate_ref)
    }
}
impl RuntimeAuthority {
    pub(crate) fn register_manual_protected_input(
        &self,
        candidate: hiroute_application_api::ComputeCandidateRefV2,
        secret: hiroute_domain::ProtectedSecret,
    ) -> Result<(), String> {
        if let Some(login_ref) = candidate
            .candidate_ref
            .strip_prefix("candidate/subscription-login/")
        {
            let session = self
                .adapter
                .cpa_runtime
                .as_ref()
                .and_then(|runtimes| runtimes.login_session(login_ref))
                .ok_or_else(|| "subscription login is unavailable".to_owned())?;
            if session.state != hiroute_cpa_bridge::CpaLoginState::Pending
                || candidate != super::subscriptions::login::callback_candidate(login_ref)
                || secret.expose().len() > 16_384
            {
                return Err("subscription callback registration is invalid".into());
            }
            let mut inputs = self
                .adapter
                .manual_protected_inputs
                .lock()
                .map_err(|_| "protected input registry is unavailable".to_owned())?;
            if inputs.len() >= 256 || inputs.contains_key(&candidate.candidate_ref) {
                return Err("protected input registration is invalid".into());
            }
            inputs.insert(candidate.candidate_ref, secret);
            return Ok(());
        }
        if candidate
            .candidate_ref
            .starts_with("candidate/native/agent-token-")
        {
            candidate
                .validate_shape()
                .map_err(|_| "protected input registration is invalid".to_owned())?;
            if candidate.candidate_revision != 1
                || !hiroute_domain::valid_user_agent_token(secret.expose())
            {
                return Err("protected agent token is invalid".to_owned());
            }
            let mut inputs = self
                .adapter
                .agent_token_inputs
                .lock()
                .map_err(|_| "protected input registry is unavailable".to_owned())?;
            if inputs.len() >= 256 || inputs.contains_key(&candidate.candidate_ref) {
                return Err("protected input registration is invalid".to_owned());
            }
            inputs.insert(candidate.candidate_ref, secret);
            return Ok(());
        }
        self.adapter
            .model_connections
            .reserve_candidate_ref(&candidate)
            .map_err(|error| error.to_string())?;
        let mut inputs = self
            .adapter
            .manual_protected_inputs
            .lock()
            .map_err(|_| "protected input registry is unavailable".to_owned())?;
        if inputs.len() >= 256 || inputs.contains_key(&candidate.candidate_ref) {
            return Err("protected input registration is invalid".to_owned());
        }
        inputs.insert(candidate.candidate_ref, secret);
        Ok(())
    }

    pub(crate) fn release_manual_protected_input(&self, candidate_ref: &str) -> Result<(), String> {
        if candidate_ref.trim().is_empty() {
            return Err("protected input reference is invalid".to_owned());
        }
        self.adapter
            .manual_protected_inputs
            .lock()
            .map_err(|_| "protected input registry is unavailable".to_owned())?
            .remove(candidate_ref);
        self.adapter
            .agent_token_inputs
            .lock()
            .map_err(|_| "protected input registry is unavailable".to_owned())?
            .remove(candidate_ref);
        Ok(())
    }
}