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 std::collections::{BTreeMap, BTreeSet};
use hiroute_domain::{
AGENT_SETTINGS_SCHEMA_V2, AgentAccessGrantMutationV1, AgentAccessGrantScopeV1,
AgentConnectionControlIntentV1, AgentConnectionTransactionSubjectV1, AgentFacetIntent,
AgentModelDefaultSelectionV2, AgentModelGrantV2, AgentModelRouteV2, AgentModelSelectionV2,
AgentPlanId, AgentSettingsSpecV2, CHANGE_SPEC_SCHEMA_V1, IdempotencyScopeV1,
SETTINGS_SERVICE_COMPLETION_SCHEMA, SettingsServiceCompletionV1, TransactionPlanV1,
is_settings_managed_configuration, is_settings_publication, settings_model_publication_intent,
};
use serde_json::json;
use super::*;
use crate::agent_connection::{
CodexModelFileAction, settings_codex_model_file_intent, settings_login_item_intent,
};
const CONTEXT_ID: &str = "agent-context/settings-tail";
const MODEL_FILE_EFFECT: &str = "agent-connection-managed-configuration";
const PUBLICATION_EFFECT: &str = "agent-connection-grant-publication";
fn settings_spec() -> AgentSettingsSpecV2 {
let plan_id = AgentPlanId::parse("plan/tail").unwrap();
AgentSettingsSpecV2 {
native_target: None,
management_skill: None,
schema_version: AGENT_SETTINGS_SCHEMA_V2,
context_id: CONTEXT_ID.to_owned(),
model: AgentFacetIntent::Configure {
settings: AgentModelSelectionV2::CodexDefault {
native_model_mode: hiroute_domain::CodexNativeModelModeV2::HirouteOnly,
fixed_models: Vec::new(),
allowed_plan_ids: BTreeSet::from([plan_id.clone()]),
default_selection: AgentModelDefaultSelectionV2::Plan { plan_id },
},
},
collaboration: AgentFacetIntent::Keep,
restore_native_model: None,
protected_native_model_ids: Vec::new(),
access_token: hiroute_domain::AgentAccessTokenIntentV1::Keep,
}
}
fn settings_plan() -> TransactionPlanV1 {
settings_plan_with_login_item(false)
}
fn settings_plan_with_login_item(host_login_item: bool) -> TransactionPlanV1 {
settings_plan_for_action(host_login_item, false)
}
fn settings_plan_for_action(host_login_item: bool, restoring: bool) -> TransactionPlanV1 {
let original = OperationId::derive(
&WorkspaceId::default(),
&IdempotencyScopeV1::new("interactive-user", "agents.settings.apply", "original").unwrap(),
&CanonicalDigest::of_bytes(b"original"),
);
let mut settings = settings_spec();
if restoring {
settings.model = AgentFacetIntent::Restore {
restore_point_ref: crate::agent_connection::codex_model_restore_point_ref(&original),
};
}
let spec = hiroute_domain::ChangeSpecV1 {
schema_version: CHANGE_SPEC_SCHEMA_V1,
command_id: "agents.settings.apply".to_owned(),
resource_id: Some(CONTEXT_ID.to_owned()),
desired_state: serde_json::to_value(settings).unwrap(),
};
let subject = AgentConnectionTransactionSubjectV1::from_registered_profile(
"agent_codex_default",
"codex-responses-v1",
"builtin/codex-responses/v1",
)
.unwrap();
let control = AgentConnectionControlIntentV1::from_settings_planner(
subject,
&spec,
false,
&json!({"fixture": "settings-tail"}),
)
.unwrap();
let grant = AgentModelGrantV2::seal(
hiroute_domain::AgentIngressProtocolV1::Responses,
BTreeMap::from([(
"hiroute-tail".to_owned(),
AgentModelRouteV2::Plan {
plan_id: AgentPlanId::parse("plan/tail").unwrap(),
alias: hiroute_domain::ModelAlias::parse_custom("hiroute-tail").unwrap(),
revision: 1,
semantic_digest: CanonicalDigest::of_bytes(b"plan-tail"),
},
)]),
)
.unwrap();
let scope =
AgentAccessGrantScopeV1::new(format!("agent-connection/{CONTEXT_ID}"), grant).unwrap();
let mutation = if restoring {
AgentAccessGrantMutationV1::revoke(WorkspaceId::DEFAULT, scope.connection_id(), 1).unwrap()
} else {
AgentAccessGrantMutationV1::ensure(WorkspaceId::DEFAULT, scope, 0).unwrap()
};
let model_file = settings_codex_model_file_intent(
&control,
CONTEXT_ID,
CanonicalDigest::of_bytes(b"model-file-content"),
None,
if restoring {
CodexModelFileAction::Restore {
original_operation: original,
native_model: None,
}
} else {
CodexModelFileAction::Configure {
previous_operation: None,
provider_id: "hiroute".to_owned(),
endpoint: "http://127.0.0.1:8787/v1".to_owned(),
model: None,
model_catalog: None,
}
},
)
.unwrap();
let publication = settings_model_publication_intent(
&control,
CONTEXT_ID,
CanonicalDigest::of_bytes(b"publication-source"),
None,
)
.unwrap();
let mut external = Vec::new();
if host_login_item {
external.push(
settings_login_item_intent(
&control,
CONTEXT_ID,
&hiroute_application_api::AgentLoginItemDeclarationV2 {
before: hiroute_application_api::AgentLoginItemStatusV2::NotRegistered,
after: hiroute_application_api::AgentLoginItemStatusV2::Enabled,
created: true,
},
)
.unwrap(),
);
}
external.extend([model_file, publication]);
TransactionPlanV1::from_agent_connection_planner_with_agent_access_grants(
spec,
control,
vec![mutation],
external,
)
.unwrap()
}
fn inject_settings_operation(ports: &MemoryPorts) -> OperationId {
inject_settings_operation_with_plan(ports, settings_plan())
}
fn inject_settings_operation_with_plan(
ports: &MemoryPorts,
plan: TransactionPlanV1,
) -> OperationId {
let workspace = WorkspaceId::default();
let idempotency = IdempotencyScopeV1::new(
"interactive-user",
"agents.settings.apply",
"settings-tail-1",
)
.unwrap();
let request_digest = CanonicalDigest::of_bytes(b"settings-tail-request");
let operation_id = OperationId::derive(&workspace, &idempotency, &request_digest);
let operation = OperationV1::new(
operation_id.clone(),
workspace.clone(),
idempotency.clone(),
request_digest,
CanonicalDigest::of_bytes(b"settings-tail-accepted"),
RevisionSetV1 {
target: 0,
dependencies: BTreeMap::new(),
},
plan,
)
.unwrap();
let mut state = ports.state.borrow_mut();
state.idempotency.insert(
MemoryPorts::idempotency_key(&workspace, &idempotency),
operation_id.as_str().to_owned(),
);
state
.operations
.insert(operation_id.as_str().to_owned(), operation);
state.writer = Some(operation_id.as_str().to_owned());
state.publication_revision = 7;
operation_id
}
#[test]
fn failed_publication_with_host_login_item_rolls_back_without_blocking_other_writes() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id =
inject_settings_operation_with_plan(&ports, settings_plan_with_login_item(true));
{
let mut state = ports.state.borrow_mut();
state.host_login_item_observed = true;
state.fail_activation = Some(PUBLICATION_EFFECT.to_owned());
}
let failed = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(failed.state, OperationState::RolledBack);
assert_eq!(failed.safe_error_code.as_deref(), Some("ADAPTER_FAILURE"));
assert!(
failed
.steps
.iter()
.all(|step| step.status == OperationStepStatus::Compensated)
);
assert_eq!(ports.state.borrow().writer, None);
}
#[test]
fn startup_rechecks_a_fully_compensated_host_login_item_rollback() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id =
inject_settings_operation_with_plan(&ports, settings_plan_with_login_item(true));
{
let mut state = ports.state.borrow_mut();
state.host_login_item_observed = true;
state.fail_activation = Some(PUBLICATION_EFFECT.to_owned());
}
let rolled_back = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(rolled_back.state, OperationState::RolledBack);
{
// Exact journal shape left by the previous terminal check: all daemon effects were
// compensated, but the host's pre-admission declaration kept NeedsAttention claimed.
let mut state = ports.state.borrow_mut();
state
.operations
.get_mut(operation_id.as_str())
.unwrap()
.state = OperationState::NeedsAttention;
state.writer = Some(operation_id.as_str().to_owned());
}
let restarted = TransactionRuntime::default();
let recovered = coordinator(&ports, &restarted)
.reconcile_startup_and_open()
.unwrap();
assert_eq!(recovered.len(), 1);
assert_eq!(recovered[0].state, OperationState::RolledBack);
assert_eq!(ports.state.borrow().writer, None);
assert!(restarted.writes_open.load(Ordering::Acquire));
}
fn coordinator<'a>(
ports: &'a MemoryPorts,
admission: &'a TransactionRuntime,
) -> TransactionCoordinator<'a, MemoryPorts, MemoryPorts, MemoryPorts, MemoryPorts, MemoryPorts> {
TransactionCoordinator::new(ports, ports, ports, ports, ports, admission)
}
#[test]
fn restore_only_settings_require_restore_authority_before_journal_admission() {
let ports = MemoryPorts::default();
let runtime = TransactionRuntime::default();
let coordinator = open(&ports, &runtime);
let plan = settings_plan_for_action(false, true);
// Unlike the execution-tail fixtures, admission observes the previewed publication.
// Model-file absence is intentional, but the publication must exist at its source digest.
let publication = plan
.external()
.iter()
.find(|intent| is_settings_publication(intent))
.unwrap();
ports.state.borrow_mut().external_fingerprints.insert(
publication.target().to_owned(),
CanonicalDigest::of_bytes(b"publication-source"),
);
let digest = CanonicalDigest::of_bytes(b"restore-authority");
let request = ApplyRequestV1 {
schema_version: CHANGE_SPEC_SCHEMA_V1,
spec: plan.spec().clone(),
accept_digest: digest.clone(),
expected_revisions: ports.current_revisions(&WorkspaceId::default()).unwrap(),
idempotency_key: "restore-authority".to_owned(),
apply_capability: Some("restore-capability".to_owned()),
};
// Even a valid Change capability cannot admit a restore-only plan under the Change kind.
ports.grant_for(
"restore-capability",
&digest,
&request.expected_revisions,
"ApplyAgentConnectionChange",
);
let before = ports.counters();
let wrong =
crate::PreparedTransactionV1::for_setup(request.clone(), digest.clone(), plan.clone())
.unwrap()
.with_revalidation(|| Ok(()));
assert!(matches!(
coordinator.accept_prepared(&WorkspaceId::default(), &principal(), wrong),
Err(TransactionError::InvalidArguments)
));
assert_eq!(ports.counters(), before);
assert!(ports.state.borrow().operations.is_empty());
assert!(ports.state.borrow().writer.is_none());
assert!(
ports.state.borrow().grants[CanonicalDigest::of_bytes(b"restore-capability").as_str()]
.consumed
.is_none()
);
ports.grant_for(
"restore-capability",
&digest,
&request.expected_revisions,
"ApplyAgentConnectionRestore",
);
for replay in [false, true] {
let prepared = crate::PreparedTransactionV1::for_agent_settings_restore(
request.clone(),
digest.clone(),
plan.clone(),
)
.unwrap()
.with_revalidation(|| Ok(()));
let accepted = coordinator
.accept_prepared(&WorkspaceId::default(), &principal(), prepared)
.unwrap();
assert_eq!(accepted.existing, replay);
assert_eq!(
accepted.operation().idempotency.operation_kind,
"ApplyAgentConnectionRestore"
);
}
assert_eq!(ports.state.borrow().operations.len(), 1);
}
fn stored(ports: &MemoryPorts, operation_id: &OperationId) -> OperationV1 {
ports
.state
.borrow()
.operations
.get(operation_id.as_str())
.cloned()
.unwrap()
}
fn effect_applied(ports: &MemoryPorts, operation_id: &OperationId, effect_id: &str) -> bool {
ports
.state
.borrow()
.effects
.get(&MemoryPorts::effect_key(operation_id, effect_id))
.is_some_and(|(_, applied)| *applied)
}
fn effect_staged(ports: &MemoryPorts, operation_id: &OperationId, effect_id: &str) -> bool {
ports
.state
.borrow()
.effects
.get(&MemoryPorts::effect_key(operation_id, effect_id))
.is_some_and(|(_, applied)| !*applied)
}
#[test]
fn settings_publication_serves_before_the_client_file_switch() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id = inject_settings_operation(&ports);
let finished = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(finished.state, OperationState::Succeeded);
assert!(effect_applied(&ports, &operation_id, PUBLICATION_EFFECT));
assert!(effect_applied(&ports, &operation_id, MODEL_FILE_EFFECT));
let state = ports.state.borrow();
let publication = state
.activation_log
.iter()
.position(|effect| effect == PUBLICATION_EFFECT)
.unwrap();
let model_file = state
.activation_log
.iter()
.position(|effect| effect == MODEL_FILE_EFFECT)
.unwrap();
assert!(publication < model_file);
let receipt = SettingsServiceCompletionV1::parse(
finished
.step(OperationStepKind::Activate)
.terminal_result
.as_deref()
.unwrap(),
)
.unwrap();
assert_eq!(receipt.publication_revision, 7);
assert_eq!(
receipt.publication_digest,
CanonicalDigest::of_bytes(PUBLICATION_EFFECT.as_bytes())
);
}
#[test]
fn client_file_failure_parks_the_tail_without_rollback() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id = inject_settings_operation(&ports);
ports.state.borrow_mut().fail_activation = Some(MODEL_FILE_EFFECT.to_owned());
let parked = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(parked.state, OperationState::Activating);
assert!(parked.safe_error_code.is_some());
assert!(effect_applied(&ports, &operation_id, PUBLICATION_EFFECT));
assert!(effect_staged(&ports, &operation_id, MODEL_FILE_EFFECT));
assert!(
SettingsServiceCompletionV1::parse(
parked
.step(OperationStepKind::Activate)
.terminal_result
.as_deref()
.unwrap()
)
.is_some()
);
assert_eq!(ports.state.borrow().writer, None);
let publication_digest = CanonicalDigest::of_bytes(PUBLICATION_EFFECT.as_bytes());
assert!(settings_service_completion_is_current(
&parked,
7,
&publication_digest
));
assert!(!settings_service_completion_is_current(
&parked,
8,
&publication_digest
));
assert!(!settings_service_completion_is_current(
&parked,
7,
&CanonicalDigest::of_bytes(b"displaced")
));
let mut tampered = parked.clone();
tampered.accepted_digest = CanonicalDigest::of_bytes(b"another-accepted-change");
assert!(!settings_service_completion_is_current(
&tampered,
7,
&publication_digest
));
let mut incomplete = parked.clone();
incomplete
.step_mut(OperationStepKind::CompilePublication)
.status = OperationStepStatus::Pending;
assert!(!settings_service_completion_is_current(
&incomplete,
7,
&publication_digest
));
ports.state.borrow_mut().fail_activation = None;
let finished = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(finished.state, OperationState::Succeeded);
assert!(
finished
.steps
.iter()
.all(|step| step.status == OperationStepStatus::Applied)
);
assert!(finished.safe_error_code.is_none());
assert!(effect_applied(&ports, &operation_id, MODEL_FILE_EFFECT));
let activations = ports
.state
.borrow()
.activation_log
.iter()
.filter(|effect| effect == &PUBLICATION_EFFECT)
.count();
assert_eq!(activations, 1);
}
#[test]
fn startup_reports_a_pending_tail_without_touching_files() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id = inject_settings_operation(&ports);
ports.state.borrow_mut().fail_activation = Some(MODEL_FILE_EFFECT.to_owned());
coordinator(&ports, &admission).run(&operation_id).unwrap();
let activations = ports.state.borrow().activation_log.len();
let startup_admission = TransactionRuntime::default();
let startup =
TransactionCoordinator::new(&ports, &ports, &ports, &ports, &ports, &startup_admission);
let recovered = startup.reconcile_startup_and_open().unwrap();
assert_eq!(recovered.len(), 1);
assert_eq!(recovered[0].state, OperationState::Activating);
assert_eq!(
recovered[0].safe_error_code.as_deref(),
Some("SETTINGS_TAIL_PENDING")
);
assert!(effect_staged(&ports, &operation_id, MODEL_FILE_EFFECT));
assert_eq!(ports.state.borrow().activation_log.len(), activations);
assert_eq!(ports.state.borrow().writer, None);
}
#[test]
fn displaced_publication_expires_the_tail_with_zero_file_writes() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id = inject_settings_operation(&ports);
ports.state.borrow_mut().fail_activation = Some(MODEL_FILE_EFFECT.to_owned());
coordinator(&ports, &admission).run(&operation_id).unwrap();
let activations = ports.state.borrow().activation_log.len();
ports.state.borrow_mut().publication_displaced = true;
let expired = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(expired.state, OperationState::Activating);
assert_eq!(
expired.safe_error_code.as_deref(),
Some("SETTINGS_TAIL_EXPIRED")
);
assert!(effect_staged(&ports, &operation_id, MODEL_FILE_EFFECT));
assert_eq!(ports.state.borrow().activation_log.len(), activations);
assert_eq!(ports.state.borrow().writer, None);
}
#[test]
fn tampered_receipt_digest_rolls_the_operation_back() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let operation_id = inject_settings_operation(&ports);
ports.state.borrow_mut().fail_activation = Some(MODEL_FILE_EFFECT.to_owned());
coordinator(&ports, &admission).run(&operation_id).unwrap();
{
let mut state = ports.state.borrow_mut();
let operation = state
.operations
.get_mut(operation_id.as_str())
.expect("parked operation");
let mut receipt = SettingsServiceCompletionV1::parse(
operation
.step(OperationStepKind::Activate)
.terminal_result
.as_deref()
.unwrap(),
)
.unwrap();
receipt.completed_effects_digest = CanonicalDigest::of_bytes(b"tampered");
operation
.step_mut(OperationStepKind::Activate)
.terminal_result = Some(serde_json::to_string(&receipt).unwrap());
}
let rolled_back = coordinator(&ports, &admission).run(&operation_id).unwrap();
assert_eq!(
rolled_back.safe_error_code.as_deref(),
Some("SETTINGS_RECEIPT_INVALID")
);
assert_ne!(rolled_back.state, OperationState::Activating);
assert!(rolled_back.state.is_terminal());
}
#[test]
fn settings_discriminators_accept_only_the_settings_transaction_facets() {
let plan = settings_plan();
let model_file = plan
.external()
.iter()
.find(|intent| intent.effect_id() == MODEL_FILE_EFFECT)
.unwrap();
let publication = plan
.external()
.iter()
.find(|intent| intent.effect_id() == PUBLICATION_EFFECT)
.unwrap();
assert!(is_settings_managed_configuration(model_file));
assert!(!is_settings_managed_configuration(publication));
assert!(is_settings_publication(publication));
assert!(!is_settings_publication(model_file));
}
#[test]
fn settings_receipt_parse_accepts_only_the_registered_schema() {
let receipt = SettingsServiceCompletionV1 {
schema: SETTINGS_SERVICE_COMPLETION_SCHEMA.to_owned(),
publication_revision: 3,
publication_digest: CanonicalDigest::of_bytes(b"publication"),
completed_effects_digest: CanonicalDigest::of_bytes(b"effects"),
};
let encoded = serde_json::to_string(&receipt).unwrap();
assert_eq!(
SettingsServiceCompletionV1::parse(&encoded),
Some(receipt.clone())
);
let mut wrong_schema = receipt.clone();
wrong_schema.schema = format!("hiroute.settings-service-completion/v{}", 999);
assert_eq!(
SettingsServiceCompletionV1::parse(&serde_json::to_string(&wrong_schema).unwrap()),
None
);
assert_eq!(SettingsServiceCompletionV1::parse("applied"), None);
assert_eq!(SettingsServiceCompletionV1::parse("{}"), None);
}
#[test]
fn settings_disable_restores_file_before_publication_and_grant() {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let id = inject_settings_operation_with_plan(&ports, settings_plan_for_action(false, true));
let finished = coordinator(&ports, &admission).run(&id).unwrap();
assert_eq!(finished.state, OperationState::Succeeded);
let log = &ports.state.borrow().activation_log;
let file = log.iter().position(|e| e == MODEL_FILE_EFFECT).unwrap();
let publication = log.iter().position(|e| e == PUBLICATION_EFFECT).unwrap();
let grant = log
.iter()
.position(|e| e.starts_with("agent-access-grant:"))
.unwrap();
assert!(file < publication && publication < grant, "{log:?}");
}
#[test]
fn settings_disable_failures_roll_back_and_release_writer() {
for effect in [
MODEL_FILE_EFFECT.to_owned(),
PUBLICATION_EFFECT.to_owned(),
format!("agent-access-grant:agent-connection/{CONTEXT_ID}"),
] {
let ports = MemoryPorts::default();
let admission = TransactionRuntime::default();
let id = inject_settings_operation_with_plan(&ports, settings_plan_for_action(false, true));
ports.state.borrow_mut().fail_activation = Some(effect.clone());
let failed = coordinator(&ports, &admission).run(&id).unwrap();
assert_eq!(failed.state, OperationState::RolledBack, "{effect}");
assert!(failed.safe_error_code.is_some());
assert!(
SettingsServiceCompletionV1::parse(
failed
.step(OperationStepKind::Activate)
.terminal_result
.as_deref()
.unwrap_or_default()
)
.is_none()
);
assert!(ports.state.borrow().writer.is_none(), "{effect}");
assert!(ports.state.borrow().effects.is_empty(), "{effect}");
if effect == MODEL_FILE_EFFECT {
assert!(ports.state.borrow().activation_log.is_empty());
} else {
assert!(
ports
.state
.borrow()
.activation_log
.iter()
.any(|e| e == MODEL_FILE_EFFECT)
);
}
coordinator(&ports, &admission)
.reconcile_startup_and_open()
.unwrap();
assert!(admission.writes_open.load(Ordering::Acquire));
}
}