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
//! Component regressions over the production completion entry and real Client Core transport.
//! The scoped socket server models an A record arriving after the close-time sweep.
use super::*;
use hiroute_client_core::{Client, LocalEndpoint};
use serde_json::{Value, json};
use std::os::unix::fs::PermissionsExt;
use std::sync::atomic::{AtomicUsize, Ordering};
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
use tokio::net::UnixListener;
use zeroize::Zeroizing;
const RELEASE_GRANT: &str = "completion-release-grant";
struct CompletionAuthority(Arc<AtomicUsize>);
impl HostAuthority for CompletionAuthority {
fn as_any(&self) -> &dyn std::any::Any {
self
}
fn has_authority(&self) -> bool {
true
}
fn register_operation(
&self,
digest: &CanonicalDigest,
revisions: &RevisionSetV1,
operation: &'static str,
) -> Result<Zeroizing<String>, String> {
if operation == APPLY_SUBSCRIPTION_CHECK_OPERATION_V2 {
assert_eq!(revisions.target, 2);
self.0.fetch_add(1, Ordering::SeqCst);
return Ok(Zeroizing::new("next-check-grant".into()));
}
let validation: ComputeValidationRefV2 =
serde_json::from_value(result(false)["validation"].clone()).unwrap();
assert_eq!(operation, RELEASE_SUBSCRIPTION_CHECK_OPERATION_V2);
assert_eq!(digest, &CanonicalDigest::of(&validation).unwrap());
assert_eq!(revisions.target, 1);
assert!(revisions.dependencies.is_empty());
self.0.fetch_add(1, Ordering::SeqCst);
Ok(Zeroizing::new(RELEASE_GRANT.into()))
}
fn register_input(
&self,
_: &ComputeCandidateRefV2,
_: Zeroizing<String>,
) -> Result<(), String> {
panic!("completion must not register a new protected input")
}
fn release_model_input(&self, _: &ComputeCandidateRefV2) -> Result<(), String> {
panic!("completion must not release an unrelated protected input")
}
}
struct Fixture {
_root: tempfile::TempDir,
client: Client,
calls: Arc<AtomicUsize>,
releases: Arc<AtomicUsize>,
registrations: Arc<AtomicUsize>,
created: Arc<AtomicBool>,
check_result: Arc<std::sync::Mutex<Value>>,
server: tokio::task::JoinHandle<()>,
}
impl Fixture {
fn new() -> Self {
let root = tempfile::Builder::new()
.prefix("hrsc-")
.tempdir_in(std::fs::canonicalize("/tmp").unwrap())
.unwrap();
let runtime = root.path().join("run");
let directory = runtime.join("hiroute");
std::fs::create_dir_all(&directory).unwrap();
std::fs::set_permissions(&directory, std::fs::Permissions::from_mode(0o700)).unwrap();
let endpoint = LocalEndpoint::for_child(&runtime, std::process::id());
let listener = UnixListener::bind(endpoint.path()).unwrap();
std::fs::set_permissions(endpoint.path(), std::fs::Permissions::from_mode(0o600)).unwrap();
let client = Client::new("desktop-test", endpoint);
let calls = Arc::new(AtomicUsize::new(0));
let releases = Arc::new(AtomicUsize::new(0));
let created = Arc::new(AtomicBool::new(false));
let check_result = Arc::new(std::sync::Mutex::new(result(false)));
let server_result = check_result.clone();
let (server_calls, server_releases, server_created) =
(calls.clone(), releases.clone(), created.clone());
let server = tokio::spawn(async move {
loop {
let (stream, _) = listener.accept().await.unwrap();
let mut stream = BufReader::new(stream);
let mut line = String::new();
stream.read_line(&mut line).await.unwrap();
let hello: ClientHelloV1 = serde_json::from_str(&line).unwrap();
write(
&mut stream,
serde_json::to_value(negotiate_hello(&hello).unwrap()).unwrap(),
)
.await;
line.clear();
stream.read_line(&mut line).await.unwrap();
let request: LocalControlWireRequestV2 = serde_json::from_str(&line).unwrap();
server_calls.fetch_add(1, Ordering::SeqCst);
let data = match request.operation_id.as_str() {
"FindOperationByIdempotency" => json!({
"digest_matches": true,
"operation": if server_created.load(Ordering::SeqCst) { Some(json!({
"operation_id": "operation-a",
"state": server_result.lock().unwrap()["approval_operation"]["state"],
"sequence": 1,
"cancellable": false, "accepted_digest": CanonicalDigest::of_bytes(b"accepted"),
"safe_error_code": null
})) } else { None }
}),
LIST_COMPUTE_SUBSCRIPTIONS_OPERATION_V2 => json!({
"candidates": [], "discovery_state": "complete"
}),
GET_SUBSCRIPTION_CHECK_RESULT_OPERATION_V2 => {
server_result.lock().unwrap().clone()
}
"GetClientServiceStatus" => json!({
"schema": "hiroute.client-service-status/v1", "daemon_role": "all",
"recovery_ready": true, "mutation_available": true, "gateway": "ready",
"active_publication": null, "revisions": { "target": 1, "dependencies": {} }
}),
RELEASE_SUBSCRIPTION_CHECK_OPERATION_V2 => {
assert_eq!(request.payload["validation_ref"], "validation-a");
let grant = request.protected_grant.as_ref().unwrap();
assert_eq!(grant.principal_kind, PrincipalKind::Desktop);
assert_eq!(grant.capability, RELEASE_GRANT);
server_releases.fetch_add(1, Ordering::SeqCst);
result(true)
}
operation => panic!("unexpected completion operation: {operation}"),
};
write(
&mut stream,
json!({
"schema_version": LOCAL_CONTROL_SCHEMA_V2, "request_id": request.request_id,
"status": "succeeded", "data": data, "operation": null,
"warnings": [], "next_actions": [], "error": null
}),
)
.await;
}
});
Self {
_root: root,
client,
calls,
releases,
registrations: Arc::new(AtomicUsize::new(0)),
created,
check_result,
server,
}
}
fn session(&self) -> Session {
Session::new(
self.client.clone(),
Arc::new(CompletionAuthority(self.registrations.clone())),
)
}
fn set_check_result(&self, value: Value) {
serde_json::from_value::<ComputeSubscriptionCheckResultV2>(value.clone())
.unwrap()
.validate_shape()
.unwrap();
*self.check_result.lock().unwrap() = value;
}
}
fn next_check(session: &mut Session) -> SubscriptionCheckConfirmation {
let candidate = "candidate/cpa/claude/managed/second-login";
let preview = serde_json::from_value(json!({
"candidate": {"candidate_ref": candidate, "candidate_revision": 1},
"display_scope": "Claude Code subscription",
"spec": {
"schema_version": {"major": 1, "minor": 0},
"command_id": "compute.subscription.check.apply",
"resource_id": candidate,
"desired_state": {}
},
"accept_digest": CanonicalDigest::of_bytes(b"second-check"),
"expected_revisions": {"target": 2, "dependencies": {}}
}))
.unwrap();
let close_requested = session.resume_subscription_interaction();
session
.prepare_subscription_check_confirmation(
preview,
"en".into(),
"b".repeat(64),
close_requested,
)
.unwrap()
}
fn saved_result() -> Value {
let mut value = result(false);
value["status"] = json!("retained");
value["save_operation"] = json!({
"operation_id": "operation-save", "state": "succeeded", "sequence": 1,
"cancellable": false
});
value
}
fn verified_result() -> Value {
let mut value = result(false);
value["status"] = json!("verified");
value["checked_candidate"] = json!({
"candidate": {"candidate_ref": "candidate/one", "candidate_revision": 2},
"correlation": {
"candidate_ref": "candidate/one", "edit_revision": 1,
"check_id": "check-a", "input_digest": CanonicalDigest::of_bytes(b"checked")
},
"producer": "cpa", "provenance": "connector_owned",
"display_name": "Codex subscription", "models": [],
"input_state": "provided", "fact_state": "complete",
"validation": value["validation"]
});
value
}
#[tokio::test]
async fn saved_subscription_check_allows_the_next_provider_without_releasing_saved_access() {
let fixture = Fixture::new();
fixture.set_check_result(saved_result());
fixture.created.store(true, Ordering::SeqCst);
let mut session = fixture.session();
let _ = submitted(&mut session);
let context = next_check(&mut session);
let pending = session
.begin_subscription_check_confirmation(context, true)
.await
.expect("a saved Codex subscription must not block the next Claude check");
assert_eq!(
pending.request.spec.resource_id.as_deref(),
Some("candidate/cpa/claude/managed/second-login")
);
assert_eq!(fixture.releases.load(Ordering::SeqCst), 0);
// A late observation of the old saved check must not clear the new identity.
session
.finish_subscription_hint(&serde_json::from_value(saved_result()).unwrap())
.unwrap();
assert_eq!(
session.subscription_hint.as_ref().unwrap().idempotency_key,
"b".repeat(64)
);
}
#[tokio::test]
async fn observing_a_saved_check_finishes_only_its_interaction_without_releasing_access() {
let fixture = Fixture::new();
fixture.set_check_result(saved_result());
fixture.created.store(true, Ordering::SeqCst);
let mut session = fixture.session();
let _ = submitted(&mut session);
let result = session.recover_subscription_check().await.unwrap().unwrap();
assert_eq!(result.status, ComputeSubscriptionCheckStatusV2::Retained);
assert!(session.subscription_hint.is_none());
session.close_subscription_check().await.unwrap();
assert_eq!(fixture.releases.load(Ordering::SeqCst), 0);
assert_eq!(fixture.registrations.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn an_unsaved_verified_check_still_blocks_replacement() {
let fixture = Fixture::new();
fixture.set_check_result(verified_result());
fixture.created.store(true, Ordering::SeqCst);
let mut session = fixture.session();
let _ = submitted(&mut session);
let context = next_check(&mut session);
let failure = session
.begin_subscription_check_confirmation(context, true)
.await;
assert!(
matches!(failure, Err(DesktopFailure::Native { code }) if code == "SUBSCRIPTION_CHECK_ACTIVE")
);
assert_eq!(fixture.releases.load(Ordering::SeqCst), 0);
assert_eq!(fixture.registrations.load(Ordering::SeqCst), 0);
}
#[tokio::test]
async fn an_in_progress_check_still_blocks_replacement() {
let fixture = Fixture::new();
let mut checking = result(false);
checking["status"] = json!("checking");
checking["validation"] = Value::Null;
checking["approval_operation"]["state"] = json!("running");
fixture.set_check_result(checking);
fixture.created.store(true, Ordering::SeqCst);
let mut session = fixture.session();
let _ = submitted(&mut session);
let context = next_check(&mut session);
let failure = session
.begin_subscription_check_confirmation(context, true)
.await;
assert!(
matches!(failure, Err(DesktopFailure::Native { code }) if code == "SUBSCRIPTION_CHECK_ACTIVE")
);
assert_eq!(fixture.registrations.load(Ordering::SeqCst), 0);
}
impl Drop for Fixture {
fn drop(&mut self) {
self.server.abort();
}
}
async fn write(stream: &mut BufReader<tokio::net::UnixStream>, value: Value) {
let mut bytes = serde_json::to_vec(&value).unwrap();
bytes.push(b'\n');
stream.get_mut().write_all(&bytes).await.unwrap();
}
fn operation() -> OperationReferenceV1 {
OperationReferenceV1 {
operation_id: "operation-a".into(),
state: "succeeded".into(),
sequence: 1,
cancellable: false,
}
}
fn result(released: bool) -> Value {
json!({
"candidate": {"candidate_ref": "candidate/one", "candidate_revision": 1},
"approval_operation": operation(), "status": if released { "released" } else { "source_changed" },
"validation": if released { None } else { Some(json!({
"approval_operation": operation(), "validation_ref": "validation-a", "validation_revision": 1
})) }
})
}
fn submitted(session: &mut Session) -> SubscriptionCheckCompletion {
let digest = CanonicalDigest::of_bytes(b"accepted");
session.subscription_hint = Some(SubmittedOperation {
plan_id: "candidate/one".into(),
principal_kind: PrincipalKind::Desktop,
operation_kind: APPLY_SUBSCRIPTION_CHECK_OPERATION_V2.into(),
idempotency_key: "a".repeat(64),
accepted_digest: digest.clone(),
operation_id: None,
after_sequence: 0,
intent: None,
latest_edit_not_applied: false,
});
SubscriptionCheckCompletion {
owner: session.confirmation.owner(),
idempotency_key: "a".repeat(64),
accepted_digest: digest.clone(),
close_requested: session.subscription_close_requested.clone(),
outcome: SubscriptionCheckSubmission::Submitted(Box::new(Ok(MachineEnvelopeV2 {
schema_version: LOCAL_CONTROL_SCHEMA_V2,
request_id: Some("request-a".into()),
status: MachineStatus::Succeeded,
data: Some(ApplyResultV1 {
operation_id: "operation-a".into(),
accepted_digest: digest,
state: "succeeded".into(),
}),
operation: Some(operation()),
warnings: vec![],
next_actions: vec![],
error: None,
}))),
}
}
#[tokio::test]
async fn close_before_operation_record_releases_late_completed_validation() {
let fixture = Fixture::new();
let mut session = fixture.session();
let completion = submitted(&mut session);
// The submitted request is in flight, but the close-time query cannot find A yet.
session.invalidate_confirmation();
session.close_subscription_check().await.unwrap();
assert_eq!(fixture.releases.load(Ordering::SeqCst), 0);
assert_eq!(fixture.registrations.load(Ordering::SeqCst), 0);
assert!(session.subscription_hint.is_some());
fixture.created.store(true, Ordering::SeqCst);
let sessions = tokio::sync::Mutex::new(Some(session));
complete_subscription_check(&sessions, completion)
.await
.unwrap();
assert_eq!(fixture.releases.load(Ordering::SeqCst), 1);
assert_eq!(fixture.registrations.load(Ordering::SeqCst), 1);
assert!(
sessions
.lock()
.await
.as_ref()
.unwrap()
.subscription_hint
.is_none()
);
}
#[tokio::test]
async fn replacement_session_rejects_completion_before_queries_or_hint_changes() {
let fixture = Fixture::new();
let mut old = fixture.session();
let completion = submitted(&mut old);
drop(old); // The host lock also belongs to exactly one scoped fixture Session.
let mut replacement = fixture.session();
let _ = submitted(&mut replacement);
replacement
.subscription_hint
.as_mut()
.unwrap()
.idempotency_key = "new-hint".into();
let sessions = tokio::sync::Mutex::new(Some(replacement));
let failure = complete_subscription_check(&sessions, completion)
.await
.unwrap_err();
assert!(matches!(failure, DesktopFailure::Native { code } if code == "CONFIRMATION_STALE"));
assert_eq!(fixture.calls.load(Ordering::SeqCst), 0);
assert_eq!(fixture.releases.load(Ordering::SeqCst), 0);
assert_eq!(fixture.registrations.load(Ordering::SeqCst), 0);
assert_eq!(
sessions
.lock()
.await
.as_ref()
.unwrap()
.subscription_hint
.as_ref()
.unwrap()
.idempotency_key,
"new-hint"
);
}