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, require};
use serde::{Deserialize, Serialize};
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum State {
Green,
ExpectedRed,
Red,
}
#[derive(Clone, Copy, Debug, Deserialize, Serialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum Execution {
Executed,
NotExecuted,
Interrupted,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Step {
pub id: String,
pub process_exit: Option<i32>,
pub signal: Option<i32>,
pub evidence_digest: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct CaseReport {
pub id: String,
pub domain: String,
pub scope: String,
pub owner: String,
pub execution: Execution,
pub state: Option<State>,
pub reason: Option<String>,
pub steps: Vec<Step>,
pub build_ms: u128,
pub execution_ms: u128,
/// Measured outer integrity checks; a subset of execution_ms, not additive.
#[serde(default)]
pub integrity_ms: u128,
pub unclassified_ms: u128,
pub timing_complete: bool,
pub cleanup: String,
}
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(deny_unknown_fields)]
pub struct Report {
pub schema: String,
pub run_id: String,
pub tool_sha256: String,
pub started_unix_ms: u128,
pub finished_unix_ms: u128,
pub scenario_timeout_ms: u64,
pub step_timeout_ms: u64,
pub source_revision: Option<String>,
pub source_tree: Option<String>,
pub build_input_digest: Option<String>,
pub registry_digest: String,
pub platform: String,
pub requested_domains: Vec<String>,
pub requested_cases: Vec<String>,
pub expected_cases: Vec<String>,
pub actual_case_count: usize,
pub cases: Vec<CaseReport>,
pub artifacts: Vec<super::build::Artifact>,
pub tool_process_exit: i32,
pub rust_test_process_exit: Option<i32>,
pub capability_gaps: Vec<String>,
}
impl Report {
/// Structural consistency only: imported JSON cannot attest a live product run.
/// The private executors supply observed evidence before producing this report.
pub fn verify(&self) -> Result<()> {
require(
self.schema == "hiroute.smoke.result/v1",
"unsupported_result",
)?;
let selected = super::select(&self.requested_domains, &self.requested_cases)?;
require(
self.expected_cases == selected.iter().map(|c| c.id.to_owned()).collect::<Vec<_>>(),
"required_cases_missing",
)?;
require(
self.registry_digest == super::digest(&serde_json::to_vec(&selected)?),
"registry_changed",
)?;
require(self.cases.len() == selected.len(), "case_terminal_missing")?;
for (result, case) in self.cases.iter().zip(selected) {
require(
result.id == case.id
&& result.domain == case.domain
&& result.scope == case.scope
&& result.owner == case.owner,
"case_identity_mismatch",
)?;
require(
if result.timing_complete {
result.unclassified_ms == 0
} else {
result.execution_ms == 0
},
"ambiguous_execution_timing",
)?;
match result.execution {
Execution::NotExecuted => require(
result.state.is_none() && result.reason.is_some(),
"unexecuted_has_verdict",
)?,
Execution::Interrupted => require(
result.state == Some(State::Red) && result.reason.is_some(),
"interrupted_has_success",
)?,
Execution::Executed => {
require(result.state.is_some(), "case_terminal_missing")?;
if result.state == Some(State::ExpectedRed) {
require(
case.expected_red.is_some()
&& result.reason.as_deref() == case.expected_red,
"unregistered_expected_red",
)?;
}
if result.state == Some(State::Green) {
require(
case.execute.is_some()
&& result.cleanup == "complete"
&& result.reason.is_none(),
"false_green",
)?;
require(
result
.steps
.iter()
.map(|s| s.id.as_str())
.collect::<Vec<_>>()
== case.steps,
"required_step_missing",
)?;
require(
result.steps.iter().all(|s| {
s.evidence_digest.starts_with("sha256:")
&& s.evidence_digest.len() == 71
}),
"missing_evidence",
)?;
}
}
}
}
require(
self.actual_case_count
== self
.cases
.iter()
.filter(|c| c.execution != Execution::NotExecuted)
.count(),
"case_count_mismatch",
)?;
let green = self.cases.iter().all(|c| {
c.execution == Execution::Executed
&& c.state == Some(State::Green)
&& c.cleanup == "complete"
});
require(
self.tool_process_exit == if green { 0 } else { 1 },
"exit_verdict_mismatch",
)?;
if green {
require(
self.source_revision.as_ref().is_some_and(|s| s.len() == 40)
&& self.source_tree.is_some()
&& self.build_input_digest.is_some()
&& !self.artifacts.is_empty(),
"source_evidence_missing",
)?;
}
Ok(())
}
}