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
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(())
}
}