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
//! Provider-isolated CPA instances sharing the same lifecycle implementation.
use crate::{
CpaAccountKind, CpaAttemptError, CpaDownstreamCredentialCapability,
CpaDownstreamCredentialPort, CpaLifecycleError, CpaRegisteredSourcePort, CpaRoutingBatch,
CpaSourceManagementState, ExactCpaCredentialRequest, ManagedCpaRuntime,
};
use hiroute_integrations::CpaRegisteredSourceV1;
use parking_lot::Mutex;
use std::collections::BTreeMap;
use std::sync::Arc;
use std::sync::atomic::{AtomicU64, Ordering};
use std::time::{Duration, Instant};
#[path = "managed_sessions.rs"]
mod managed_sessions;
pub use managed_sessions::{CpaLoginSession, CpaLoginState};
pub struct ManagedCpaRuntimeSet {
runtimes: Vec<Arc<ManagedCpaRuntime>>,
logins: Option<managed_sessions::ManagedLoginRegistry>,
/// Rebuilt solely from saved management state; login manifests never set this map.
selected: BTreeMap<CpaAccountKind, Mutex<ProviderSelection>>,
}
#[derive(Clone, Eq, PartialEq)]
struct SavedSourceProjection {
source_id: String,
revision: u64,
candidate: String,
account_ref: String,
state: CpaSourceManagementState,
}
#[derive(Default)]
struct ProviderSelection {
saved: Option<SavedSourceProjection>,
runtime: Option<Arc<ManagedCpaRuntime>>,
revision: Arc<AtomicU64>,
lifecycle: Arc<Mutex<()>>,
// A failed shutdown must be retried before any replacement is admitted.
retiring: Vec<Arc<ManagedCpaRuntime>>,
}
fn retry_retiring(selection: &Mutex<ProviderSelection>) -> Result<(), CpaLifecycleError> {
loop {
let runtime = selection.lock().retiring.last().cloned();
let Some(runtime) = runtime else {
return Ok(());
};
runtime.suspend_subscription_execution();
match runtime.shutdown() {
Ok(_) | Err(CpaLifecycleError::NotStarted) => {
selection
.lock()
.retiring
.retain(|item| !Arc::ptr_eq(item, &runtime));
}
Err(error) => return Err(error),
}
}
}
fn provider_selections() -> BTreeMap<CpaAccountKind, Mutex<ProviderSelection>> {
[CpaAccountKind::Codex, CpaAccountKind::Claude]
.into_iter()
.map(|kind| (kind, Mutex::new(ProviderSelection::default())))
.collect()
}
impl ManagedCpaRuntimeSet {
pub fn new(runtimes: Vec<Arc<ManagedCpaRuntime>>) -> Result<Self, CpaLifecycleError> {
let mut kinds = std::collections::BTreeSet::new();
for runtime in &runtimes {
let kind = runtime
.managed_kind()
.ok_or(CpaLifecycleError::InvalidSpec)?;
if !kinds.insert(kind) {
return Err(CpaLifecycleError::InvalidSpec);
}
}
// Corrupt or temporarily unavailable optional login state must not take Local Control
// or native subscriptions down. Saved managed candidates still remain fail-closed.
let logins = runtimes.first().and_then(|runtime| {
let root = runtime.spec.state_root.parent()?.join("managed-logins");
managed_sessions::ManagedLoginRegistry::load(root, &runtimes).ok()
});
Ok(Self {
runtimes,
logins,
selected: provider_selections(),
})
}
pub fn for_kind(&self, kind: CpaAccountKind) -> Option<Arc<ManagedCpaRuntime>> {
self.runtimes
.iter()
.find(|runtime| runtime.managed_kind() == Some(kind) && !runtime.is_managed_oauth())
.cloned()
}
pub fn for_connector(&self, connector: &str) -> Option<Arc<ManagedCpaRuntime>> {
let kind = CpaAccountKind::from_connector(connector)?;
let selection = self.selected.get(&kind)?.lock();
if selection.saved.is_some() {
selection.runtime.clone()
} else {
self.for_kind(kind)
}
}
pub fn runtime_for_candidate(&self, candidate: &str) -> Option<Arc<ManagedCpaRuntime>> {
let kind = CpaAccountKind::from_candidate(candidate)?;
if candidate.starts_with(&format!("candidate/cpa/{}/managed/", kind.stock_provider())) {
self.logins.as_ref()?.for_candidate(candidate)
} else {
self.for_kind(kind)
}
}
/// Project a durably saved source as one provider-serialized lifecycle operation.
/// Callers release their storage locks first. The revision guard is shared across
/// native and managed instances, so delayed completion cannot undo a newer save.
pub fn apply_saved_source(
&self,
source_id: &str,
candidate: &str,
account_ref: &str,
revision: u64,
state: CpaSourceManagementState,
) -> Result<(), CpaLifecycleError> {
let kind = CpaAccountKind::from_candidate(candidate)
.ok_or(CpaLifecycleError::InvalidSourceManagement)?;
if source_id.is_empty() || revision == 0 {
return Err(CpaLifecycleError::InvalidSourceManagement);
}
let next = SavedSourceProjection {
source_id: source_id.to_owned(),
revision,
candidate: candidate.to_owned(),
account_ref: account_ref.to_owned(),
state,
};
let selection = self
.selected
.get(&kind)
.ok_or(CpaLifecycleError::InvalidSourceManagement)?;
let (context, owner, mut runtime) = {
let mut selection = selection.lock();
if let Some(previous) = &selection.saved
&& (previous.source_id != source_id
|| previous.revision > revision
|| (previous.revision == revision && previous != &next))
{
return Err(CpaLifecycleError::StaleSourceManagement);
}
let same_candidate = selection.saved.as_ref().map_or_else(
|| {
!candidate
.starts_with(&format!("candidate/cpa/{}/managed/", kind.stock_provider()))
},
|previous| previous.candidate == candidate,
);
let previous = if selection.saved.is_some() {
selection.runtime.clone()
} else {
self.for_kind(kind)
};
let changed = selection.saved.as_ref() != Some(&next);
if changed {
// Revoke before releasing this short publication lock. Resolving
// a new login or waiting for stop/recovery never delays revocation.
if let Some(previous) = &previous {
previous.suspend_subscription_execution();
}
selection.revision.fetch_add(1, Ordering::AcqRel);
selection.saved = Some(next.clone());
if !same_candidate {
selection.runtime = None;
} else if selection.runtime.is_none() {
selection.runtime = previous.clone();
}
}
if (!same_candidate || state != CpaSourceManagementState::Enabled)
&& let Some(previous) = previous
&& !selection
.retiring
.iter()
.any(|item| Arc::ptr_eq(item, &previous))
{
selection.retiring.push(previous);
}
let context = crate::CpaRequestContext::new(Instant::now() + Duration::from_secs(90))
.observing(
Arc::clone(&selection.revision),
selection.revision.load(Ordering::Acquire),
);
(
context,
Arc::clone(&selection.lifecycle),
selection.runtime.clone(),
)
};
context.run(|| {
if runtime.is_none() {
runtime = self.runtime_for_candidate(candidate);
}
context.ensure_active()?;
{
let mut selection = selection.lock();
context.ensure_active()?;
selection.runtime = runtime.clone();
if state != CpaSourceManagementState::Enabled
&& let Some(runtime) = &runtime
{
runtime.apply_account_management(account_ref, revision, state)?;
if !selection
.retiring
.iter()
.any(|item| Arc::ptr_eq(item, runtime))
{
selection.retiring.push(runtime.clone());
}
}
}
let _owner = crate::request_context::lock(&owner)?;
retry_retiring(selection)?;
let runtime = runtime.ok_or(CpaLifecycleError::InvalidSourceManagement)?;
{
let _selection = selection.lock();
context.ensure_active()?;
runtime.apply_account_management(account_ref, revision, state)?;
}
if state == CpaSourceManagementState::Enabled {
runtime.ensure_saved_runtime_ready(account_ref, revision)?;
}
context.ensure_active()
})
}
/// A stale maintenance snapshot must not suspend the newly selected login.
pub fn suspend_saved_source(&self, source_id: &str, candidate: &str, revision: u64) {
let Some(kind) = CpaAccountKind::from_candidate(candidate) else {
return;
};
let Some(selection) = self.selected.get(&kind) else {
return;
};
let selection = selection.lock();
if selection.saved.as_ref().is_some_and(|saved| {
saved.source_id == source_id
&& saved.candidate == candidate
&& saved.revision == revision
}) && let Some(runtime) = &selection.runtime
{
runtime.suspend_subscription_execution();
}
}
/// Retry failed stops for all saved states without starting a process or reopening
/// execution. Return only affected source identities for safe maintenance status.
pub fn retry_saved_shutdowns(&self) -> Vec<String> {
let mut failures = Vec::new();
for selection in self.selected.values() {
let owner = Arc::clone(&selection.lock().lifecycle);
// Maintenance must not queue behind an active projection/recovery.
let Some(_owner) = owner.try_lock() else {
continue;
};
let context = crate::CpaRequestContext::new(Instant::now() + Duration::from_secs(30));
if context.run(|| retry_retiring(selection)).is_err()
&& let Some(saved) = &selection.lock().saved
{
failures.push(saved.source_id.clone());
}
}
failures
}
pub fn maintain_login_sessions(&self) -> Result<(), CpaLifecycleError> {
self.logins
.as_ref()
.map_or(Ok(()), |logins| logins.maintain())
}
pub fn start_login(
&self,
kind: CpaAccountKind,
) -> Result<(CpaLoginSession, String), CpaLifecycleError> {
self.logins
.as_ref()
.ok_or(CpaLifecycleError::InvalidSpec)?
.start(&self.runtimes, kind)
}
pub fn login_sessions(&self, kind: CpaAccountKind) -> Vec<CpaLoginSession> {
self.logins
.as_ref()
.map(|logins| logins.list(kind))
.unwrap_or_default()
}
pub fn login_session(&self, id: &str) -> Option<CpaLoginSession> {
self.logins.as_ref()?.session(id)
}
pub fn login_status(&self, id: &str) -> Result<CpaLoginSession, CpaLifecycleError> {
self.logins
.as_ref()
.ok_or(CpaLifecycleError::InvalidSpec)?
.status(id)
}
pub fn submit_login_callback(&self, id: &str, value: &str) -> Result<(), CpaLifecycleError> {
self.logins
.as_ref()
.ok_or(CpaLifecycleError::InvalidSpec)?
.callback(id, value)
}
pub fn cancel_login(
&self,
id: &str,
forget: bool,
) -> Result<CpaLoginSession, CpaLifecycleError> {
self.logins
.as_ref()
.ok_or(CpaLifecycleError::InvalidSpec)?
.cancel(id, forget)
}
fn selected_runtimes(&self) -> Vec<Arc<ManagedCpaRuntime>> {
[CpaAccountKind::Codex, CpaAccountKind::Claude]
.into_iter()
.filter_map(|kind| self.for_connector(kind.connector_id()))
.collect()
}
pub fn shutdown(&self) -> Result<(), CpaLifecycleError> {
let mut error = None;
let mut all = self.runtimes.clone();
if let Some(logins) = &self.logins {
all.extend(logins.all_runtimes());
}
for runtime in all {
if let Err(e) = runtime.shutdown()
&& !matches!(e, CpaLifecycleError::NotStarted)
{
error = Some(e);
}
}
error.map_or(Ok(()), Err)
}
}
impl From<Arc<ManagedCpaRuntime>> for ManagedCpaRuntimeSet {
fn from(runtime: Arc<ManagedCpaRuntime>) -> Self {
Self {
runtimes: vec![runtime],
logins: None,
selected: provider_selections(),
}
}
}
impl CpaRegisteredSourcePort for ManagedCpaRuntimeSet {
fn discover_registered_sources_for(
&self,
kind: CpaAccountKind,
) -> Result<Vec<CpaRegisteredSourceV1>, CpaLifecycleError> {
self.for_connector(kind.connector_id())
.ok_or(CpaLifecycleError::NotStarted)?
.discover_registered_sources_for(kind)
}
fn discover_registered_sources(&self) -> Result<Vec<CpaRegisteredSourceV1>, CpaLifecycleError> {
let mut sources = Vec::new();
for runtime in self.selected_runtimes() {
// A missing/failed optional subscription must not remove healthy sibling facts.
if let Ok(found) = runtime.discover_registered_sources() {
sources.extend(found);
}
}
Ok(sources)
}
fn begin_routing_batch(&self) -> Result<CpaRoutingBatch<'_>, CpaLifecycleError> {
let mut batch: Option<CpaRoutingBatch<'_>> = None;
for runtime in self.selected_runtimes() {
if let Ok(next) = super::runtime::CpaRoutingBatch::begin_owned(runtime) {
if let Some(batch) = &mut batch {
batch.extend(next);
} else {
batch = Some(next);
}
}
}
batch.ok_or(CpaLifecycleError::NotStarted)
}
}
impl CpaDownstreamCredentialPort for ManagedCpaRuntimeSet {
fn lease_downstream_capability(
&self,
request: ExactCpaCredentialRequest<'_>,
) -> Result<Option<CpaDownstreamCredentialCapability>, CpaAttemptError> {
self.for_connector(request.connector_id)
.ok_or(CpaAttemptError::UnregisteredTarget)?
.lease_downstream_capability(request)
}
}