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::{
Result,
build::Artifact,
digest, fixtures, nonce,
process::{Process, private_file},
require,
run::Context,
};
use hiroute_application_api::{
CanonicalDigest, ClientHelloV1, LOCAL_CONTROL_SCHEMA_V2, LocalControlWireRequestV2,
MACHINE_ENVELOPE_SCHEMA_V2, MachineEnvelopeV2, OperationIdempotencyLookupV1, PrincipalKind,
ServerHelloV1,
};
use serde_json::{Value, json};
use std::{
fs,
io::{BufRead, BufReader, Write},
os::unix::net::UnixStream,
os::unix::{fs::FileTypeExt, process::ExitStatusExt},
path::Path,
process::Command,
time::{Duration, Instant},
};
fn command(binary: &Path, root: &Path) -> Command {
let mut c = Command::new(binary);
c.env_clear()
.current_dir(root)
.env("HOME", root.join("home"))
.env("XDG_CONFIG_HOME", root.join("config"))
.env("XDG_CACHE_HOME", root.join("cache"))
.env("TMPDIR", root.join("tmp"))
.env("PATH", "/usr/bin:/bin")
.env("HIROUTE_RUNTIME_DIR", root.join("control-runtime"));
c
}
fn prepare(ctx: &mut Context<'_>) -> Result<(Artifact, Artifact)> {
ctx.enter("control_build");
let cli = ctx.build("hiroute-cli", "hiroute")?;
let daemon = ctx.build("hiroute-daemon", "hirouted")?;
ctx.record(
"control_build",
Some(0),
None,
&json!({"cli":cli,"daemon":daemon}),
)?;
for dir in ["home", "config", "cache", "tmp", "control-runtime"] {
fs::create_dir(ctx.runtime.join(dir))?;
use std::os::unix::fs::PermissionsExt;
fs::set_permissions(ctx.runtime.join(dir), fs::Permissions::from_mode(0o700))?;
}
ctx.product_deadline();
Ok((cli, daemon))
}
struct CliObservation {
exit: Option<i32>,
signal: Option<i32>,
envelope: Value,
}
fn observe_cli(
ctx: &mut Context<'_>,
artifact: &Artifact,
id: &'static str,
args: &[&str],
input: Option<&[u8]>,
secret: &str,
) -> Result<CliObservation> {
ctx.verify_artifact(artifact)?;
let mut c = command(&artifact.path, &ctx.runtime);
c.args(args).args([
"--output",
"json",
"--non-interactive",
"--request-id",
&format!("{}-{id}", ctx.run_id),
]);
let input = input
.map(|bytes| -> Result<std::fs::File> {
let path = ctx.private.join(format!("{id}.stdin"));
let mut file = private_file(&path)?;
file.write_all(bytes)?;
file.sync_all()?;
Ok(std::fs::File::open(path)?)
})
.transpose()?;
let mut process = match input {
Some(input) => {
Process::spawn_with_input(&mut c, &ctx.private.join(id), ctx.cancel.clone(), input)?
}
None => Process::spawn(&mut c, &ctx.private.join(id), ctx.cancel.clone())?,
};
let exit = process.wait(ctx.step_deadline(), 1024 * 1024)?;
let (stdout, stderr) = process.output(1024 * 1024)?;
require(
stderr.is_empty()
&& stdout
.split(|b| *b == b'\n')
.filter(|l| !l.is_empty())
.count()
== 1,
"invalid_machine_output",
)?;
let envelope: MachineEnvelopeV2<Value> = serde_json::from_slice(&stdout)?;
require(
envelope.schema_version == MACHINE_ENVELOPE_SCHEMA_V2
&& envelope.request_id.as_deref() == Some(&format!("{}-{id}", ctx.run_id)),
"machine_identity_mismatch",
)?;
require(
response_is_private(
&serde_json::from_slice::<Value>(&stdout)?,
&ctx.runtime,
secret,
matches!(args, ["agents", "scan"] | ["agents", "list"]),
),
"privacy_failure",
)?;
ctx.verify_artifact(artifact)?;
Ok(CliObservation {
exit: exit.code(),
signal: exit.signal(),
envelope: serde_json::to_value(envelope)?,
})
}
fn internal_call(
ctx: &Context<'_>,
endpoint: &Path,
id: &str,
operation_id: &str,
payload: Value,
) -> Result<Value> {
let mut stream = UnixStream::connect(endpoint)?;
serde_json::to_writer(
&mut stream,
&ClientHelloV1 {
api_version: LOCAL_CONTROL_SCHEMA_V2,
machine_schema_version: MACHINE_ENVELOPE_SCHEMA_V2,
client_name: "hiroute-smoke-internal".into(),
client_version: hiroute_application_api::LOCAL_CONTROL_RELEASE_VERSION.into(),
},
)?;
stream.write_all(b"\n")?;
stream.flush()?;
let mut reader = BufReader::new(stream.try_clone()?);
let mut line = String::new();
reader.read_line(&mut line)?;
serde_json::from_str::<ServerHelloV1>(&line)?;
serde_json::to_writer(
&mut stream,
&LocalControlWireRequestV2 {
schema_version: LOCAL_CONTROL_SCHEMA_V2,
request_id: format!("{}-{id}-internal", ctx.run_id),
operation_id: operation_id.into(),
payload,
protected_grant: None,
},
)?;
stream.write_all(b"\n")?;
stream.flush()?;
line.clear();
reader.read_line(&mut line)?;
Ok(serde_json::to_value(serde_json::from_str::<
MachineEnvelopeV2<Value>,
>(&line)?)?)
}
#[allow(clippy::too_many_arguments)]
fn planned_command(
ctx: &mut Context<'_>,
artifact: &Artifact,
endpoint: &Path,
id: &'static str,
args: &[&str],
input: Option<&[u8]>,
secret: &str,
operation_id: &str,
payload: Value,
) -> Result<Value> {
ctx.enter(id);
let public = observe_cli(ctx, artifact, id, args, input, secret)?;
require(
public.exit == Some(2)
&& public.signal.is_none()
&& public.envelope["status"] == "usage_error"
&& public.envelope["error"]["code"] == "UNKNOWN_COMMAND",
"planned_command_publicly_callable",
)?;
let internal = internal_call(ctx, endpoint, id, operation_id, payload)?;
ctx.record(
id,
public.exit,
public.signal,
&json!({"public_lifecycle_gate":public.envelope,"internal_local_control":internal}),
)?;
Ok(internal)
}
#[allow(clippy::too_many_arguments)]
fn released_command(
ctx: &mut Context<'_>,
artifact: &Artifact,
endpoint: &Path,
id: &'static str,
args: &[&str],
input: Option<&[u8]>,
secret: &str,
operation_id: &str,
payload: Value,
) -> Result<Value> {
ctx.enter(id);
let public = observe_cli(ctx, artifact, id, args, input, secret)?;
require(
public.exit == Some(0)
&& public.signal.is_none()
&& public.envelope["status"] == "succeeded"
&& public.envelope["error"].is_null(),
"released_command_not_publicly_callable",
)?;
let internal = internal_call(ctx, endpoint, id, operation_id, payload)?;
require(
internal["status"] == "succeeded" && internal["error"].is_null(),
"internal_local_control_failed",
)?;
ctx.record(
id,
public.exit,
public.signal,
&json!({"public_cli":public.envelope,"internal_local_control":internal}),
)?;
Ok(public.envelope)
}
pub(super) fn discover(ctx: &mut Context<'_>) -> Result<()> {
let (cli_artifact, daemon) = prepare(ctx)?;
let secret = nonce()?;
let (home, bin) = fixtures::discovery(&ctx.runtime, &secret)?;
let settings = home.join(".claude/settings.json");
let original = fs::read(&settings)?;
let endpoint = ctx.runtime.join("control-runtime/hiroute/control.sock");
let mut c = command(&daemon.path, &ctx.runtime);
c.args(["--role", "control", "--storage-root"])
.arg(ctx.runtime.join("storage"))
.arg("--runtime-root")
.arg(ctx.runtime.join("control-runtime"))
.args(["--diagnostic-level-override", "debug"])
.env("HOME", &home)
.env("PATH", &bin);
ctx.enter("control_ready");
ctx.verify_artifact(&daemon)?;
let mut child = Process::spawn(&mut c, &ctx.private.join("daemon"), ctx.cancel.clone())?;
let outcome: Result<()> = (|| {
let deadline = ctx.step_deadline();
loop {
child.check()?;
if fs::symlink_metadata(&endpoint).is_ok_and(|m| m.file_type().is_socket()) {
break;
}
require(Instant::now() < deadline, "ready_timeout")?;
std::thread::sleep(Duration::from_millis(20));
}
ctx.record(
"control_ready",
None,
None,
&json!({"child_pid":child.id(),"role":"control","executable_sha256":daemon.sha256}),
)?;
let status = released_command(
ctx,
&cli_artifact,
&endpoint,
"system_status",
&["system", "status"],
None,
&secret,
"GetSystemStatus",
json!({}),
)?;
require(
status["status"] == "succeeded"
&& status["data"]["daemon"] == "control_only"
&& status["data"]["gateway"] == "unavailable:not_composed",
"control_status_mismatch",
)?;
let client_status = planned_command(
ctx,
&cli_artifact,
&endpoint,
"client_service_status",
&["system", "client-status"],
None,
&secret,
"GetClientServiceStatus",
json!({}),
)?;
require(
client_status["status"] == "succeeded"
&& client_status["data"]["schema"] == "hiroute.client-service-status/v1"
&& client_status["data"]["daemon_role"] == "control_only"
&& client_status["data"]["recovery_ready"] == true
&& client_status["data"]["mutation_available"] == false
&& client_status["data"]["gateway"] == "not_composed"
&& client_status["data"]["active_publication"].is_null(),
"client_service_status_mismatch",
)?;
let lookup = OperationIdempotencyLookupV1 {
principal_kind: PrincipalKind::InteractiveUser,
operation_kind: "ApplyAgentPlanChange".into(),
idempotency_key: format!("smoke-lookup-{}", &ctx.run_id[..16]),
accepted_digest: CanonicalDigest::of_bytes(
format!("mvp17-lookup-{}", ctx.run_id).as_bytes(),
),
include_model_budget_conflict: false,
};
let lookup_payload = serde_json::to_value(&lookup)?;
let lookup_input = serde_json::to_vec(&lookup)?;
let lookup = released_command(
ctx,
&cli_artifact,
&endpoint,
"operation_idempotency_lookup",
&["operations", "find", "--request-stdin"],
Some(&lookup_input),
&secret,
"FindOperationByIdempotency",
lookup_payload,
)?;
require(
lookup["status"] == "succeeded"
&& lookup["data"]["operation"].is_null()
&& lookup["data"]["digest_matches"] == true,
"idempotency_lookup_mismatch",
)?;
for (step, verb, operation) in [
("agents_scan", "scan", "ScanAgents"),
("agents_list", "list", "ListAgents"),
] {
child.check()?;
let result = released_command(
ctx,
&cli_artifact,
&endpoint,
step,
&["agents", verb],
None,
&secret,
operation,
json!({}),
)?;
let agents = result["data"]["agents"]
.as_array()
.ok_or(super::SmokeError("agent_discovery_missing"))?;
let agent_ids = agents
.iter()
.map(|agent| {
agent["agent_id"]
.as_str()
.ok_or(super::SmokeError("agent_discovery_mismatch"))
})
.collect::<Result<std::collections::BTreeSet<_>>>()?;
require(
result["status"] == "succeeded"
&& agent_ids.len() == agents.len()
&& [
"agent_codex_default",
"agent_claude_default",
"agent_qoder_default",
]
.iter()
.all(|id| agent_ids.contains(id))
&& agents.iter().any(|a| {
a["agent_id"] == "agent_claude_default"
&& a["supported"] == true
&& a["registered_configuration"]["connection_option_id"]
== "zhipu.coding-plan.cn.v1"
})
&& agents.iter().any(|a| {
a["agent_id"] == "agent_qoder_default"
&& a["registered_configuration"].is_null()
&& a["discovered_credential"].is_null()
}),
"agent_discovery_mismatch",
)?;
}
require(
fs::read(&settings)? == original,
"synthetic_configuration_changed",
)?;
Ok(())
})();
let cleanup = child.stop();
outcome?;
cleanup?;
ctx.enter("control_cleanup");
ctx.verify_artifact(&daemon)?;
let (_, stderr) = child.output(1024 * 1024)?;
require(
!String::from_utf8_lossy(&stderr).contains(&secret),
"privacy_failure",
)?;
ctx.record(
"control_cleanup",
None,
None,
&json!({"reaped":true,"initial_configuration_digest":digest(&original)}),
)
}
pub(super) fn embedded_catalog(ctx: &mut Context<'_>) -> Result<()> {
let (cli_artifact, daemon) = prepare(ctx)?;
let endpoint = ctx.runtime.join("control-runtime/hiroute/control.sock");
let mut c = command(&daemon.path, &ctx.runtime);
c.args(["--role", "control", "--storage-root"])
.arg(ctx.runtime.join("storage"))
.arg("--runtime-root")
.arg(ctx.runtime.join("control-runtime"))
.args(["--diagnostic-level-override", "debug"]);
fixtures::initialize_current_storage(
&daemon.path,
&ctx.runtime.join("storage"),
&ctx.private.join("embedded-catalog-initialize"),
ctx.cancel.clone(),
ctx.step_deadline(),
)?;
fixtures::install_storage_catalog_tampering(&ctx.runtime.join("storage"))?;
ctx.enter("embedded_catalog_ready");
ctx.verify_artifact(&daemon)?;
let mut child = Process::spawn(
&mut c,
&ctx.private.join("embedded-catalog-daemon"),
ctx.cancel.clone(),
)?;
let outcome: Result<()> = (|| {
let deadline = ctx.step_deadline();
loop {
child.check()?;
if fs::symlink_metadata(&endpoint).is_ok_and(|m| m.file_type().is_socket()) {
break;
}
require(Instant::now() < deadline, "ready_timeout")?;
std::thread::sleep(Duration::from_millis(20));
}
ctx.record(
"embedded_catalog_ready",
None,
None,
&json!({"child_pid":child.id(),"catalog_source":"daemon_embedded_current"}),
)?;
let result = released_command(
ctx,
&cli_artifact,
&endpoint,
"storage_catalog_ignored",
&["compute", "scan"],
None,
"",
"ScanCompute",
json!({}),
)?;
require(
result["status"] == "succeeded"
&& fs::read(
ctx.runtime
.join("storage/release-facts/current/manifest.json"),
)? == b"{\"schema\":\"untrusted\"}\n",
"embedded_catalog_not_proven",
)?;
Ok(())
})();
let cleanup = child.stop();
outcome?;
cleanup?;
let (_, stderr) = child.output(1024 * 1024)?;
require(stderr.is_empty(), "unexpected_daemon_stderr")?;
ctx.enter("embedded_catalog_cleanup");
ctx.record(
"embedded_catalog_cleanup",
None,
None,
&json!({"reaped":true,"mutable_storage_catalog_ignored":true}),
)?;
ctx.verify_artifact(&daemon)
}
// Only the owner-local connection controls may disclose their exact target.
// Check secrets before removing these fields from the path-leak check.
fn response_is_private(value: &Value, runtime: &Path, secret: &str, discovery: bool) -> bool {
if !secret.is_empty() && value.to_string().contains(secret) {
return false;
}
let mut redacted = value.clone();
if discovery {
let Some(agents) = redacted["data"]["agents"].as_array_mut() else {
return false;
};
let Some(agent) = agents
.iter_mut()
.find(|a| a["agent_id"] == "agent_codex_default")
else {
return false;
};
let Some(access) = agent["codex_access"].as_object_mut() else {
return false;
};
let home = runtime.join("agent-home/.codex");
if access.remove("codex_home") != Some(json!(home))
|| access.remove("target_file") != Some(json!(home.join("hiroute.config.toml")))
{
return false;
}
let Some(Value::Object(commands)) = access.remove("commands") else {
return false;
};
if commands.len() != 3
|| !["bash/zsh", "fish", "PowerShell"].iter().all(|shell| {
commands
.get(*shell)
.and_then(Value::as_str)
.is_some_and(|command| {
command.contains(home.to_string_lossy().as_ref())
&& command.contains("codex --profile hiroute")
})
})
{
return false;
}
}
!redacted
.to_string()
.contains(runtime.to_string_lossy().as_ref())
}
#[cfg(test)]
mod privacy_tests {
use super::*;
#[test]
fn only_connection_controls_allow_exact_paths_and_never_credentials() {
let runtime = Path::new("/private/smoke");
let home = runtime.join("agent-home/.codex");
let command = format!("CODEX_HOME={} codex --profile hiroute", home.display());
let value = json!({"data":{"agents":[{"agent_id":"agent_codex_default","codex_access":{
"codex_home":home,"target_file":home.join("hiroute.config.toml"),
"commands":{"bash/zsh":command,"fish":command,"PowerShell":command}
}}]}});
assert!(response_is_private(
&value,
runtime,
"sentinel-secret",
true
));
assert!(!response_is_private(
&value,
runtime,
"sentinel-secret",
false
));
let mut unrelated = value.clone();
unrelated["extra"] = json!(home);
let raw = serde_json::to_vec(&unrelated).unwrap();
let unrelated = serde_json::from_slice::<Value>(&raw).unwrap();
assert!(!response_is_private(
&unrelated,
runtime,
"sentinel-secret",
true
));
let mut unknown = value.clone();
unknown["extra"] = json!("sentinel-secret");
let raw = serde_json::to_vec(&unknown).unwrap();
assert!(!response_is_private(
&serde_json::from_slice::<Value>(&raw).unwrap(),
runtime,
"sentinel-secret",
true
));
let mut secret = value.clone();
secret["data"]["agents"][0]["codex_access"]["commands"]["fish"] =
json!(format!("{command} sentinel-secret"));
assert!(!response_is_private(
&secret,
runtime,
"sentinel-secret",
true
));
let mut wrong_target = value.clone();
wrong_target["data"]["agents"][0]["codex_access"]["target_file"] = json!(home);
assert!(!response_is_private(
&wrong_target,
runtime,
"sentinel-secret",
true
));
}
}