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 hiroute_application_api::{
WORKER_EXECUTOR_AVAILABILITY_SCHEMA_V1, WorkerExecutorAvailabilityListV1,
WorkerExecutorAvailabilityReasonV1 as Reason, WorkerExecutorAvailabilityStateV1 as State,
WorkerExecutorAvailabilityV1, WorkerExecutorCapabilityAvailabilityV1,
};
use hiroute_domain::delegation::WorkerHarnessV1;
use std::sync::Arc;
use super::{WORKER_HARNESSES, WorkerInstallationSelectionSource, check_installation};
pub(crate) struct WorkerExecutorAvailabilityRegistry {
selections: Arc<dyn WorkerInstallationSelectionSource>,
}
#[cfg(test)]
struct NoWorkerInstallationSelections;
#[cfg(test)]
impl WorkerInstallationSelectionSource for NoWorkerInstallationSelections {
fn selection(
&self,
_harness: WorkerHarnessV1,
) -> Result<
Option<super::WorkerInstallationSelection>,
hiroute_domain::delegation::DelegationErrorV1,
> {
Ok(None)
}
}
impl WorkerExecutorAvailabilityRegistry {
pub(crate) fn new(selections: Arc<dyn WorkerInstallationSelectionSource>) -> Self {
Self { selections }
}
/// A test fixture with no configured selection. Production composition supplies the durable
/// Local Control selection source instead.
#[cfg(test)]
pub(crate) fn unconfigured() -> Self {
Self::new(Arc::new(NoWorkerInstallationSelections))
}
pub(crate) fn runtime_unavailable() -> WorkerExecutorAvailabilityListV1 {
executor_list(
WORKER_HARNESSES
.map(|harness| unavailable(harness, State::Unknown, Reason::RuntimeUnavailable)),
)
}
pub(crate) fn snapshot(&self) -> WorkerExecutorAvailabilityListV1 {
executor_list(WORKER_HARNESSES.map(|harness| {
let selection = match self.selections.selection(harness) {
Ok(selection) => selection,
Err(_) => {
return unavailable(harness, State::Unavailable, Reason::RuntimeUnavailable);
}
};
let Some(selection) = selection else {
return unavailable(
harness,
State::Unavailable,
Reason::InstallationNotConfigured,
);
};
if check_installation(&selection.config).is_err() {
return unavailable(harness, State::Unavailable, Reason::ArtifactUnavailable);
}
if harness == WorkerHarnessV1::OpenCode
&& hiroute_integrations::opencode_native_format(&selection.config.harness_binary)
.is_err()
{
return unavailable(harness, State::Unavailable, Reason::CapabilityUnverified);
}
let ready = WorkerExecutorCapabilityAvailabilityV1 {
state: State::Ready,
reason: None,
};
WorkerExecutorAvailabilityV1 {
harness,
state: State::Ready,
reason: None,
start_approve_all: ready.clone(),
cancel: ready,
continue_session: WorkerExecutorCapabilityAvailabilityV1 {
state: State::Unknown,
reason: Some(Reason::CapabilityUnverified),
},
restricted_policy: WorkerExecutorCapabilityAvailabilityV1 {
state: State::Unknown,
reason: Some(Reason::RestrictedPolicyUnverified),
},
}
}))
}
}
fn unavailable(
harness: WorkerHarnessV1,
state: State,
reason: Reason,
) -> WorkerExecutorAvailabilityV1 {
let capability = WorkerExecutorCapabilityAvailabilityV1 {
state,
reason: Some(reason),
};
WorkerExecutorAvailabilityV1 {
harness,
state,
reason: Some(reason),
start_approve_all: capability.clone(),
cancel: capability.clone(),
continue_session: capability.clone(),
restricted_policy: capability,
}
}
fn executor_list(
executors: impl IntoIterator<Item = WorkerExecutorAvailabilityV1>,
) -> WorkerExecutorAvailabilityListV1 {
let list = WorkerExecutorAvailabilityListV1 {
schema: WORKER_EXECUTOR_AVAILABILITY_SCHEMA_V1.into(),
executors: executors.into_iter().collect(),
};
debug_assert!(list.valid());
list
}
#[cfg(test)]
mod tests {
use super::*;
use crate::delegation::installation::{WorkerInstallationConfig, WorkerInstallationSelection};
use hiroute_domain::delegation::DelegationErrorV1;
use std::fs;
struct StaticSelections(Vec<WorkerInstallationConfig>);
impl WorkerInstallationSelectionSource for StaticSelections {
fn selection(
&self,
harness: WorkerHarnessV1,
) -> Result<Option<WorkerInstallationSelection>, DelegationErrorV1> {
Ok(self
.0
.iter()
.find(|config| config.harness == harness)
.cloned()
.map(|config| WorkerInstallationSelection {
config,
revision: 1,
}))
}
}
fn registry(
configurations: Vec<WorkerInstallationConfig>,
) -> WorkerExecutorAvailabilityRegistry {
WorkerExecutorAvailabilityRegistry::new(Arc::new(StaticSelections(configurations)))
}
#[test]
fn native_qoder_readiness_requires_only_its_selected_cli_and_rejects_mixed_launch_forms() {
let root = tempfile::tempdir().unwrap();
let cli = root.path().join("qodercli");
fs::write(&cli, b"unexecuted native fixture").unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(&cli, fs::Permissions::from_mode(0o700)).unwrap();
}
let mut config = WorkerInstallationConfig::qoder_native(&cli);
let list = registry(vec![config.clone()]).snapshot();
let fact = list
.executors
.iter()
.find(|entry| entry.harness == WorkerHarnessV1::QoderCli)
.unwrap();
assert_eq!(fact.state, State::Ready);
assert_eq!(fact.continue_session.state, State::Unknown);
assert_eq!(fact.restricted_policy.state, State::Unknown);
config.adapter = Some(cli);
assert_eq!(
check_installation(&config),
Err(DelegationErrorV1::DependenciesInvalid)
);
}
#[test]
#[cfg(unix)]
fn worker_installation_accepts_every_diagnostic_version_without_running_it() {
use std::os::unix::fs::PermissionsExt;
let root = tempfile::tempdir().unwrap();
let binary = root.path().join("worker");
let marker = root.path().join("version-was-run");
for harness in [WorkerHarnessV1::CodexCli, WorkerHarnessV1::ClaudeCode] {
for output in ["0.0.1", "99.1.2", "", "not a version"] {
fs::write(
&binary,
format!(
"#!/bin/sh\ntouch '{}'\nprintf '%s' '{}'\n",
marker.display(),
output
),
)
.unwrap();
fs::set_permissions(&binary, fs::Permissions::from_mode(0o700)).unwrap();
let config = WorkerInstallationConfig {
harness,
adapter: Some(binary.clone()),
harness_binary: binary.clone(),
node_binary: None,
};
assert!(check_installation(&config).is_ok());
let snapshot = registry(vec![config]).snapshot();
assert_eq!(
snapshot
.executors
.iter()
.find(|item| item.harness == harness)
.unwrap()
.state,
State::Ready
);
assert!(!marker.exists());
}
}
}
#[test]
fn installed_is_launchable_not_behavior_verified_and_contents_are_not_pinned() {
let root = tempfile::tempdir().unwrap();
let adapter = root.path().join("adapter");
fs::write(&adapter, b"not a working adapter").unwrap();
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(&adapter, fs::Permissions::from_mode(0o700)).unwrap();
}
let config = WorkerInstallationConfig {
harness: WorkerHarnessV1::CodexCli,
adapter: Some(adapter.clone()),
harness_binary: adapter.clone(),
node_binary: None,
};
let registry = registry(vec![config]);
let before = registry.snapshot();
assert!(before.valid());
assert_eq!(before.executors[0].state, State::Ready);
assert_eq!(before.executors[0].continue_session.state, State::Unknown);
assert_eq!(before.executors[0].restricted_policy.state, State::Unknown);
assert_eq!(
before.executors[1].reason,
Some(Reason::InstallationNotConfigured)
);
fs::write(&adapter, b"replacement contents").unwrap();
assert_eq!(registry.snapshot(), before);
#[cfg(unix)]
{
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(&adapter, fs::Permissions::from_mode(0o600)).unwrap();
assert_eq!(
registry.snapshot().executors[0].reason,
Some(Reason::ArtifactUnavailable)
);
fs::set_permissions(&adapter, fs::Permissions::from_mode(0o700)).unwrap();
assert_eq!(registry.snapshot(), before);
}
fs::remove_file(&adapter).unwrap();
assert_eq!(
registry.snapshot().executors[0].reason,
Some(Reason::ArtifactUnavailable)
);
}
#[test]
#[cfg(unix)]
fn unreadable_executable_is_not_opened_and_fifo_is_rejected_without_blocking() {
use std::os::unix::fs::PermissionsExt;
let root = tempfile::tempdir().unwrap();
let binary = root.path().join("worker");
fs::write(&binary, b"#!/bin/sh\nexit 1\n").unwrap();
fs::set_permissions(&binary, fs::Permissions::from_mode(0o100)).unwrap();
let config = WorkerInstallationConfig {
harness: WorkerHarnessV1::ClaudeCode,
adapter: Some(binary.clone()),
harness_binary: binary,
node_binary: None,
};
assert!(check_installation(&config).is_ok());
let fifo = root.path().join("fifo");
nix::unistd::mkfifo(&fifo, nix::sys::stat::Mode::S_IRWXU).unwrap();
let registry = registry(vec![WorkerInstallationConfig {
adapter: Some(fifo),
..config
}]);
assert_eq!(
registry.snapshot().executors[1].reason,
Some(Reason::ArtifactUnavailable)
);
}
}