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
//! Exact catalog controls replace incoming controls before native request serialization.
use super::*;
use crate::server::core_runtime::model_ir::RequestedReasoningDisposition;
use crate::server::core_runtime::profiles::{
CandidateProtocolProfile, CriticalFact, NativeReasoningFieldAssignment, NativeReasoningRender,
NativeReasoningValue, ReasoningControlKind, fixed_reasoning,
};
use crate::server::request_plan::IngressProtocol;
use serde_json::json;
fn display_request() -> serde_json::Value {
json!({"model":"alias", "max_tokens":2048,
"messages":[{"role":"user","content":"hello"}],
"thinking":{"type":"enabled","budget_tokens":1024,"display":"omitted"},
"output_config":{"format":{"type":"json_schema","schema":{"type":"object","properties":{"ok":{"type":"boolean"}}}}}})
}
#[test]
fn clear_thinking_strategy_follows_selected_plan_mode() {
let mut body = display_request();
body["context_management"] = json!({"edits":[{"type":"clear_thinking_20251015","keep":"all"}]});
let mut request = decode_ingress_request(IngressProtocol::Messages, &body).unwrap();
request.requested_reasoning.disposition = RequestedReasoningDisposition::OverriddenByAgentPlan;
for mode in ["default", "disabled", "enabled", "adaptive"] {
let profile = if mode == "default" {
CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::Messages,
"physical",
fixed_reasoning("default"),
)
} else {
display_profile(mode)
};
let native = project_candidate_request(&request, &profile).unwrap();
if matches!(mode, "enabled" | "adaptive") {
assert_eq!(
native.body["context_management"],
body["context_management"]
);
} else {
assert!(
native.body.get("context_management").is_none(),
"{mode}: {}",
native.body
);
}
assert_eq!(
native.body["output_config"]["format"],
body["output_config"]["format"]
);
}
// Every candidate starts from the same immutable caller payload.
assert_eq!(
request.native_body.as_ref().unwrap()["context_management"],
body["context_management"]
);
}
#[test]
fn clear_thinking_removal_preserves_other_context_controls_and_fixed_payload() {
let strategy = json!({"type":"clear_thinking_20251015","keep":"all"});
let other = json!({"type":"clear_tool_uses_20250919","keep":{"type":"tool_uses","value":3}});
for (context, expected) in [
(
json!({"edits":[strategy.clone(),other.clone()],"future_control":true}),
json!({"edits":[other],"future_control":true}),
),
(
json!({"edits":[strategy],"future_control":true}),
json!({"future_control":true}),
),
(
json!({"edits":[{"type":"future_strategy"}]}),
json!({"edits":[{"type":"future_strategy"}]}),
),
(json!({"edits":[]}), json!({"edits":[]})),
] {
let mut body = display_request();
body["context_management"] = context.clone();
let mut request = decode_ingress_request(IngressProtocol::Messages, &body).unwrap();
request.requested_reasoning.disposition =
RequestedReasoningDisposition::OverriddenByAgentPlan;
let native = project_candidate_request(&request, &display_profile("disabled")).unwrap();
assert_eq!(native.body["context_management"], expected);
request.requested_reasoning.disposition =
RequestedReasoningDisposition::AppliedToFixedBinding;
let fixed = project_candidate_request(&request, &display_profile("disabled")).unwrap();
assert_eq!(fixed.body["context_management"], context);
assert_eq!(fixed.body["thinking"], body["thinking"]);
}
}
#[test]
fn thinking_display_plan_default_never_emits_display_only_object() {
let body = display_request();
let request = decode_ingress_request(IngressProtocol::Messages, &body).unwrap();
let profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::Messages,
"physical",
fixed_reasoning("default"),
);
let native = project_candidate_request(&request, &profile).unwrap();
assert!(native.body.get("thinking").is_none(), "{}", native.body);
assert_eq!(
native.body["output_config"]["format"],
body["output_config"]["format"]
);
}
#[test]
fn thinking_display_omitted_can_cross_protocol_without_disabling_reasoning() {
let request = decode_ingress_request(IngressProtocol::Messages, &display_request()).unwrap();
for upstream in [IngressProtocol::ChatCompletions, IngressProtocol::Responses] {
let profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
upstream,
"physical",
fixed_reasoning("default"),
);
let native = project_candidate_request(&request, &profile).unwrap();
assert!(native.body.get("thinking").is_none());
assert!(native.body.get("reasoning_effort").is_none());
}
}
#[test]
fn messages_adaptive_effort_overwrites_caller_disabled_thinking_and_effort() {
let request = decode_ingress_request(
IngressProtocol::Messages,
&json!({
"model":"alias", "max_tokens":2048, "messages":[{"role":"user","content":"hello"}],
"thinking":{"type":"disabled"}, "output_config":{"effort":"low"}
}),
)
.unwrap();
let mut reasoning = fixed_reasoning("high");
reasoning.control_kind = ReasoningControlKind::Discrete;
reasoning.render = NativeReasoningRender::ExactFields {
protocol: IngressProtocol::Messages,
fields: vec![
NativeReasoningFieldAssignment {
path: vec!["output_config".into(), "effort".into()],
value: NativeReasoningValue::String("high".into()),
},
NativeReasoningFieldAssignment {
path: vec!["thinking".into(), "type".into()],
value: NativeReasoningValue::String("adaptive".into()),
},
],
};
let profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::Messages,
"physical",
reasoning,
);
let native = project_candidate_request(&request, &profile).unwrap();
assert_eq!(native.body["thinking"], json!({"type":"adaptive"}));
assert_eq!(native.body["output_config"], json!({"effort":"high"}));
}
fn project_reasoning(
protocol: IngressProtocol,
reasoning: crate::server::core_runtime::profiles::ReasoningProfileCapability,
max_tokens: u64,
) -> Result<PreparedNativeRequest, ProtocolAdapterError> {
project_reasoning_with_cap(protocol, reasoning, max_tokens, max_tokens)
}
fn project_reasoning_with_cap(
protocol: IngressProtocol,
reasoning: crate::server::core_runtime::profiles::ReasoningProfileCapability,
max_tokens: u64,
configured_cap: u64,
) -> Result<PreparedNativeRequest, ProtocolAdapterError> {
let body = match protocol {
IngressProtocol::Responses => {
json!({"model":"alias", "input":"hello", "reasoning":{"effort":"high", "summary":"auto"}})
}
IngressProtocol::Messages => {
json!({"model":"alias", "max_tokens":max_tokens, "messages":[{"role":"user","content":"hello"}], "thinking":{"type":"enabled","budget_tokens":4096}})
}
IngressProtocol::ChatCompletions => {
json!({"model":"alias", "messages":[{"role":"user","content":"hello"}]})
}
};
let request = decode_ingress_request(protocol, &body).unwrap();
let mut profile =
CandidateProtocolProfile::exact_portable_path(protocol, protocol, "physical", reasoning);
profile.capability.context.max_output_tokens = CriticalFact::Exact(configured_cap);
profile.capability.context.max_total_tokens =
CriticalFact::Exact(Some(1024 * 1024 + configured_cap));
project_candidate_request(&request, &profile)
}
#[test]
fn released_toggle_profiles_render_standard_controls_without_changing_frozen_bytes() {
// Frozen output of the 0.2.0 producer d625e653 (enable_thinking toggle).
// Do not build this input through the current daemon projection.
let released = r#"{"profile_id":"enabled","control_kind":"toggle","render":{"kind":"exact_fields","protocol":"responses","fields":[{"path":["reasoning","effort"],"value":{"kind":"string","value":"high"}}]},"accounting":"within_output_cap","additional_reservation_tokens":0}"#;
let enabled: crate::server::core_runtime::profiles::ReasoningProfileCapability =
serde_json::from_str(released).unwrap();
let before = serde_json::to_value(&enabled).unwrap();
let rendered = project_reasoning(IngressProtocol::Responses, enabled.clone(), 2048).unwrap();
assert_eq!(rendered.body["reasoning"]["effort"], "low");
assert_eq!(rendered.body["reasoning"]["summary"], "auto");
assert_eq!(serde_json::to_value(&enabled).unwrap(), before);
let mut explicit = enabled.clone();
explicit.profile_id = "high".into();
explicit.control_kind = ReasoningControlKind::Discrete;
assert_eq!(
project_reasoning(IngressProtocol::Responses, explicit, 2048)
.unwrap()
.body["reasoning"]["effort"],
"high"
);
for on in [false, true] {
for protocol in [IngressProtocol::Responses, IngressProtocol::Messages] {
let mut profile = enabled.clone();
profile.profile_id = if on { "enabled" } else { "disabled" }.into();
profile.render = NativeReasoningRender::ExactFields {
protocol,
fields: vec![NativeReasoningFieldAssignment {
path: if protocol == IngressProtocol::Messages {
vec!["thinking".into(), "type".into()]
} else {
vec!["reasoning".into(), "effort".into()]
},
value: NativeReasoningValue::String(
match (protocol, on) {
(IngressProtocol::Messages, true) => "enabled",
(IngressProtocol::Messages, false) => "disabled",
(_, true) => "low",
(_, false) => "none",
}
.into(),
),
}],
};
let rendered = project_reasoning(protocol, profile.clone(), 2048).unwrap();
if protocol == IngressProtocol::Messages {
assert_eq!(
rendered.body["thinking"],
if on {
json!({"type":"enabled", "budget_tokens":1024})
} else {
json!({"type":"disabled"})
}
);
if on {
assert!(project_reasoning(protocol, profile, 1024).is_err());
}
} else {
assert_eq!(
rendered.body["reasoning"]["effort"],
if on { "low" } else { "none" }
);
}
}
}
}
#[test]
fn messages_explicit_budget_is_preserved_and_checked_against_output_cap() {
for budget in [512, 1024, 2048, 4096] {
let mut profile = fixed_reasoning(format!("budget-{budget}"));
profile.control_kind = ReasoningControlKind::Budget;
profile.render = NativeReasoningRender::ExactBudget {
protocol: IngressProtocol::Messages,
fields: vec![NativeReasoningFieldAssignment {
path: vec!["thinking".into(), "budget_tokens".into()],
value: NativeReasoningValue::U64(budget),
}],
budget_path: vec!["thinking".into(), "budget_tokens".into()],
selected_tokens: budget,
min_tokens: 512,
max_tokens: 4096,
step_tokens: 512,
};
let rendered = project_reasoning(IngressProtocol::Messages, profile, 4096);
if (1024..4096).contains(&budget) {
assert_eq!(
rendered.unwrap().body["thinking"],
json!({"type":"enabled", "budget_tokens":budget})
);
} else {
assert!(rendered.is_err());
}
}
}
#[test]
fn messages_manual_toggle_checks_the_effective_candidate_output_cap() {
let mut reasoning = fixed_reasoning("enabled");
reasoning.control_kind = ReasoningControlKind::Toggle;
reasoning.render = NativeReasoningRender::ExactFields {
protocol: IngressProtocol::Messages,
fields: vec![NativeReasoningFieldAssignment {
path: vec!["thinking".into(), "type".into()],
value: NativeReasoningValue::String("enabled".into()),
}],
};
assert!(
project_reasoning_with_cap(IngressProtocol::Messages, reasoning.clone(), 4096, 1024,)
.is_err()
);
let rendered =
project_reasoning_with_cap(IngressProtocol::Messages, reasoning, 4096, 2048).unwrap();
assert_eq!(rendered.body["max_tokens"], 2048);
assert_eq!(rendered.body["thinking"]["budget_tokens"], 1024);
}
#[test]
fn legacy_custom_boolean_profile_keeps_its_exact_assignment() {
for protocol in [IngressProtocol::Responses, IngressProtocol::Messages] {
let mut reasoning = fixed_reasoning("custom-boolean-name");
reasoning.control_kind = ReasoningControlKind::Toggle;
reasoning.render = NativeReasoningRender::ExactFields {
protocol,
fields: vec![NativeReasoningFieldAssignment {
path: vec!["custom_toggle".into()],
value: NativeReasoningValue::Bool(true),
}],
};
let rendered = project_reasoning(protocol, reasoning, 4096).unwrap();
assert_eq!(rendered.body["custom_toggle"], true);
assert!(rendered.body.get("thinking").is_none());
if protocol == IngressProtocol::Responses {
assert_eq!(rendered.body["reasoning"], json!({"summary":"auto"}));
}
}
}
#[test]
fn plan_reasoning_removes_legacy_switch_aliases_without_changing_fixed_native_controls() {
for protocol in [IngressProtocol::Responses, IngressProtocol::Messages] {
let body = match protocol {
IngressProtocol::Responses => json!({
"model":"alias", "input":"hello", "enable_thinking":false,
"thinking":{"enabled":false}, "reasoning":{"effort":"high","summary":"auto"}
}),
IngressProtocol::Messages => json!({
"model":"alias", "max_tokens":4096,
"messages":[{"role":"user","content":"hello"}],
"enable_thinking":false, "thinking":{"enabled":false}
}),
IngressProtocol::ChatCompletions => unreachable!(),
};
let mut request = decode_ingress_request(protocol, &body).unwrap();
let mut reasoning = fixed_reasoning("enabled");
reasoning.control_kind = ReasoningControlKind::Toggle;
reasoning.render = NativeReasoningRender::ExactFields {
protocol,
fields: vec![NativeReasoningFieldAssignment {
path: if protocol == IngressProtocol::Responses {
vec!["reasoning".into(), "effort".into()]
} else {
vec!["thinking".into(), "type".into()]
},
value: NativeReasoningValue::String(
if protocol == IngressProtocol::Responses {
"low"
} else {
"enabled"
}
.into(),
),
}],
};
let mut profile = CandidateProtocolProfile::exact_portable_path(
protocol, protocol, "physical", reasoning,
);
profile.capability.context.max_output_tokens = CriticalFact::Exact(4096);
let rendered = project_candidate_request(&request, &profile).unwrap();
assert!(rendered.body.get("enable_thinking").is_none());
assert!(rendered.body["thinking"].get("enabled").is_none());
if protocol == IngressProtocol::Responses {
assert!(rendered.body.get("thinking").is_none());
assert_eq!(
rendered.body["reasoning"],
json!({"effort":"low","summary":"auto"})
);
} else {
assert_eq!(
rendered.body["thinking"],
json!({"type":"enabled","budget_tokens":1024})
);
}
request.requested_reasoning.disposition =
RequestedReasoningDisposition::AppliedToFixedBinding;
let fixed = project_candidate_request(&request, &profile).unwrap();
assert_eq!(fixed.body["enable_thinking"], body["enable_thinking"]);
assert_eq!(fixed.body["thinking"], body["thinking"]);
if protocol == IngressProtocol::Responses {
assert_eq!(fixed.body["reasoning"], body["reasoning"]);
}
}
}
fn display_profile(mode: &str) -> CandidateProtocolProfile {
let mut reasoning = fixed_reasoning(mode);
reasoning.control_kind = ReasoningControlKind::Discrete;
let mut fields = vec![NativeReasoningFieldAssignment {
path: vec!["thinking".into(), "type".into()],
value: NativeReasoningValue::String(mode.into()),
}];
if mode == "enabled" {
fields.push(NativeReasoningFieldAssignment {
path: vec!["thinking".into(), "budget_tokens".into()],
value: NativeReasoningValue::U64(1024),
});
}
reasoning.render = NativeReasoningRender::ExactFields {
protocol: IngressProtocol::Messages,
fields,
};
let mut profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::Messages,
"physical",
reasoning,
);
// Manual thinking must fit strictly below the effective output limit.
profile.capability.context.max_output_tokens = CriticalFact::Exact(2048);
profile
}
#[test]
fn thinking_display_plan_modes_use_only_plan_budget_and_preserve_format() {
let body = display_request();
let request = decode_ingress_request(IngressProtocol::Messages, &body).unwrap();
for (mode, expected) in [
("disabled", json!({"type":"disabled"})),
("adaptive", json!({"type":"adaptive","display":"omitted"})),
(
"enabled",
json!({"type":"enabled","budget_tokens":1024,"display":"omitted"}),
),
] {
let native = project_candidate_request(&request, &display_profile(mode)).unwrap();
assert_eq!(native.body["thinking"], expected);
assert_eq!(
native.body["output_config"]["format"],
body["output_config"]["format"]
);
}
assert_eq!(request.native_body.as_ref().unwrap(), &body);
}
#[test]
fn thinking_display_fixed_preserves_native_controls_and_unknown_values_stay_bounded() {
use crate::server::core_runtime::model_ir::RequestedReasoningDisposition;
for display in [
json!("omitted"),
json!("summarized"),
json!("future-mode"),
json!(42),
json!(null),
] {
let mut body = display_request();
body["thinking"]["display"] = display.clone();
let mut request = decode_ingress_request(IngressProtocol::Messages, &body).unwrap();
assert_eq!(request.native_only, display != "omitted");
request.requested_reasoning.disposition =
RequestedReasoningDisposition::AppliedToFixedBinding;
let native = project_candidate_request(&request, &display_profile("disabled")).unwrap();
assert_eq!(native.body["thinking"], body["thinking"]);
request.requested_reasoning.disposition =
RequestedReasoningDisposition::OverriddenByAgentPlan;
if display != "omitted" {
let native = project_candidate_request(&request, &display_profile("adaptive")).unwrap();
assert_eq!(native.body["thinking"]["display"], display);
assert!(project_candidate_request(&request, &display_profile("disabled")).is_err());
for upstream in [IngressProtocol::ChatCompletions, IngressProtocol::Responses] {
let profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
upstream,
"physical",
fixed_reasoning("default"),
);
assert!(project_candidate_request(&request, &profile).is_err());
}
}
}
}
#[test]
fn thinking_display_does_not_allow_unrelated_extensions_to_cross_protocol() {
let mut body = display_request();
body["thinking"]["future_control"] = json!(true);
let request = decode_ingress_request(IngressProtocol::Messages, &body).unwrap();
assert!(request.native_only);
let native_default = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::Messages,
"physical",
fixed_reasoning("default"),
);
assert!(project_candidate_request(&request, &native_default).is_err());
let adaptive = project_candidate_request(&request, &display_profile("adaptive")).unwrap();
assert_eq!(adaptive.body["thinking"]["future_control"], true);
assert_eq!(adaptive.body["thinking"]["display"], "omitted");
let profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::ChatCompletions,
"physical",
fixed_reasoning("default"),
);
assert!(project_candidate_request(&request, &profile).is_err());
}
#[test]
fn thinking_display_policy_survives_replay_externalization() {
use crate::{
content_ref::externalize_model_request,
replay::{ReplayConfig, ReplayManager},
};
use hiroute_gateway_core::runtime::body::BudgetTree;
let root = std::env::temp_dir().join(format!(
"hiroute-thinking-display-{}-{}",
std::process::id(),
std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.unwrap()
.as_nanos()
));
let manager = ReplayManager::open(ReplayConfig {
root: root.clone(),
memory_threshold_bytes: 128,
record_bytes: 31,
orphan_ttl: std::time::Duration::from_secs(60),
})
.unwrap();
let budget = BudgetTree::new(1024 * 1024, 1024 * 1024)
.unwrap()
.stream(1024 * 1024)
.unwrap();
let store = manager.begin_request(budget).unwrap();
let mut request =
decode_ingress_request(IngressProtocol::Messages, &display_request()).unwrap();
externalize_model_request(&mut request, &store, 0).unwrap();
assert!(request.requested_reasoning.messages_omit_thinking);
assert_ne!(
request.native_body.as_ref().unwrap()["thinking"]["display"],
"omitted"
);
assert!(project_candidate_request_template(&request, &display_profile("disabled")).is_ok());
let serialized = serde_json::to_value(&request).unwrap();
assert!(
serialized["requested_reasoning"]
.get("messages_omit_thinking")
.is_none()
);
drop(request);
drop(store);
drop(manager);
std::fs::remove_dir_all(root).unwrap();
}