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
//! Actual serving transitions are separate from recorded decision stages. A user
//! turn may contain several model HTTP requests; compare its final endpoint once.
use super::views::Row;
use crate::query_v2::ObservationV2Error as Error;
use hiroute_domain::*;
use rusqlite::Connection;
use std::collections::{BTreeMap, BTreeSet};
pub(crate) fn transitions(rows: &[Row]) -> Vec<AnalysisTransitionV1> {
let mut previous_http = BTreeMap::<&str, &Row>::new();
let mut previous_turn = BTreeMap::<&str, &Row>::new();
let mut first_by_turn = BTreeMap::new();
for r in rows {
if let Some(turn) = r.turn.as_deref()
&& r.turn_first_request.as_deref() == Some(r.request.request.request_id.as_str())
{
first_by_turn.insert(
(
r.request.request.session_id.as_str(),
r.epoch.as_deref(),
turn,
),
r.request.request.started_at_ms,
);
}
}
// Timestamp ties cannot choose an endpoint by lexical request ID. Native
// first/last references disambiguate a whole known turn; otherwise a tied
// physical-session endpoint remains unknown.
let mut last_groups = BTreeMap::<&str, Vec<&Row>>::new();
for r in rows {
let group = last_groups
.entry(r.request.request.session_id.as_str())
.or_default();
if group
.first()
.is_some_and(|p| p.request.request.started_at_ms < r.request.request.started_at_ms)
{
group.clear();
}
group.push(r);
}
let last_by_session: BTreeMap<_, _> = last_groups
.into_iter()
.filter_map(|(id, group)| {
if group.len() == 1 {
return Some((id, group[0]));
}
let first = group[0];
if first.turn.is_none()
|| first.turn_partial
|| group.iter().any(|r| {
r.turn != first.turn
|| r.epoch != first.epoch
|| r.turn_partial
|| r.turn_last_request != first.turn_last_request
})
{
return None;
}
group
.iter()
.find(|r| {
r.turn_last_request.as_deref() == Some(r.request.request.request_id.as_str())
})
.copied()
.map(|r| (id, r))
})
.collect();
let mut seen = BTreeSet::new();
let mut result = Vec::new();
for r in rows {
let own = &r.request.request;
let first_physical = seen.insert(own.session_id.as_str());
let boundary = first_physical
&& r.predecessor
.as_deref()
.is_some_and(|id| last_by_session.get(id).is_none_or(|p| p.anchor == r.anchor));
let final_turn = r.turn.as_deref().is_some_and(|turn| {
r.turn_last_request.as_deref() == Some(own.request_id.as_str())
&& first_by_turn.contains_key(&(own.session_id.as_str(), r.epoch.as_deref(), turn))
});
let prior_http = previous_http.get(own.session_id.as_str()).copied();
let prev = if boundary {
r.predecessor
.as_deref()
.and_then(|id| last_by_session.get(id).copied())
} else if final_turn {
previous_turn
.get(own.session_id.as_str())
.copied()
.or(prior_http.filter(|p| p.turn != r.turn))
} else {
prior_http
};
let known = r.terminal && r.request.model.native_model.is_some();
let endpoint_start = if final_turn && !boundary {
r.turn
.as_deref()
.and_then(|turn| {
first_by_turn.get(&(own.session_id.as_str(), r.epoch.as_deref(), turn))
})
.copied()
.unwrap_or(own.started_at_ms)
} else {
own.started_at_ms
};
let endpoints = known
&& prev.is_some_and(|p| {
p.terminal
&& p.request
.finished_at_ms
.is_some_and(|at| at < endpoint_start)
&& p.request.model.native_model.is_some()
});
let changed = endpoints
.then(|| prev.unwrap().request.model.native_model != r.request.model.native_model);
let reasoning = endpoints
.then(|| {
prev.and_then(|p| {
p.request
.model
.reasoning_profile_id
.as_ref()
.zip(r.request.model.reasoning_profile_id.as_ref())
.map(|(a, b)| a != b)
})
})
.flatten();
let adjacent = final_turn
&& prev.is_some_and(|p| {
p.epoch.is_some()
&& p.epoch == r.epoch
&& p.ordinal
.zip(r.ordinal)
.is_some_and(|(a, b)| a.checked_add(1) == Some(b))
&& p.turn != r.turn
&& !p.turn_partial
&& !r.turn_partial
&& endpoints
});
let same_turn =
prev.is_some_and(|p| p.turn.is_some() && p.turn == r.turn && p.epoch == r.epoch);
let kind = if boundary {
AnalysisTransitionKindV1::ContinuationBoundary
} else if !r.terminal {
AnalysisTransitionKindV1::Unknown
} else if final_turn
&& prev.is_none()
&& r.ordinal == Some(1)
&& !r.turn_partial
&& r.gap.is_none()
{
AnalysisTransitionKindV1::InitialSelection
} else if adjacent && changed == Some(true) {
AnalysisTransitionKindV1::BetweenTurnChange
} else if adjacent && reasoning == Some(true) {
AnalysisTransitionKindV1::ReasoningChange
} else if (adjacent || same_turn) && changed == Some(false) {
AnalysisTransitionKindV1::Unchanged
} else {
AnalysisTransitionKindV1::Unknown
};
let completeness = if !r.terminal || prev.is_some_and(|p| !p.terminal) {
"pending"
} else if boundary || prev.is_some() && !adjacent && !same_turn {
"turn_context_reset"
} else if known && (endpoints || kind == AnalysisTransitionKindV1::InitialSelection) {
"complete"
} else {
"unknown"
};
let transition = AnalysisTransitionV1 {
kind,
session_id: own.session_id.clone(),
request_id: own.request_id.clone(),
previous_session_id: prev.map(|p| p.request.request.session_id.clone()),
previous_request_id: prev.map(|p| p.request.request.request_id.clone()),
at_ms: own.started_at_ms,
previous_model: prev.map(|p| p.request.model.clone()),
model: r.request.model.clone(),
model_changed: changed,
reasoning_changed: reasoning,
completeness: completeness.into(),
receipt_id: own.receipt_id.clone(),
reason: None,
};
result.push(transition.clone());
for kind in [
(own.within_request_fallback == Some(true))
.then_some(AnalysisTransitionKindV1::WithinRequestFallback),
r.credential_relay
.then_some(AnalysisTransitionKindV1::CredentialRelay),
]
.into_iter()
.flatten()
{
let mut within = transition.clone();
within.kind = kind;
within.previous_session_id = None;
within.previous_request_id = None;
within.previous_model = None;
within.model_changed = Some(kind == AnalysisTransitionKindV1::WithinRequestFallback);
within.reasoning_changed = None;
result.push(within);
}
previous_http.insert(own.session_id.as_str(), r);
if final_turn {
previous_turn.insert(own.session_id.as_str(), r);
}
}
result
}
pub(super) fn reasons(
db: &Connection,
reader: &ObservationReaderContext,
values: &mut [AnalysisTransitionV1],
) -> Result<(), Error> {
let mut cache = BTreeMap::new();
for t in values {
if !cache.contains_key(&t.request_id) {
cache.insert(
t.request_id.clone(),
crate::query_v2::routing_reason(
db,
reader.workspace().as_str(),
&t.session_id,
&t.request_id,
)?,
);
}
t.reason = cache.get(&t.request_id).cloned().flatten();
}
Ok(())
}
#[cfg(test)]
mod tests {
use super::*;
fn row(id: &str, turn: &str, ordinal: u64, model: &str, at: i64) -> Row {
Row {
request: AnalysisRequestV1 {
request: ObservedRequestSummary {
session_id: "physical-a".into(),
request_id: id.into(),
started_at_ms: at,
outcome: Some("accepted".into()),
receipt_id: Some(format!("receipt-{id}")),
run_id: None,
parent_context_ref: None,
native_turn_id: Some(turn.into()),
relation_conflicted: false,
routing_context: ObservationRoutingContextV1::unavailable(),
attempted_model_count: 1,
within_request_fallback: Some(false),
final_native_model: Some(model.into()),
between_turn_model_change: None,
previous_native_turn_id: None,
previous_turn_model: None,
turn_final_native_model: None,
},
model: AnalysisModelV1 {
native_model: Some(model.into()),
model_configuration_id: Some(model.into()),
reasoning_profile_id: Some("max".into()),
},
finished_at_ms: Some(at + 1),
content: vec![],
content_partial: false,
content_state: "not_observed".into(),
},
anchor: "physical-a".into(),
predecessor: None,
gap: None,
turn: Some(turn.into()),
ordinal: Some(ordinal),
epoch: Some("epoch-1".into()),
turn_partial: false,
turn_first_request: Some(id.into()),
turn_last_request: Some(id.into()),
terminal: true,
credential_relay: false,
}
}
#[test]
fn stage_http_changes_do_not_replace_the_final_model_of_each_user_turn() {
let mut rows = vec![
row("a", "turn-a", 1, "cheap", 10),
row("b", "turn-b", 2, "primary", 20),
row("c", "turn-b", 2, "cheap", 30),
row("d", "turn-c", 3, "cheap", 40),
row("e", "turn-c", 3, "primary", 50),
];
for (start, end) in [(1, 2), (3, 4)] {
let first = rows[start].request.request.request_id.clone();
let last = rows[end].request.request.request_id.clone();
for r in &mut rows[start..=end] {
r.turn_first_request = Some(first.clone());
r.turn_last_request = Some(last.clone());
}
}
let values = transitions(&rows);
let changed: Vec<_> = values
.iter()
.filter(|v| v.kind == AnalysisTransitionKindV1::BetweenTurnChange)
.collect();
assert_eq!(changed.len(), 1);
assert_eq!(changed[0].request_id, "e");
assert_eq!(changed[0].previous_request_id.as_deref(), Some("c"));
assert_eq!(
values.iter().find(|v| v.request_id == "c").unwrap().kind,
AnalysisTransitionKindV1::Unchanged
);
}
#[test]
fn tied_request_timestamps_use_the_native_last_request_not_lexical_order() {
let mut rows = vec![
row("a", "one", 1, "primary", 10),
row("b", "two", 2, "primary", 20),
row("c", "two", 2, "cheap", 20),
row("d", "three", 3, "cheap", 40),
];
for r in &mut rows[1..=2] {
r.turn_first_request = Some("c".into());
r.turn_last_request = Some("b".into());
}
let values = transitions(&rows);
let changed: Vec<_> = values
.iter()
.filter(|v| v.kind == AnalysisTransitionKindV1::BetweenTurnChange)
.collect();
assert_eq!(changed.len(), 1);
assert_eq!(changed[0].request_id, "d");
assert_eq!(changed[0].previous_request_id.as_deref(), Some("b"));
}
#[test]
fn restarted_turn_order_does_not_prove_adjacent_user_turns() {
let a = row("a", "before", 1, "cheap", 10);
let mut b = row("b", "after", 1, "primary", 20);
b.epoch = Some("new-epoch".into());
let values = transitions(&[a, b]);
assert_eq!(values[1].kind, AnalysisTransitionKindV1::Unknown);
assert_eq!(values[1].completeness, "turn_context_reset");
}
#[test]
fn interleaved_continuation_endpoints_leave_both_changes_unknown() {
let mut a = row("a", "before", 1, "cheap", 10);
a.request.finished_at_ms = Some(40);
let mut b = row("b", "after", 2, "primary", 20);
b.request.request.session_id = "physical-b".into();
b.predecessor = Some("physical-a".into());
let values = transitions(&[a, b]);
assert_eq!(
values[1].kind,
AnalysisTransitionKindV1::ContinuationBoundary
);
assert_eq!(values[1].model_changed, None);
assert_eq!(values[1].reasoning_changed, None);
assert_eq!(values[1].completeness, "turn_context_reset");
}
#[test]
fn same_model_credential_relay_is_not_a_model_switch() {
let mut a = row("a", "turn", 1, "cheap", 10);
a.credential_relay = true;
let values = transitions(&[a]);
let relay = values
.iter()
.find(|v| v.kind == AnalysisTransitionKindV1::CredentialRelay)
.unwrap();
assert_eq!(relay.model_changed, Some(false));
}
}