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
//! Bounded native Live verification using the current managed configuration and Gateway receipt.
use super::LocalControlAdapter;
use hiroute_application::control::{AgentConnectionControlPort, ControlReadError};
use hiroute_application_api::{AgentCheckRequestV1, AgentLaunchDescriptorRequestV1};
use hiroute_domain::{
AGENT_SURFACE_CHECK_SCHEMA, AgentModelSurfaceV2, AgentSurfaceCheckRecordV1,
AgentSurfaceCheckStateV1, CanonicalDigest, ContentMode, ControlRepositoryPort,
FactsCompleteness, FrozenExecutionTrustV1, GatewayPublicationSnapshotProjectionV3,
ObservationQueryError, ObservationQueryPort, PublicationRepositoryPort, RequestOutcome,
WorkspaceId,
};
use hiroute_gateway::server::core_runtime::observation::{
NativeAgentObservationIdentityV1, derive_native_agent_observation_session_id,
};
use hiroute_integrations::ManagedClaudeProcessV1;
use std::collections::BTreeSet;
use std::ffi::OsString;
use std::io::Read;
use std::process::Command;
#[cfg(not(windows))]
use std::process::Stdio;
use std::thread;
use std::time::{Duration, Instant};
#[path = "agent_live_check_qoder.rs"]
mod qoder;
#[cfg(windows)]
#[path = "agent_live_check_windows.rs"]
mod windows;
const LIVE_CHECK_BUDGET: Duration = Duration::from_secs(120);
const RECEIPT_WAIT_BUDGET: Duration = Duration::from_secs(5);
const OUTPUT_LIMIT: usize = 1024 * 1024;
const LIVE_PROMPT_RESPONSE: &str = "HIROUTE_LIVE_CHECK_OK";
const LIVE_PROMPT: &str =
"Reply with exactly HIROUTE_LIVE_CHECK_OK. Do not use tools or perform any other action.";
const CLIENT_FAILED: &str = "LIVE_CLIENT_FAILED";
const CLIENT_OUTPUT_INVALID: &str = "LIVE_CLIENT_OUTPUT_INVALID";
const CHECK_TIMEOUT: &str = "LIVE_CHECK_TIMEOUT";
const RECEIPT_MISSING: &str = "LIVE_RECEIPT_MISSING";
const RECEIPT_MISMATCH: &str = "LIVE_RECEIPT_MISMATCH";
pub(super) struct AttemptFailure {
executed: bool,
reason: &'static str,
}
struct ProcessOutput {
stdout: Vec<u8>,
}
/// Do not delete a native workspace until its owned process scope is confirmed stopped.
struct LiveWorkspace {
cleanup: Option<tempfile::TempDir>,
path: std::path::PathBuf,
}
impl LiveWorkspace {
fn new() -> std::io::Result<Self> {
let root = tempfile::tempdir()?;
#[cfg(windows)]
let path = {
let path = root.path().join("private");
hiroute_platform::windows::security::create_owner_only_directory(&path)?;
path
};
#[cfg(not(windows))]
let path = root.path().to_owned();
Ok(Self {
cleanup: Some(root),
path,
})
}
fn path(&self) -> &std::path::Path {
&self.path
}
fn keep(&mut self) {
if let Some(root) = self.cleanup.take() {
let _ = root.keep();
}
}
}
impl LocalControlAdapter {
pub(super) fn execute_model_live_check(
&self,
request: &AgentCheckRequestV1,
request_digest: &CanonicalDigest,
) -> Result<AgentSurfaceCheckRecordV1, ControlReadError> {
self.validate_model_check_target(request)?;
let target = request.target.as_ref().ok_or(ControlReadError::Denied)?;
let join = self
.configured_model_settings_join(&target.context_id)?
.ok_or(ControlReadError::Denied)?;
let publication = {
let stores = self.stores_lock().map_err(super::map_port)?;
let record = stores
.control()
.active_publication(&WorkspaceId::default())
.map_err(super::map_port)?
.ok_or(ControlReadError::Denied)?;
if record.publication_revision != target.expected_applied_revision
|| record.digest != join.publication_digest
{
return Err(ControlReadError::SnapshotChanged);
}
record.verify().map_err(|_| ControlReadError::Corrupt)?
};
let snapshot = publication
.gateway_snapshot()
.map_err(|_| ControlReadError::Corrupt)?;
let expected = target
.client_model_ids
.iter()
.map(|model| expected_trust(&snapshot, join.grant.grant_id(), model))
.collect::<Result<Vec<_>, _>>()?;
let deadline = Instant::now() + LIVE_CHECK_BUDGET;
let mut any_executed = false;
let mut checked_model_ids = Vec::new();
let mut verified_evidence = Vec::new();
let mut failure_reason = None;
let claude = if target.surface == AgentModelSurfaceV2::ClaudeCli {
let descriptor = self.managed_launch_descriptor(&AgentLaunchDescriptorRequestV1 {
connection_id: format!("agent-connection/{}", target.context_id),
})?;
let trusted_hiroute_executable = self
.managed_agent_runtime
.lock()
.map_err(|_| ControlReadError::Unavailable)?
.as_ref()
.map(|runtime| runtime.trusted_hiroute_executable.clone())
.ok_or(ControlReadError::Unavailable)?;
Some((descriptor, trusted_hiroute_executable))
} else {
None
};
for (model, trust) in target.client_model_ids.iter().zip(&expected) {
let result = match target.surface {
AgentModelSurfaceV2::PiCli
| AgentModelSurfaceV2::DshCli
| AgentModelSurfaceV2::OpenCodeCli
| AgentModelSurfaceV2::HermesCli => {
return Err(ControlReadError::Denied);
}
AgentModelSurfaceV2::QoderCli => {
self.execute_qoder_live_attempt(&target.context_id, model, trust, deadline)
}
AgentModelSurfaceV2::ClaudeCli => {
let (descriptor, trusted_hiroute_executable) =
claude.as_ref().ok_or(ControlReadError::Corrupt)?;
self.execute_claude_live_attempt(
descriptor,
trusted_hiroute_executable,
model,
trust,
deadline,
)
}
AgentModelSurfaceV2::CodexCli | AgentModelSurfaceV2::CodexDesktop => self
.execute_codex_live_attempt(
&target.context_id,
target.surface,
model,
trust,
deadline,
),
};
match result {
Ok(evidence) => {
any_executed = true;
checked_model_ids.push(model.clone());
verified_evidence.push(evidence);
}
Err(error) => {
any_executed |= error.executed;
if error.executed {
checked_model_ids.push(model.clone());
}
failure_reason = Some(error.reason);
break;
}
}
}
if !any_executed {
return Err(ControlReadError::Unavailable);
}
// A result that races any settings/publication/grant change is not current evidence and
// must never reach the surface CAS, including a failure result.
self.validate_model_check_target(request)?;
let capability_scope_digest = CanonicalDigest::of(&(
"hiroute.agent-live-check-evidence/v1",
target.surface,
&expected,
&verified_evidence,
failure_reason,
))
.map_err(|_| ControlReadError::Corrupt)?;
let record = AgentSurfaceCheckRecordV1 {
schema: AGENT_SURFACE_CHECK_SCHEMA.into(),
context_id: target.context_id.clone(),
surface: target.surface,
applied_revision: target.expected_applied_revision,
state: if failure_reason.is_some() {
AgentSurfaceCheckStateV1::Failed
} else {
AgentSurfaceCheckStateV1::Passed
},
checked_model_ids,
capability_scope_digest,
check_request_digest: request_digest.clone(),
reason_code: failure_reason.map(str::to_owned),
};
record.validate().map_err(|_| ControlReadError::Corrupt)?;
Ok(record)
}
pub(super) fn save_model_live_check_result(
&self,
record: &AgentSurfaceCheckRecordV1,
) -> Result<bool, ControlReadError> {
self.stores_lock()
.map_err(super::map_port)?
.control()
.save_agent_surface_check(&WorkspaceId::default(), record)
.map_err(super::map_port)
}
fn execute_claude_live_attempt(
&self,
descriptor: &hiroute_domain::ManagedClaudeLaunchDescriptorV2,
trusted_hiroute_executable: &str,
model: &str,
trust: &FrozenExecutionTrustV1,
deadline: Instant,
) -> Result<CanonicalDigest, AttemptFailure> {
let arguments = [
"--print",
"--output-format",
"json",
"--model",
model,
"--max-turns",
"1",
LIVE_PROMPT,
]
.into_iter()
.map(OsString::from)
.collect::<Vec<_>>();
let mut process = ManagedClaudeProcessV1::prepare(
descriptor,
&serde_json::json!({}),
&arguments,
trusted_hiroute_executable,
)
.map_err(|_| AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
})?;
let mut working = LiveWorkspace::new().map_err(|_| AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
})?;
process.command_mut().current_dir(working.path());
let output = run_bounded(process.command_mut(), deadline, &mut working)?;
let identity = parse_claude_output(&output.stdout).ok_or(AttemptFailure {
executed: true,
reason: CLIENT_OUTPUT_INVALID,
})?;
let response_digest = CanonicalDigest::of(&output.stdout).map_err(|_| AttemptFailure {
executed: true,
reason: CLIENT_OUTPUT_INVALID,
})?;
self.verify_live_receipt(trust, &[identity], &response_digest, deadline)
}
fn execute_codex_live_attempt(
&self,
context_id: &str,
surface: AgentModelSurfaceV2,
model: &str,
trust: &FrozenExecutionTrustV1,
deadline: Instant,
) -> Result<CanonicalDigest, AttemptFailure> {
let executable = self
.scanner
.codex_engine_target(surface)
.ok_or(AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
})?;
let mut working = LiveWorkspace::new().map_err(|_| AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
})?;
let mut command = Command::new(executable);
let root = self.scanner.codex_user_config_target();
let home = root.parent().ok_or(AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
})?;
command.env("CODEX_HOME", home);
if self.settings_agent_for_context(context_id)
== Some(super::settings_facts::SettingsAgentClass::CodexProfile)
{
if surface != AgentModelSurfaceV2::CodexCli {
return Err(AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
});
}
command.args([
"--profile",
hiroute_integrations::CODEX_MANAGED_PROFILE_NAME,
]);
}
command.current_dir(working.path()).args([
"exec",
"--json",
"--ephemeral",
"--sandbox",
"read-only",
"--skip-git-repo-check",
"--model",
model,
LIVE_PROMPT,
]);
let output = run_bounded(&mut command, deadline, &mut working)?;
let identities = parse_codex_output(&output.stdout).ok_or(AttemptFailure {
executed: true,
reason: CLIENT_OUTPUT_INVALID,
})?;
let response_digest = CanonicalDigest::of(&output.stdout).map_err(|_| AttemptFailure {
executed: true,
reason: CLIENT_OUTPUT_INVALID,
})?;
self.verify_live_receipt(trust, &identities, &response_digest, deadline)
}
pub(super) fn verify_live_receipt(
&self,
expected: &FrozenExecutionTrustV1,
identities: &[NativeAgentObservationIdentityV1],
response_digest: &CanonicalDigest,
deadline: Instant,
) -> Result<CanonicalDigest, AttemptFailure> {
let sessions = identities
.iter()
.filter_map(|identity| {
derive_native_agent_observation_session_id(
&WorkspaceId::default(),
&self.observation_workspace_key,
expected,
identity,
)
.ok()
})
.collect::<BTreeSet<_>>();
if sessions.is_empty() {
return Err(AttemptFailure {
executed: true,
reason: RECEIPT_MISMATCH,
});
}
let wait_until = deadline.min(Instant::now() + RECEIPT_WAIT_BUDGET);
loop {
let mut matching = Vec::new();
for session in &sessions {
let detail = match self.delegation_observation.get_session(
&WorkspaceId::default(),
session,
ContentMode::None,
) {
Ok(detail) => detail,
Err(ObservationQueryError::NotFound) => continue,
Err(_) => {
return Err(AttemptFailure {
executed: true,
reason: RECEIPT_MISSING,
});
}
};
for receipt_id in detail.turns.iter().flat_map(|turn| turn.receipt_ids.iter()) {
let receipt = self
.delegation_observation
.get_receipt(&WorkspaceId::default(), receipt_id)
.map_err(|_| AttemptFailure {
executed: true,
reason: RECEIPT_MISSING,
})?;
if &receipt.trust == expected {
matching.push(receipt);
}
}
}
if matching.len() == 1 {
let receipt = &matching[0];
// Identity is established by the unique matching receipt and frozen
// trust; a failed request is still our connectivity probe. Mark it
// before separately judging whether the live check succeeded.
self.delegation_observation
.mark_observed_connectivity_probe(&receipt.workspace_id, &receipt.request_id)
.map_err(|_| AttemptFailure {
executed: true,
reason: RECEIPT_MISMATCH,
})?;
if receipt.outcome == RequestOutcome::Accepted
&& receipt.facts_completeness == FactsCompleteness::Complete
{
return CanonicalDigest::of(&(
"hiroute.agent-live-check-receipt/v1",
response_digest,
identities,
receipt,
))
.map_err(|_| AttemptFailure {
executed: true,
reason: RECEIPT_MISMATCH,
});
}
return Err(AttemptFailure {
executed: true,
reason: RECEIPT_MISMATCH,
});
}
if matching.len() > 1 {
return Err(AttemptFailure {
executed: true,
reason: RECEIPT_MISMATCH,
});
}
if Instant::now() >= wait_until {
return Err(AttemptFailure {
executed: true,
reason: RECEIPT_MISSING,
});
}
thread::sleep(Duration::from_millis(50));
}
}
}
pub(super) fn expected_trust(
snapshot: &GatewayPublicationSnapshotProjectionV3,
grant_id: &str,
served_model_id: &str,
) -> Result<FrozenExecutionTrustV1, ControlReadError> {
let snapshot: hiroute_gateway::server::publication::GatewayPublicationSnapshotV3 =
serde_json::from_value(
serde_json::to_value(snapshot).map_err(|_| ControlReadError::Corrupt)?,
)
.map_err(|_| ControlReadError::Corrupt)?;
snapshot
.native_agent_execution_trust(grant_id, served_model_id)
.map_err(|_| ControlReadError::Corrupt)
}
#[cfg(windows)]
fn run_bounded(
command: &mut Command,
deadline: Instant,
working: &mut LiveWorkspace,
) -> Result<ProcessOutput, AttemptFailure> {
let (stdout, success) = windows::run_captured(command, true, deadline, working)?;
if !success {
return Err(AttemptFailure {
executed: true,
reason: CLIENT_FAILED,
});
}
Ok(ProcessOutput { stdout })
}
#[cfg(not(windows))]
fn run_bounded(
command: &mut Command,
deadline: Instant,
_working: &mut LiveWorkspace,
) -> Result<ProcessOutput, AttemptFailure> {
command
.stdin(Stdio::null())
.stdout(Stdio::piped())
.stderr(Stdio::piped());
#[cfg(unix)]
{
use std::os::unix::process::CommandExt;
command.process_group(0);
}
let mut child = command.spawn().map_err(|_| AttemptFailure {
executed: false,
reason: CLIENT_FAILED,
})?;
let stdout = child.stdout.take().ok_or(AttemptFailure {
executed: true,
reason: CLIENT_FAILED,
})?;
let stderr = child.stderr.take().ok_or(AttemptFailure {
executed: true,
reason: CLIENT_FAILED,
})?;
let stdout_reader = thread::spawn(move || drain_bounded(stdout));
let stderr_reader = thread::spawn(move || drain_bounded(stderr));
let status = loop {
match child.try_wait() {
Ok(Some(status)) => {
terminate_remaining_process_group(child.id());
break Some(status);
}
Ok(None) if Instant::now() < deadline => thread::sleep(Duration::from_millis(25)),
Ok(None) => {
terminate_owned_process(&mut child);
break None;
}
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {}
Err(_) => {
terminate_owned_process(&mut child);
break None;
}
}
};
let (stdout, stdout_overflow) = stdout_reader.join().unwrap_or_default();
let (_, stderr_overflow) = stderr_reader.join().unwrap_or_default();
let Some(status) = status else {
return Err(AttemptFailure {
executed: true,
reason: CHECK_TIMEOUT,
});
};
if !status.success() {
return Err(AttemptFailure {
executed: true,
reason: CLIENT_FAILED,
});
}
if stdout_overflow || stderr_overflow {
return Err(AttemptFailure {
executed: true,
reason: CLIENT_OUTPUT_INVALID,
});
}
Ok(ProcessOutput { stdout })
}
#[cfg(not(windows))]
fn drain_bounded(mut reader: impl Read) -> (Vec<u8>, bool) {
let mut output = Vec::new();
let mut overflow = false;
let mut buffer = [0_u8; 8192];
loop {
match reader.read(&mut buffer) {
Ok(0) => break,
Ok(length) => {
let remaining = OUTPUT_LIMIT.saturating_sub(output.len());
output.extend_from_slice(&buffer[..length.min(remaining)]);
overflow |= length > remaining;
}
Err(error) if error.kind() == std::io::ErrorKind::Interrupted => {}
Err(_) => {
overflow = true;
break;
}
}
}
(output, overflow)
}
#[cfg(not(windows))]
fn terminate_owned_process(child: &mut std::process::Child) {
#[cfg(unix)]
{
let group = nix::unistd::Pid::from_raw(child.id() as i32);
let _ = nix::sys::signal::killpg(group, nix::sys::signal::Signal::SIGTERM);
let until = Instant::now() + Duration::from_millis(500);
while Instant::now() < until {
if child.try_wait().ok().flatten().is_some() {
let _ = nix::sys::signal::killpg(group, nix::sys::signal::Signal::SIGKILL);
return;
}
thread::sleep(Duration::from_millis(25));
}
let _ = nix::sys::signal::killpg(group, nix::sys::signal::Signal::SIGKILL);
}
let _ = child.kill();
let _ = child.wait();
}
#[cfg(not(windows))]
fn terminate_remaining_process_group(pid: u32) {
#[cfg(unix)]
{
let group = nix::unistd::Pid::from_raw(pid as i32);
let _ = nix::sys::signal::killpg(group, nix::sys::signal::Signal::SIGTERM);
thread::sleep(Duration::from_millis(25));
let _ = nix::sys::signal::killpg(group, nix::sys::signal::Signal::SIGKILL);
}
#[cfg(not(unix))]
let _ = pid;
}
fn parse_claude_output(bytes: &[u8]) -> Option<NativeAgentObservationIdentityV1> {
let value: serde_json::Value = serde_json::from_slice(bytes).ok()?;
if value["type"] != "result"
|| value["subtype"] != "success"
|| value["is_error"] != false
|| value["result"].as_str()?.trim() != LIVE_PROMPT_RESPONSE
{
return None;
}
let session_id = value["session_id"].as_str()?;
valid_native_identity(session_id).then(|| {
NativeAgentObservationIdentityV1::ClaudeMetadataSession {
session_id: session_id.to_owned(),
}
})
}
fn parse_codex_output(bytes: &[u8]) -> Option<Vec<NativeAgentObservationIdentityV1>> {
let mut thread_id = None;
let mut session_id = None;
let mut completed = false;
let mut response = None;
for line in bytes.split(|byte| *byte == b'\n') {
if line.iter().all(u8::is_ascii_whitespace) {
continue;
}
let value: serde_json::Value = serde_json::from_slice(line).ok()?;
match value["type"].as_str()? {
"thread.started" => {
let observed = value["thread_id"].as_str()?;
if !valid_native_identity(observed)
|| thread_id.replace(observed.to_owned()).is_some()
{
return None;
}
if let Some(observed) = value["session_id"].as_str() {
if !valid_native_identity(observed) {
return None;
}
session_id = Some(observed.to_owned());
}
}
"turn.completed" => completed = true,
"turn.failed" | "error" => return None,
"item.completed" if value["item"]["type"] == "agent_message" => {
let observed = value["item"]["text"].as_str()?;
if response.replace(observed.to_owned()).is_some() {
return None;
}
}
_ => {}
}
}
let thread_id = thread_id?;
if !completed || response.as_deref()?.trim() != LIVE_PROMPT_RESPONSE {
return None;
}
let mut identities = vec![NativeAgentObservationIdentityV1::CodexThread {
thread_id: thread_id.clone(),
}];
if let Some(session_id) = session_id {
identities.push(NativeAgentObservationIdentityV1::CodexSession {
session_id: session_id.clone(),
});
identities.push(NativeAgentObservationIdentityV1::CodexThreadSession {
thread_id,
session_id,
});
} else {
// Current Codex JSONL exposes the thread ID, while some protocol revisions also send the
// same value as session metadata. Try only producer-defined identities for that value.
identities.push(NativeAgentObservationIdentityV1::CodexSession {
session_id: thread_id.clone(),
});
identities.push(NativeAgentObservationIdentityV1::CodexThreadSession {
session_id: thread_id.clone(),
thread_id,
});
}
Some(identities)
}
fn valid_native_identity(value: &str) -> bool {
!value.is_empty() && value.len() <= 128 && !value.chars().any(char::is_control)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn native_success_parsers_require_terminal_success_and_return_producer_identities() {
assert!(matches!(
parse_claude_output(
br#"{"type":"result","subtype":"success","is_error":false,"result":"HIROUTE_LIVE_CHECK_OK","session_id":"claude-session"}"#
),
Some(NativeAgentObservationIdentityV1::ClaudeMetadataSession { session_id })
if session_id == "claude-session"
));
assert!(parse_claude_output(
br#"{"type":"result","subtype":"error","is_error":true,"result":"no","session_id":"claude-session"}"#
)
.is_none());
assert!(parse_claude_output(
br#"{"type":"result","subtype":"success","is_error":false,"result":"almost","session_id":"claude-session"}"#
)
.is_none());
let identities = parse_codex_output(
b"{\"type\":\"thread.started\",\"thread_id\":\"thread-one\"}\n{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"HIROUTE_LIVE_CHECK_OK\"}}\n{\"type\":\"turn.completed\"}\n",
)
.unwrap();
assert_eq!(identities.len(), 3);
assert!(parse_codex_output(
b"{\"type\":\"thread.started\",\"thread_id\":\"thread-one\"}\n{\"type\":\"item.completed\",\"item\":{\"type\":\"agent_message\",\"text\":\"almost\"}}\n{\"type\":\"turn.completed\"}\n"
)
.is_none());
assert!(parse_codex_output(
b"{\"type\":\"thread.started\",\"thread_id\":\"thread-one\"}\n{\"type\":\"turn.failed\"}\n"
)
.is_none());
}
}