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::*;
use crate::valuation::{
CACHE_HIT_ARCHIVE_SCHEMA, CACHE_HIT_ELIGIBLE_ATTEMPTS, CACHE_HIT_INPUT_TOKENS,
CACHE_HIT_INVALID_ATTEMPTS, CACHE_HIT_MISSING_ATTEMPTS, CACHE_HIT_READ_TOKENS,
CACHE_HIT_TOTAL_ATTEMPTS, CACHE_HIT_ZERO_INPUT_ATTEMPTS,
};
use hiroute_domain::{
ObservationCacheHitStateV2, ObservationCacheHitSummaryV2, ObservationMetricCoverageV2,
ObservationReaderContext, ObservationValueQueryV2,
};
use rusqlite::{Transaction, params};
use std::collections::BTreeMap;
#[derive(Default)]
struct AttemptTotals {
read: u64,
input: u64,
eligible: u64,
total: u64,
zero_input: u64,
missing: u64,
invalid: u64,
arithmetic_overflow: bool,
archive_coverage_partial: bool,
}
#[derive(Default)]
struct ArchivedMetric {
sum: u64,
known: bool,
incomplete: bool,
}
pub(super) fn aggregate(
tx: &Transaction<'_>,
reader: &ObservationReaderContext,
query: &ObservationValueQueryV2,
retained_from: i64,
pending_requests: u64,
provisional_requests: u64,
unknown_traffic_requests: u64,
) -> Result<ObservationCacheHitSummaryV2, ObservationV2Error> {
let runs = reader
.allowed_runs()
.map(serde_json::to_string)
.transpose()
.map_err(|_| ObservationV2Error::Invalid)?;
let retention_boundary_partial = retained_from > query.from_ms;
let scope = "WITH selected AS (
SELECT r.* FROM logical_requests r
WHERE r.workspace_id=?1 AND r.started_at_ms>=?2 AND r.started_at_ms<?3
AND (?4 IS NULL OR r.session_id=?4)
AND (?5 IS NULL OR EXISTS(
SELECT 1 FROM valuation_requests_v2 v
WHERE v.workspace_id=r.workspace_id AND v.request_id=r.request_id AND v.plan_id=?5))
AND (?6 IS NULL OR EXISTS(
SELECT 1 FROM observation_run_links l
WHERE l.workspace_id=r.workspace_id AND l.request_id=r.request_id
AND l.conflicted=0 AND l.run_id IN(SELECT value FROM json_each(?6))))
)";
let sql = format!(
"{scope} SELECT i.usage_json
FROM valuation_attempt_inputs_v2 i
JOIN selected r ON r.workspace_id=i.workspace_id AND r.request_id=i.request_id
WHERE r.traffic_kind='normal'"
);
let mut totals = AttemptTotals::default();
let mut statement = tx.prepare(&sql)?;
let rows = statement.query_map(
params![
reader.workspace().as_str(),
retained_from,
query.to_ms,
query.session_id,
query.plan_id,
runs,
],
|row| row.get::<_, Option<String>>(0),
)?;
for row in rows {
checked_add(&mut totals.total, 1, &mut totals.arithmetic_overflow);
let usage = row?.and_then(|body| serde_json::from_str::<serde_json::Value>(&body).ok());
let pair = usage
.as_ref()
.and_then(|value| Some((value.get("input")?.as_u64()?, value.get("read")?.as_u64()?)));
record_pair(&mut totals, pair);
}
drop(statement);
if reader.allowed_runs().is_none() && query.session_id.is_none() {
merge_archives(tx, reader, query, &mut totals)?;
}
let paired_sums_available = totals.eligible > 0 && !totals.arithmetic_overflow;
let (ratio_basis_points, cache_read_tokens, total_input_tokens) =
if paired_sums_available && totals.input > 0 {
let numerator = u128::from(totals.read)
.checked_mul(10_000)
.and_then(|value| value.checked_add(u128::from(totals.input / 2)));
let ratio = numerator
.map(|value| value / u128::from(totals.input))
.and_then(|value| u32::try_from(value).ok());
match ratio {
Some(ratio) => (Some(ratio), Some(totals.read), Some(totals.input)),
None => {
totals.arithmetic_overflow = true;
(None, None, None)
}
}
} else {
(None, None, None)
};
let only_zero_input = totals.zero_input > 0
&& totals.zero_input == totals.total
&& totals.eligible == 0
&& totals.missing == 0
&& totals.invalid == 0
&& !totals.arithmetic_overflow
&& !totals.archive_coverage_partial
&& !retention_boundary_partial
&& pending_requests == 0
&& provisional_requests == 0
&& unknown_traffic_requests == 0;
let state = if ratio_basis_points.is_some() {
ObservationCacheHitStateV2::Available
} else if only_zero_input {
ObservationCacheHitStateV2::NotApplicable
} else {
ObservationCacheHitStateV2::Unknown
};
let has_known_basis = ratio_basis_points.is_some() || totals.zero_input > 0;
let has_gap = totals.missing > 0
|| totals.invalid > 0
|| totals.arithmetic_overflow
|| totals.archive_coverage_partial
|| retention_boundary_partial
|| pending_requests > 0
|| provisional_requests > 0
|| unknown_traffic_requests > 0;
let coverage = match (has_known_basis, has_gap) {
(false, _) => ObservationMetricCoverageV2::Unknown,
(true, false) => ObservationMetricCoverageV2::Complete,
(true, true) => ObservationMetricCoverageV2::Partial,
};
Ok(ObservationCacheHitSummaryV2 {
state,
ratio_basis_points,
cache_read_tokens,
total_input_tokens,
eligible_attempt_count: totals.eligible,
total_attempt_count: totals.total,
zero_input_attempt_count: totals.zero_input,
missing_attempt_count: totals.missing,
invalid_attempt_count: totals.invalid,
arithmetic_overflow: totals.arithmetic_overflow,
archive_coverage_partial: totals.archive_coverage_partial,
coverage,
})
}
fn record_pair(totals: &mut AttemptTotals, pair: Option<(u64, u64)>) {
let Some((input, read)) = pair else {
checked_add(&mut totals.missing, 1, &mut totals.arithmetic_overflow);
return;
};
if read > input {
checked_add(&mut totals.invalid, 1, &mut totals.arithmetic_overflow);
} else if input == 0 {
checked_add(&mut totals.zero_input, 1, &mut totals.arithmetic_overflow);
} else {
checked_add(&mut totals.eligible, 1, &mut totals.arithmetic_overflow);
checked_add(&mut totals.input, input, &mut totals.arithmetic_overflow);
checked_add(&mut totals.read, read, &mut totals.arithmetic_overflow);
}
}
fn merge_archives(
tx: &Transaction<'_>,
reader: &ObservationReaderContext,
query: &ObservationValueQueryV2,
totals: &mut AttemptTotals,
) -> Result<(), ObservationV2Error> {
let mut metrics = BTreeMap::<String, ArchivedMetric>::new();
let mut statement = tx.prepare(
"SELECT metric,known_sum,missing_count FROM observation_usage_archives_v2
WHERE workspace_id=?1 AND day*86400000>=?2 AND (day+1)*86400000<=?3
AND (?4 IS NULL OR plan_id=?4) AND metric LIKE 'cache_hit_%'",
)?;
let rows = statement.query_map(
params![
reader.workspace().as_str(),
query.from_ms,
query.to_ms,
query.plan_id,
],
|row| {
Ok((
row.get::<_, String>(0)?,
row.get::<_, Option<i64>>(1)?,
row.get::<_, i64>(2)?,
))
},
)?;
for row in rows {
let (name, value, missing) = row?;
let metric = metrics.entry(name).or_default();
if missing != 0 {
metric.incomplete = true;
}
match value.map(|value| value as u64) {
Some(value) => {
metric.known = true;
if let Some(sum) = metric.sum.checked_add(value) {
metric.sum = sum;
} else {
metric.incomplete = true;
}
}
None => metric.incomplete = true,
}
}
drop(statement);
let unmarked_legacy: bool = tx.query_row(
"SELECT EXISTS(
SELECT 1 FROM observation_usage_archives_v2 a
WHERE a.workspace_id=?1 AND a.day*86400000>=?2 AND (a.day+1)*86400000<=?3
AND (?4 IS NULL OR a.plan_id=?4)
AND a.metric IN ('input','cache_read')
AND NOT EXISTS(
SELECT 1 FROM observation_usage_archives_v2 marker
WHERE marker.workspace_id=a.workspace_id AND marker.day=a.day
AND marker.plan_id IS a.plan_id AND marker.metric=?5))",
params![
reader.workspace().as_str(),
query.from_ms,
query.to_ms,
query.plan_id,
CACHE_HIT_ARCHIVE_SCHEMA,
],
|row| row.get(0),
)?;
totals.archive_coverage_partial = unmarked_legacy;
merge_count(
&metrics,
CACHE_HIT_TOTAL_ATTEMPTS,
&mut totals.total,
&mut totals.arithmetic_overflow,
);
merge_count(
&metrics,
CACHE_HIT_ELIGIBLE_ATTEMPTS,
&mut totals.eligible,
&mut totals.arithmetic_overflow,
);
merge_count(
&metrics,
CACHE_HIT_ZERO_INPUT_ATTEMPTS,
&mut totals.zero_input,
&mut totals.arithmetic_overflow,
);
merge_count(
&metrics,
CACHE_HIT_MISSING_ATTEMPTS,
&mut totals.missing,
&mut totals.arithmetic_overflow,
);
merge_count(
&metrics,
CACHE_HIT_INVALID_ATTEMPTS,
&mut totals.invalid,
&mut totals.arithmetic_overflow,
);
merge_count(
&metrics,
CACHE_HIT_READ_TOKENS,
&mut totals.read,
&mut totals.arithmetic_overflow,
);
merge_count(
&metrics,
CACHE_HIT_INPUT_TOKENS,
&mut totals.input,
&mut totals.arithmetic_overflow,
);
Ok(())
}
fn merge_count(
metrics: &BTreeMap<String, ArchivedMetric>,
name: &str,
target: &mut u64,
overflow: &mut bool,
) {
let Some(metric) = metrics.get(name) else {
return;
};
if metric.incomplete || !metric.known {
*overflow = true;
return;
}
checked_add(target, metric.sum, overflow);
}
fn checked_add(target: &mut u64, value: u64, overflow: &mut bool) {
match target.checked_add(value) {
Some(sum) => *target = sum,
None => *overflow = true,
}
}