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 serde_json::json;
#[path = "branch_tests.rs"]
pub(crate) mod branches;
use super::*;
use crate::server::core_runtime::model_ir::{
CanonicalInstruction, CanonicalMessage, CanonicalTool, ContentPart, ImageSource,
InstructionRole, MODEL_REQUEST_IR_SCHEMA, MessageRole, ModelRequestIRV1, OpaqueProviderState,
RequestedReasoningControl, ToolChoice, ToolKindV1, ToolOutput, ToolResultStatusV1,
};
use crate::server::core_runtime::profiles::{
CandidateProtocolProfile, CriticalFact, Fidelity, NativeProviderStateEmission, fixed_reasoning,
};
use crate::server::request_plan::IngressProtocol;
fn request(protocol: IngressProtocol, text: &str) -> ModelRequestIRV1 {
ModelRequestIRV1 {
native_body: None,
native_only: false,
schema_version: MODEL_REQUEST_IR_SCHEMA.into(),
ingress_protocol: protocol,
responses_options: None,
responses_item_ids: Default::default(),
responses_item_statuses: Default::default(),
served_model_id: "agent/test".into(),
stream: false,
instructions: Vec::new(),
messages: vec![CanonicalMessage {
role: MessageRole::User,
content: vec![ContentPart::Text { text: text.into() }],
name: None,
}],
tools: Vec::new(),
tool_namespaces: Vec::new(),
responses_tool_order: Vec::new(),
web_search: None,
responses_search_history: Default::default(),
responses_annotations: Default::default(),
responses_message_phases: Default::default(),
responses_internal_chat_message_metadata: Default::default(),
responses_reasoning_history: Default::default(),
tool_choice: ToolChoice::None,
parallel_tool_calls: false,
requested_reasoning: RequestedReasoningControl::absent(),
requested_max_output_tokens: None,
provider_state: Vec::new(),
}
}
fn strategy() -> CompiledComplexityStrategyV1 {
ComplexityV1::compile(Vec::<(String, String)>::new()).unwrap()
}
fn decision(text: &str) -> BranchDecisionV1 {
ComplexityV1::decide(Some(text), None, &strategy())
.unwrap()
.0
}
fn candidate(
id: &str,
ingress: IngressProtocol,
score: Option<i32>,
cost: Option<u64>,
class: CostClassV1,
) -> PlannerCandidateFactsV1 {
let mut candidate = PlannerCandidateFactsV1::seal(
id,
format!("binding-{id}"),
CandidateProtocolProfile::exact_portable_path(
ingress,
IngressProtocol::Responses,
format!("native-{id}"),
fixed_reasoning("fixed"),
),
100,
score,
class,
cost,
)
.unwrap();
if class == CostClassV1::Paid {
candidate.paid_budget_quote = PaidBudgetQuoteFactV1::Available {
upper_bound_micros: cost.expect("paid fixture has a pure quote"),
};
}
candidate
}
fn stateful_messages_candidate(id: &str) -> PlannerCandidateFactsV1 {
let mut facts = candidate(
id,
IngressProtocol::Messages,
Some(50),
Some(20),
CostClassV1::Paid,
);
facts.protocol_profile = CandidateProtocolProfile::exact_portable_path(
IngressProtocol::Messages,
IngressProtocol::Messages,
format!("native-{id}"),
fixed_reasoning("fixed"),
);
facts.protocol_profile.capability.native_provider_state = NativeProviderStateEmission::Native;
facts.protocol_profile.capability.request.provider_state = Fidelity::Exact;
facts.protocol_profile.capability.response.provider_state = Fidelity::Exact;
refresh_profile(&mut facts);
facts
}
fn limits() -> RequestOwnedLimitsV1 {
RequestOwnedLimitsV1 {
max_candidate_bindings: 6,
max_attempts: 4,
deadline_cap_ms: 3_600_000,
paid_budget_ceiling_micros: Some(1_000_000),
}
}
fn policy(
route: MaterializedRouteV1,
groups: Vec<MaterializedModelGroupV1>,
complexity_strategy: Option<CompiledComplexityStrategyV1>,
cost_policy: StaticCostPolicyV1,
) -> CompiledPlannerPolicyV1 {
CompiledPlannerPolicyV1 {
schema_version: String::new(),
served_model_id: "agent/test".into(),
identity: PlannerRouteIdentityV2::Plan {
plan_id: "plan-test".into(),
revision: 7,
},
route,
groups,
complexity_strategy,
cost_policy,
limits: limits(),
policy_digest: String::new(),
}
.seal()
.unwrap()
}
fn input(
request: ModelRequestIRV1,
policy: CompiledPlannerPolicyV1,
candidates: Vec<PlannerCandidateFactsV1>,
) -> PlannerInputV1 {
let classified = policy.complexity_strategy.as_ref().map(|strategy| {
let latest_user = request.messages.iter().rev().find_map(|message| {
(message.role == MessageRole::User).then(|| {
message
.content
.iter()
.filter_map(|part| match part {
ContentPart::Text { text } => Some(text.as_str()),
_ => None,
})
.collect::<Vec<_>>()
.join("\n")
})
});
ComplexityV1::decide(latest_user.as_deref(), None, strategy).unwrap()
});
PlannerInputV1 {
schema_version: PLANNER_INPUT_SCHEMA.into(),
request,
correlated_branch: None,
classification_decision: classified.as_ref().map(|(decision, _)| decision.clone()),
classification_facts: classified.map(|(_, facts)| facts),
context_hold: None,
previous_success_candidate_id: None,
policy,
candidates,
}
}
fn custom_policy(ids: &[&str], cost_policy: StaticCostPolicyV1) -> CompiledPlannerPolicyV1 {
policy(
MaterializedRouteV1::Custom {
group_id: "custom".into(),
},
vec![MaterializedModelGroupV1 {
group_id: "custom".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: ids.iter().map(|id| (*id).into()).collect(),
}],
None,
cost_policy,
)
}
#[test]
fn fixed_route_has_no_plan_identity_and_rejects_multiple_candidates() {
let mut policy = custom_policy(&["fixed"], StaticCostPolicyV1::SubscriptionAndFree);
policy.identity = PlannerRouteIdentityV2::Fixed {
binding_digest: hiroute_domain::CanonicalDigest::of_bytes(b"confirmed-fixed-binding"),
};
policy.limits.max_candidate_bindings = 1;
policy.cost_policy = StaticCostPolicyV1::ExplicitFixed;
let policy = policy.seal().unwrap();
let mut input = input(
request(IngressProtocol::Responses, "hello"),
policy,
vec![candidate(
"fixed",
IngressProtocol::Responses,
None,
None,
CostClassV1::Subscription,
)],
);
let output = Planner.plan(&input).unwrap();
assert_eq!(output.identity, input.policy.identity);
assert_eq!(output.ledger.ordered_candidates.len(), 1);
let encoded = serde_json::to_value(&output).unwrap();
assert!(encoded.get("plan_id").is_none());
assert!(encoded.get("plan_revision").is_none());
input.policy.groups[0].candidate_ids.push("other".into());
input.policy = input.policy.seal().unwrap();
assert!(matches!(
Planner.plan(&input),
Err(PlannerError::InvalidPolicy(_))
));
}
fn evaluation<'a>(output: &'a PlannerOutputV1, id: &str) -> &'a CandidateEvaluationV1 {
output
.ledger
.evaluations
.iter()
.find(|entry| entry.candidate_id == id)
.unwrap()
}
fn refresh_profile(candidate: &mut PlannerCandidateFactsV1) {
candidate.profile_digest = candidate.recompute_profile_digest().unwrap();
}
#[test]
fn planner_complexity_v1_matches_bilingual_and_structural_contract() {
let readme = decision("把 README.md 标题改成 HiRoute");
assert_eq!(
readme.execution_group,
hiroute_domain::ExecutionGroupV1::Regular
);
assert_eq!(readme.complexity_score, Some(1));
assert_eq!(
readme.reason_codes,
[ComplexityReasonCodeV1::ImplementationAction]
);
let complex = decision("修复并发状态机,涉及 a.rs、b.rs,并补两个验收场景:1. 正常;2. 失败");
assert_eq!(
complex.execution_group,
hiroute_domain::ExecutionGroupV1::Primary
);
assert_eq!(complex.complexity_score, Some(6));
assert_eq!(
complex.reason_codes,
[
ComplexityReasonCodeV1::DeepReasoning,
ComplexityReasonCodeV1::MultiFileScope,
ComplexityReasonCodeV1::MultiConstraint,
ComplexityReasonCodeV1::ImplementationAction,
]
);
let constraints = decision("两个要求:1. 分析生产竞态根因;2. 给出迁移方案");
assert_eq!(constraints.complexity_score, Some(3));
assert_eq!(
constraints.execution_group,
hiroute_domain::ExecutionGroupV1::Primary
);
assert_eq!(
constraints.reason_codes,
[
ComplexityReasonCodeV1::DeepReasoning,
ComplexityReasonCodeV1::MultiConstraint,
]
);
for simple in [
"What is the capital of France?",
"人类为什么需要睡眠",
"Explain this function:\n```rust\nfn performance() {}\n```",
"解释这些引用:\n```text\na.rs b.rs\n```",
] {
assert_eq!(
decision(simple).execution_group,
hiroute_domain::ExecutionGroupV1::Regular
);
}
let bullets = decision("- architecture design\n- implement the change");
assert_eq!(
bullets.execution_group,
hiroute_domain::ExecutionGroupV1::Primary
);
assert_eq!(bullets.complexity_score, Some(4));
let (single_file_diff, facts) = ComplexityV1::decide(
Some(
"diff --git a/src/lib.rs b/src/lib.rs\n--- a/src/lib.rs\n+++ b/src/lib.rs\n@@ -1 +1 @@\n-old\n+new",
),
None,
&strategy(),
)
.unwrap();
assert_eq!(facts.distinct_file_or_module_refs, 1);
assert_eq!(single_file_diff.complexity_score, Some(1));
assert_eq!(
single_file_diff.execution_group,
hiroute_domain::ExecutionGroupV1::Regular
);
let (_, diff_with_requirements) = ComplexityV1::decide(
Some(
"diff --git a/src/lib.rs b/src/lib.rs\n--- a/src/lib.rs\n+++ b/src/lib.rs\n@@ -1 +1 @@\n-old\n+new\n\nRequirements:\n- update docs\n- run checks",
),
None,
&strategy(),
)
.unwrap();
assert_eq!(diff_with_requirements.numbered_requirement_count, 2);
let (_, contact_facts) = ComplexityV1::decide(
Some("Contact [email protected], inspect https://example.com/a.rs, and edit README.md"),
None,
&strategy(),
)
.unwrap();
assert_eq!(contact_facts.distinct_file_or_module_refs, 1);
}
#[test]
fn planner_complexity_uses_only_latest_human_not_history_tools_or_request_effort() {
let mut value = request(IngressProtocol::Responses, "谢谢");
value.instructions = vec![CanonicalInstruction {
role: InstructionRole::System,
content: vec![ContentPart::Text {
text: "architecture design security audit ".repeat(10_000),
}],
}];
value.messages.insert(
0,
CanonicalMessage {
role: MessageRole::Assistant,
content: vec![ContentPart::Text {
text: "整个仓库并发状态机".repeat(1_000),
}],
name: None,
},
);
value.tools = vec![CanonicalTool {
kind: ToolKindV1::Function,
name: "dangerous_architecture_tool".into(),
description: Some("security audit".repeat(10_000)),
input_schema: Some(json!({"description": "migration plan".repeat(10_000)})),
strict: Some(true),
format: None,
}];
value.tool_choice = ToolChoice::None;
value.requested_reasoning = RequestedReasoningControl::overridden(json!("high"));
let decided = ComplexityV1::decide(Some("谢谢"), None, &strategy())
.unwrap()
.0;
assert_eq!(
decided.execution_group,
hiroute_domain::ExecutionGroupV1::Regular
);
assert_eq!(decided.complexity_score, Some(0));
assert!(decided.reason_codes.is_empty());
}
#[test]
fn planner_user_phrase_and_continuations_have_fixed_precedence() {
let configured = ComplexityV1::compile(vec![
(
"phrase-local-7".into(),
"SECURITY AUDIT".into(),
),
("phrase-case-fold".into(), "Maße".into()),
])
.unwrap();
let custom = ComplexityV1::decide(Some("Please SECURITY audit this"), None, &configured)
.unwrap()
.0;
assert_eq!(
custom.decision_source,
ComplexityDecisionSourceV1::UserPhrase
);
assert_eq!(custom.matched_user_phrase_ids, ["phrase-local-7"]);
let full_case_fold = ComplexityV1::decide(Some("Please review MASSE"), None, &configured)
.unwrap()
.0;
assert_eq!(full_case_fold.matched_user_phrase_ids, ["phrase-case-fold"]);
let token_boundary =
ComplexityV1::compile(vec![("phrase-token-boundary".into(), "alpha beta".into())]).unwrap();
let embedded_token = ComplexityV1::decide(Some("alpha_beta"), None, &token_boundary)
.unwrap()
.0;
assert!(embedded_token.matched_user_phrase_ids.is_empty());
assert_eq!(
embedded_token.execution_group,
hiroute_domain::ExecutionGroupV1::Regular
);
let original = decision("把 README.md 标题改成 HiRoute");
let mut tool_request = request(IngressProtocol::Responses, "unused");
tool_request.messages = vec![CanonicalMessage {
role: MessageRole::User,
content: vec![ContentPart::ToolResult {
logical_id: "call-1".into(),
tool_kind: ToolKindV1::Function,
output: ToolOutput::Text("opaque Tool output".into()),
status: ToolResultStatusV1::Unknown,
}],
name: None,
}];
let inherited = ComplexityV1::decide(
None,
Some(&CorrelatedBranchDecisionV1 {
kind: ContinuationKindV1::ToolContinuation,
decision: original.clone(),
}),
&strategy(),
)
.unwrap()
.0;
assert_eq!(inherited.branch_id, original.branch_id);
assert_eq!(inherited.complexity_score, original.complexity_score);
assert_eq!(
inherited.reason_codes[0],
ComplexityReasonCodeV1::InheritedToolContinuation
);
let root = ComplexityV1::decide(
Some("now implement the additional validation"),
Some(&CorrelatedBranchDecisionV1 {
kind: ContinuationKindV1::TaskRoot,
decision: original.clone(),
}),
&strategy(),
)
.unwrap()
.0;
assert_eq!(root.decision_source, ComplexityDecisionSourceV1::Inherited);
assert_eq!(
root.reason_codes[0],
ComplexityReasonCodeV1::InheritedTaskRoot
);
let assert_unresolved = |decision: BranchDecisionV1| {
assert_eq!(
decision.execution_group,
hiroute_domain::ExecutionGroupV1::Primary
);
assert_eq!(decision.complexity_score, Some(COMPLEXITY_THRESHOLD));
assert_eq!(
decision.decision_source,
ComplexityDecisionSourceV1::Unresolved
);
assert_eq!(
decision.reason_codes,
[ComplexityReasonCodeV1::TaskContextUnresolved]
);
assert!(decision.fallback_used);
};
for text in ["continue", "继续!"] {
assert_unresolved(
ComplexityV1::decide(Some(text), None, &strategy())
.unwrap()
.0,
);
}
assert_unresolved(
ComplexityV1::decide(
Some("继续"),
Some(&CorrelatedBranchDecisionV1 {
kind: ContinuationKindV1::ToolContinuation,
decision: original.clone(),
}),
&strategy(),
)
.unwrap()
.0,
);
let mut incompatible = original;
incompatible.payload_digest = "sha256:incompatible-task-root".into();
assert_unresolved(
ComplexityV1::decide(
Some("continue"),
Some(&CorrelatedBranchDecisionV1 {
kind: ContinuationKindV1::TaskRoot,
decision: incompatible,
}),
&strategy(),
)
.unwrap()
.0,
);
let mut incompatible_tool = decision("把 README.md 标题改成 HiRoute");
incompatible_tool.payload_digest = "sha256:incompatible-tool-continuation".into();
assert_unresolved(
ComplexityV1::decide(
None,
Some(&CorrelatedBranchDecisionV1 {
kind: ContinuationKindV1::ToolContinuation,
decision: incompatible_tool,
}),
&strategy(),
)
.unwrap()
.0,
);
tool_request.messages.clear();
let unresolved = ComplexityV1::decide(None, None, &strategy()).unwrap().0;
assert_eq!(
unresolved.execution_group,
hiroute_domain::ExecutionGroupV1::Primary
);
assert_eq!(
unresolved.reason_codes,
[ComplexityReasonCodeV1::TaskContextUnresolved]
);
}
#[test]
fn planner_smart_saving_ranks_only_inside_materialized_groups() {
let candidates = vec![
candidate(
"anchor",
IngressProtocol::Responses,
Some(45),
Some(100),
CostClassV1::Paid,
),
candidate(
"bargain",
IngressProtocol::Responses,
Some(40),
Some(1),
CostClassV1::Subscription,
),
candidate(
"weak",
IngressProtocol::Responses,
Some(30),
Some(0),
CostClassV1::Free,
),
candidate(
"primary",
IngressProtocol::Responses,
Some(50),
Some(200),
CostClassV1::Paid,
),
];
let smart = policy(
MaterializedRouteV1::SmartSaving {
extension: None,
native_protocol: None,
judgment: Default::default(),
simple_group_id: "economy".into(),
simple_fallback_group_ids: vec!["primary".into()],
complex_group_id: "primary".into(),
reselect_on_user_message: false,
},
vec![
MaterializedModelGroupV1 {
group_id: "economy".into(),
policy: GroupPolicyV1::CheapestWithRatingGuard {
quality_anchor_ref: "anchor".into(),
max_gap_tenths: 10,
},
candidate_ids: vec!["anchor".into(), "bargain".into(), "weak".into()],
},
MaterializedModelGroupV1 {
group_id: "primary".into(),
policy: GroupPolicyV1::QualityFirst,
candidate_ids: vec!["primary".into(), "anchor".into()],
},
],
Some(strategy()),
StaticCostPolicyV1::BudgetedPaid,
);
let simple = Planner
.plan(&input(
request(IngressProtocol::Responses, "把 README.md 标题改成 HiRoute"),
smart.clone(),
candidates.clone(),
))
.unwrap();
assert_eq!(simple.branch, PlannedBranchV1::SmartSavingSimple);
assert_eq!(
simple
.ledger
.ordered_candidates
.iter()
.map(|entry| entry.candidate_id.as_str())
.collect::<Vec<_>>(),
["bargain", "anchor", "primary"]
);
assert_eq!(
evaluation(&simple, "weak").first_exclusion,
Some(ExclusionReasonCodeV1::RatingGuardExcluded)
);
let mut missing_anchor_candidates = candidates.clone();
missing_anchor_candidates
.iter_mut()
.find(|candidate| candidate.candidate_id == "anchor")
.unwrap()
.overall_score_tenths = None;
let missing_anchor = Planner
.plan(&input(
request(IngressProtocol::Responses, "把 README.md 标题改成 HiRoute"),
smart.clone(),
missing_anchor_candidates,
))
.unwrap();
assert_eq!(
evaluation(&missing_anchor, "anchor").first_exclusion,
Some(ExclusionReasonCodeV1::QualityAnchorUnavailable)
);
assert_eq!(
missing_anchor
.ledger
.ordered_candidates
.iter()
.map(|entry| entry.candidate_id.as_str())
.collect::<Vec<_>>(),
["primary"]
);
let mut unresolved_anchor_effort = candidates.clone();
let unresolved_anchor = unresolved_anchor_effort
.iter_mut()
.find(|candidate| candidate.candidate_id == "anchor")
.unwrap();
unresolved_anchor
.protocol_profile
.capability
.selected_reasoning_profile_id = "missing".into();
refresh_profile(unresolved_anchor);
let missing_effort = Planner
.plan(&input(
request(IngressProtocol::Responses, "把 README.md 标题改成 HiRoute"),
smart.clone(),
unresolved_anchor_effort,
))
.unwrap();
assert_eq!(
evaluation(&missing_effort, "bargain").first_exclusion,
Some(ExclusionReasonCodeV1::QualityAnchorUnavailable)
);
assert_eq!(
missing_effort
.ledger
.ordered_candidates
.iter()
.map(|entry| entry.candidate_id.as_str())
.collect::<Vec<_>>(),
["primary"]
);
let complex = Planner
.plan(&input(
request(
IngressProtocol::Responses,
"Implement an architecture design for this component",
),
smart,
candidates,
))
.unwrap();
assert_eq!(complex.branch, PlannedBranchV1::SmartSavingComplex);
assert_eq!(
complex
.ledger
.ordered_candidates
.iter()
.map(|entry| entry.candidate_id.as_str())
.collect::<Vec<_>>(),
["primary", "anchor"]
);
}
#[test]
fn context_hold_applies_only_inside_the_current_branch() {
let simple = candidate(
"simple",
IngressProtocol::Responses,
Some(40),
Some(10),
CostClassV1::Paid,
);
let complex = candidate(
"complex",
IngressProtocol::Responses,
Some(50),
Some(20),
CostClassV1::Paid,
);
let smart = policy(
MaterializedRouteV1::SmartSaving {
extension: None,
native_protocol: None,
judgment: Default::default(),
simple_group_id: "simple-group".into(),
simple_fallback_group_ids: Vec::new(),
complex_group_id: "complex-group".into(),
reselect_on_user_message: false,
},
vec![
MaterializedModelGroupV1 {
group_id: "simple-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["simple".into()],
},
MaterializedModelGroupV1 {
group_id: "complex-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["complex".into()],
},
],
Some(strategy()),
StaticCostPolicyV1::BudgetedPaid,
);
let mut held = input(
request(IngressProtocol::Responses, "把 README.md 标题改成 HiRoute"),
smart,
vec![simple.clone(), complex.clone()],
);
held.context_hold = Some(HoldPreferenceV1 {
stable_binding_id: complex.stable_binding_id.clone(),
candidate_id: complex.candidate_id.clone(),
profile_digest: complex.profile_digest.clone(),
reasoning_profile_id: "fixed".into(),
origin_group_id: "complex-group".into(),
});
let output = Planner.plan(&held).unwrap();
assert_eq!(output.branch, PlannedBranchV1::SmartSavingSimple);
assert_eq!(
output
.ledger
.ordered_candidates
.iter()
.map(|candidate| candidate.candidate_id.as_str())
.collect::<Vec<_>>(),
["simple"]
);
assert_eq!(output.groups.len(), 1);
assert!(output.reason_ledger.iter().any(|reason| {
reason.code == LedgerReasonCodeV1::ContextHoldInvalidated
&& reason.group_id.as_deref() == Some("complex-group")
}));
let cross_branch_digest = output.input_digest;
held.context_hold = Some(HoldPreferenceV1 {
stable_binding_id: simple.stable_binding_id.clone(),
candidate_id: simple.candidate_id.clone(),
profile_digest: simple.profile_digest.clone(),
reasoning_profile_id: "fixed".into(),
origin_group_id: "simple-group".into(),
});
let same_branch = Planner.plan(&held).unwrap();
assert_eq!(
same_branch.ledger.ordered_candidates[0].candidate_id,
"simple"
);
assert_ne!(same_branch.input_digest, cross_branch_digest);
assert!(same_branch.reason_ledger.iter().any(|reason| {
reason.code == LedgerReasonCodeV1::ContextHoldApplied
&& reason.group_id.as_deref() == Some("simple-group")
}));
let held_digest = same_branch.input_digest;
held.context_hold.as_mut().unwrap().reasoning_profile_id = "wrong".into();
let invalid = Planner.plan(&held).unwrap();
assert_eq!(invalid.ledger.ordered_candidates[0].candidate_id, "simple");
assert_ne!(invalid.input_digest, held_digest);
assert!(
invalid
.reason_ledger
.iter()
.any(|reason| reason.code == LedgerReasonCodeV1::ContextHoldInvalidated)
);
}
#[test]
fn smart_saving_preserves_lossless_state_without_reviving_old_groups() {
let luna = stateful_messages_candidate("luna");
let glm = stateful_messages_candidate("glm");
let smart = policy(
MaterializedRouteV1::SmartSaving {
extension: None,
native_protocol: None,
judgment: Default::default(),
simple_group_id: "simple-group".into(),
simple_fallback_group_ids: vec!["complex-group".into()],
complex_group_id: "complex-group".into(),
reselect_on_user_message: false,
},
vec![
MaterializedModelGroupV1 {
group_id: "simple-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["luna".into()],
},
MaterializedModelGroupV1 {
group_id: "complex-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["glm".into()],
},
],
Some(strategy()),
StaticCostPolicyV1::BudgetedPaid,
);
let mut simple_request = request(IngressProtocol::Messages, "Reply briefly");
simple_request.messages.insert(
0,
CanonicalMessage {
role: MessageRole::Assistant,
content: vec![ContentPart::ProviderState {
state: Box::new(OpaqueProviderState {
block_index: Some(0),
kind: "signed_thinking".into(),
value: json!({"signature":"opaque"}),
}),
}],
name: None,
},
);
let mut planning = input(
simple_request.clone(),
smart.clone(),
vec![luna.clone(), glm.clone()],
);
planning.previous_success_candidate_id = Some("glm".into());
let output = Planner.plan(&planning).unwrap();
assert_eq!(output.branch, PlannedBranchV1::SmartSavingSimple);
assert_eq!(output.ledger.ordered_candidates[0].candidate_id, "luna");
assert_eq!(output.ledger.ordered_candidates[1].candidate_id, "glm");
assert!(
output
.reason_ledger
.iter()
.any(|reason| reason.code == LedgerReasonCodeV1::GroupExhaustedFallback)
);
let mut no_state = simple_request.clone();
no_state.messages.remove(0);
let mut no_state_input = input(no_state, smart.clone(), vec![luna.clone(), glm.clone()]);
no_state_input.previous_success_candidate_id = Some("glm".into());
let normal = Planner.plan(&no_state_input).unwrap();
assert_eq!(normal.ledger.ordered_candidates[0].candidate_id, "luna");
assert_eq!(normal.ledger.ordered_candidates[1].candidate_id, "glm");
let mut complex_request = request(
IngressProtocol::Messages,
"Implement an architecture design for this component",
);
complex_request.messages.insert(
0,
CanonicalMessage {
role: MessageRole::Assistant,
content: vec![ContentPart::ProviderState {
state: Box::new(OpaqueProviderState {
block_index: Some(0),
kind: "signed_thinking".into(),
value: json!({"signature":"opaque"}),
}),
}],
name: None,
},
);
let mut reverse_input = input(
complex_request,
smart.clone(),
vec![luna.clone(), glm.clone()],
);
reverse_input.previous_success_candidate_id = Some("luna".into());
let reverse = Planner.plan(&reverse_input).unwrap();
assert_eq!(reverse.branch, PlannedBranchV1::SmartSavingComplex);
assert_eq!(reverse.ledger.ordered_candidates[0].candidate_id, "glm");
assert_eq!(
reverse.ledger.ordered_candidates.len(),
1,
"primary never falls back to the previous regular model"
);
assert!(
reverse
.reason_ledger
.iter()
.any(|reason| { reason.code == LedgerReasonCodeV1::ComplexNoDowngrade })
);
let mut unavailable_glm = glm.clone();
unavailable_glm.statically_enabled = false;
let mut no_primary = input(
request(
IngressProtocol::Messages,
"Implement an architecture design for this component",
),
smart.clone(),
vec![luna.clone(), unavailable_glm.clone()],
);
no_primary.previous_success_candidate_id = Some("luna".into());
let unavailable_complex = Planner.plan(&no_primary).unwrap();
assert_eq!(
unavailable_complex.branch,
PlannedBranchV1::SmartSavingComplex
);
assert!(
unavailable_complex.ledger.ordered_candidates.is_empty(),
"unavailable primary is not a reason to downgrade"
);
let unavailable = Planner
.plan(&input(
simple_request.clone(),
smart.clone(),
vec![luna.clone(), unavailable_glm],
))
.unwrap();
assert_eq!(
unavailable.ledger.ordered_candidates[0].candidate_id,
"luna"
);
let mut conflicting = simple_request;
conflicting.messages[0]
.content
.push(ContentPart::ProviderState {
state: Box::new(OpaqueProviderState {
block_index: Some(1),
kind: "signed_thinking".into(),
value: json!({"signature":"other"}),
}),
});
let conflict = Planner
.plan(&input(conflicting, smart, vec![luna, glm]))
.unwrap();
assert_eq!(conflict.ledger.ordered_candidates[0].candidate_id, "luna");
}
#[test]
fn smart_saving_uses_explicit_primary_relay_when_regular_cannot_serialize() {
let mut luna = stateful_messages_candidate("luna");
let glm = stateful_messages_candidate("glm");
luna.request_projection_exclusion = Some(ExclusionReasonCodeV1::OpaqueStateUnportable);
let smart = policy(
MaterializedRouteV1::SmartSaving {
extension: None,
native_protocol: None,
judgment: Default::default(),
simple_group_id: "simple-group".into(),
simple_fallback_group_ids: vec!["complex-group".into()],
complex_group_id: "complex-group".into(),
reselect_on_user_message: false,
},
vec![
MaterializedModelGroupV1 {
group_id: "simple-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["luna".into()],
},
MaterializedModelGroupV1 {
group_id: "complex-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["glm".into()],
},
],
Some(strategy()),
StaticCostPolicyV1::BudgetedPaid,
);
let mut state_request = request(IngressProtocol::Messages, "Reply briefly");
state_request.messages.insert(
0,
CanonicalMessage {
role: MessageRole::Assistant,
content: vec![ContentPart::ProviderState {
state: Box::new(OpaqueProviderState {
block_index: Some(0),
kind: "thinking".into(),
value: json!({"type":"thinking","thinking":"note","signature":"opaque"}),
}),
}],
name: None,
},
);
let mut continuation = input(state_request, smart, vec![luna, glm]);
continuation.previous_success_candidate_id = Some("glm".into());
let output = Planner.plan(&continuation).unwrap();
assert_eq!(output.ledger.ordered_candidates[0].candidate_id, "glm");
assert!(
output
.reason_ledger
.iter()
.any(|reason| { reason.code == LedgerReasonCodeV1::GroupExhaustedFallback })
);
}
#[test]
fn smart_saving_cannot_downgrade_to_state_owner_when_primary_lacks_image_capability() {
let luna = stateful_messages_candidate("luna");
let mut glm = stateful_messages_candidate("glm");
glm.protocol_profile.capability.request.image_url = Fidelity::Unsupported;
glm.request_projection_exclusion = Some(ExclusionReasonCodeV1::VisionUnsupported);
refresh_profile(&mut glm);
let smart = policy(
MaterializedRouteV1::SmartSaving {
extension: None,
native_protocol: None,
judgment: Default::default(),
simple_group_id: "simple-group".into(),
simple_fallback_group_ids: Vec::new(),
complex_group_id: "complex-group".into(),
reselect_on_user_message: false,
},
vec![
MaterializedModelGroupV1 {
group_id: "simple-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["luna".into()],
},
MaterializedModelGroupV1 {
group_id: "complex-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["glm".into()],
},
],
Some(strategy()),
StaticCostPolicyV1::BudgetedPaid,
);
let mut complex_request = request(
IngressProtocol::Messages,
"Implement an architecture design for this component",
);
complex_request.messages.insert(
0,
CanonicalMessage {
role: MessageRole::Assistant,
content: vec![ContentPart::ProviderState {
state: Box::new(OpaqueProviderState {
block_index: Some(0),
kind: "signed_thinking".into(),
value: json!({"signature":"opaque"}),
}),
}],
name: None,
},
);
complex_request.messages[1]
.content
.push(ContentPart::Image {
source: ImageSource::Url {
url: "https://image.invalid/diagram.png".into(),
},
});
let mut continuation = input(
complex_request.clone(),
smart.clone(),
vec![luna.clone(), glm.clone()],
);
continuation.previous_success_candidate_id = Some("luna".into());
let output = Planner.plan(&continuation).unwrap();
assert_eq!(output.branch, PlannedBranchV1::SmartSavingComplex);
assert_eq!(
evaluate_candidate(&complex_request, &glm, smart.cost_policy, &smart.limits).unwrap_err(),
ExclusionReasonCodeV1::VisionUnsupported
);
assert!(output.ledger.ordered_candidates.is_empty());
let mut without_state_request = complex_request.clone();
without_state_request.messages.remove(0);
let without_state = Planner
.plan(&input(
without_state_request,
smart.clone(),
vec![luna.clone(), glm.clone()],
))
.unwrap();
assert!(without_state.ledger.ordered_candidates.is_empty());
let mut incapable_owner = luna;
incapable_owner
.protocol_profile
.capability
.request
.image_url = Fidelity::Unsupported;
incapable_owner.request_projection_exclusion = Some(ExclusionReasonCodeV1::VisionUnsupported);
refresh_profile(&mut incapable_owner);
let no_eligible_owner = Planner
.plan(&input(complex_request, smart, vec![incapable_owner, glm]))
.unwrap();
assert!(no_eligible_owner.ledger.ordered_candidates.is_empty());
}
#[test]
fn external_classification_drives_existing_smart_groups_without_rule_score() {
let strategy = ComplexityV1::compile_with_classifier(
Vec::<(String, String)>::new(),
CompiledClassifierKindV1::Rest,
Some(
hiroute_domain::CanonicalDigest::of_bytes(b"rest-classifier")
.as_str()
.to_owned(),
),
)
.unwrap();
let smart = policy(
MaterializedRouteV1::SmartSaving {
extension: None,
native_protocol: None,
judgment: Default::default(),
simple_group_id: "simple-group".into(),
simple_fallback_group_ids: Vec::new(),
complex_group_id: "complex-group".into(),
reselect_on_user_message: false,
},
vec![
MaterializedModelGroupV1 {
group_id: "simple-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["simple".into()],
},
MaterializedModelGroupV1 {
group_id: "complex-group".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["complex".into()],
},
],
Some(strategy.clone()),
StaticCostPolicyV1::BudgetedPaid,
);
let mut planner_input = input(
request(IngressProtocol::Responses, "rename README"),
smart,
vec![
candidate(
"simple",
IngressProtocol::Responses,
Some(40),
Some(10),
CostClassV1::Subscription,
),
candidate(
"complex",
IngressProtocol::Responses,
Some(50),
Some(20),
CostClassV1::Subscription,
),
],
);
planner_input.classification_decision = Some(BranchDecisionV1 {
extension_reason: None,
decision_protocol: Some(hiroute_domain::DecisionProtocolV1::LocalRules),
routing_observation: None,
policy: None,
competence_trigger: None,
execution_group: hiroute_domain::ExecutionGroupV1::Primary,
simple_probability: None,
simple_threshold_millis: None,
selection_reason: hiroute_domain::ModelGroupReasonV1::Heuristic,
strategy_id: strategy.strategy_id.clone(),
schema_version: strategy.schema_version.clone(),
payload_digest: strategy.payload_digest.clone(),
branch_id: hiroute_domain::SMART_SAVING_SCOPE_ID.into(),
complexity_score: None,
threshold: None,
decision_source: ComplexityDecisionSourceV1::ExternalClassifier,
reason_codes: Vec::new(),
matched_user_phrase_ids: Vec::new(),
fallback_used: false,
classification_duration_micros: Some(125),
fallback_reason: None,
});
let output = Planner.plan(&planner_input).unwrap();
assert_eq!(output.branch, PlannedBranchV1::SmartSavingComplex);
assert_eq!(output.ledger.ordered_candidates[0].candidate_id, "complex");
let decision = output.complexity.unwrap();
assert_eq!(
decision.decision_source,
ComplexityDecisionSourceV1::ExternalClassifier
);
assert_eq!(decision.complexity_score, None);
let observed: hiroute_domain::BranchDecisionV1 =
serde_json::from_value(serde_json::to_value(&decision).unwrap()).unwrap();
assert_eq!(
observed.decision_source,
hiroute_domain::ComplexityDecisionSourceV1::ExternalClassifier
);
assert_eq!(observed.complexity_score, None);
}
#[test]
fn external_decision_can_be_inherited_without_inventing_a_rule_threshold() {
let strategy = ComplexityV1::compile_with_classifier(
Vec::<(String, String)>::new(),
CompiledClassifierKindV1::Rest,
Some(
hiroute_domain::CanonicalDigest::of_bytes(b"rest-classifier")
.as_str()
.to_owned(),
),
)
.unwrap();
let previous = BranchDecisionV1 {
extension_reason: None,
decision_protocol: Some(hiroute_domain::DecisionProtocolV1::LocalRules),
routing_observation: None,
policy: None,
competence_trigger: None,
execution_group: hiroute_domain::ExecutionGroupV1::Primary,
simple_probability: None,
simple_threshold_millis: None,
selection_reason: hiroute_domain::ModelGroupReasonV1::Heuristic,
strategy_id: strategy.strategy_id.clone(),
schema_version: strategy.schema_version.clone(),
payload_digest: strategy.payload_digest.clone(),
branch_id: hiroute_domain::SMART_SAVING_SCOPE_ID.into(),
complexity_score: None,
threshold: None,
decision_source: ComplexityDecisionSourceV1::ExternalClassifier,
reason_codes: Vec::new(),
matched_user_phrase_ids: Vec::new(),
fallback_used: false,
classification_duration_micros: Some(125),
fallback_reason: None,
};
let (inherited, _) = ComplexityV1::decide(
Some("continue"),
Some(&CorrelatedBranchDecisionV1 {
kind: ContinuationKindV1::TaskRoot,
decision: previous,
}),
&strategy,
)
.unwrap();
assert_eq!(
inherited.decision_source,
ComplexityDecisionSourceV1::Inherited
);
assert_eq!(
inherited.execution_group,
hiroute_domain::ExecutionGroupV1::Primary
);
assert_eq!(inherited.complexity_score, None);
assert_eq!(inherited.threshold, None);
}
#[test]
fn planner_free_first_never_classifies_and_custom_preserves_exact_order() {
let free = candidate(
"free",
IngressProtocol::Responses,
Some(20),
Some(0),
CostClassV1::Free,
);
let paid = candidate(
"paid",
IngressProtocol::Responses,
Some(50),
Some(1),
CostClassV1::Paid,
);
let free_policy = policy(
MaterializedRouteV1::FreeFirst {
free_group_id: "free".into(),
exhaustion: FreeFirstExhaustionV1::FreeOnly,
candidate_mode: FreeCandidateModeV1::AutomaticAllAvailable,
},
vec![MaterializedModelGroupV1 {
group_id: "free".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["free".into()],
}],
None,
StaticCostPolicyV1::StrictFree,
);
let free_output = Planner
.plan(&input(
request(
IngressProtocol::Responses,
"security audit entire repository",
),
free_policy,
vec![free.clone()],
))
.unwrap();
assert_eq!(free_output.branch, PlannedBranchV1::FreeFirstFreeOnly);
assert!(free_output.complexity.is_none());
assert_eq!(
free_output.ledger.ordered_candidates[0].candidate_id,
"free"
);
let primary_fallback = policy(
MaterializedRouteV1::FreeFirst {
free_group_id: "free".into(),
exhaustion: FreeFirstExhaustionV1::PrimaryFallback {
primary_group_id: "primary".into(),
},
candidate_mode: FreeCandidateModeV1::Manual,
},
vec![
MaterializedModelGroupV1 {
group_id: "free".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["free".into()],
},
MaterializedModelGroupV1 {
group_id: "primary".into(),
policy: GroupPolicyV1::QualityFirst,
candidate_ids: vec!["paid".into()],
},
],
None,
StaticCostPolicyV1::BudgetedPaid,
);
let primary_fallback_output = Planner
.plan(&input(
request(
IngressProtocol::Responses,
"security audit entire repository",
),
primary_fallback,
vec![free.clone(), paid.clone()],
))
.unwrap();
assert_eq!(
primary_fallback_output.branch,
PlannedBranchV1::FreeFirstPrimaryFallback
);
assert!(primary_fallback_output.complexity.is_none());
assert_eq!(
primary_fallback_output
.ledger
.ordered_candidates
.iter()
.map(|candidate| candidate.candidate_id.as_str())
.collect::<Vec<_>>(),
["free", "paid"]
);
let invalid_free = policy(
MaterializedRouteV1::FreeFirst {
free_group_id: "free".into(),
exhaustion: FreeFirstExhaustionV1::FreeOnly,
candidate_mode: FreeCandidateModeV1::Manual,
},
vec![MaterializedModelGroupV1 {
group_id: "free".into(),
policy: GroupPolicyV1::Manual,
candidate_ids: vec!["paid".into()],
}],
None,
StaticCostPolicyV1::StrictFree,
);
assert!(matches!(
Planner.plan(&input(
request(IngressProtocol::Responses, "hello"),
invalid_free,
vec![paid.clone()],
)),
Err(PlannerError::InvalidPolicy(_))
));
let mut over_budget = paid.clone();
over_budget.paid_budget_quote = PaidBudgetQuoteFactV1::Available {
upper_bound_micros: 1_000_001,
};
let budget_output = Planner
.plan(&input(
request(IngressProtocol::Responses, "hello"),
custom_policy(&["paid"], StaticCostPolicyV1::BudgetedPaid),
vec![over_budget],
))
.unwrap();
assert_eq!(
evaluation(&budget_output, "paid").first_exclusion,
Some(ExclusionReasonCodeV1::PaidBudgetQuoteUnavailable)
);
let mut routing_price_unknown = paid.clone();
routing_price_unknown.api_equivalent_cost_micros = None;
let unknown_price_output = Planner
.plan(&input(
request(IngressProtocol::Responses, "hello"),
custom_policy(&["paid"], StaticCostPolicyV1::BudgetedPaid),
vec![routing_price_unknown],
))
.unwrap();
assert!(evaluation(&unknown_price_output, "paid").eligible);
assert_eq!(
evaluation(&unknown_price_output, "paid").effective_cost_micros,
None
);
let mut cheap = free;
cheap.candidate_id = "cheap".into();
cheap.stable_binding_id = "binding-cheap".into();
let custom = Planner
.plan(&input(
request(IngressProtocol::Responses, "hello"),
custom_policy(&["paid", "cheap"], StaticCostPolicyV1::BudgetedPaid),
vec![paid, cheap],
))
.unwrap();
assert!(custom.complexity.is_none());
assert_eq!(
custom
.ledger
.ordered_candidates
.iter()
.map(|entry| entry.candidate_id.as_str())
.collect::<Vec<_>>(),
["paid", "cheap"]
);
}
#[test]
fn planner_freezes_candidates_beyond_the_runtime_binding_cap() {
let ids = ["one", "two", "three", "four", "five"];
let candidates = ids
.iter()
.map(|id| {
candidate(
id,
IngressProtocol::Responses,
Some(10),
Some(0),
CostClassV1::Free,
)
})
.collect();
let mut policy = custom_policy(&ids, StaticCostPolicyV1::SubscriptionAndFree);
policy.limits.max_candidate_bindings = 4;
let policy = policy.seal().unwrap();
let output = Planner
.plan(&input(
request(IngressProtocol::Responses, "hello"),
policy,
candidates,
))
.unwrap();
assert_eq!(output.outcome, PlannerOutcomeV1::Ready);
assert_eq!(output.limits.max_candidate_bindings, 4);
assert_eq!(
output
.ledger
.ordered_candidates
.iter()
.map(|candidate| candidate.candidate_id.as_str())
.collect::<Vec<_>>(),
ids
);
assert_eq!(output.ledger.evaluations.len(), ids.len());
}
#[test]
fn planner_context_estimate_is_advisory_but_reasoning_remains_exact() {
let mut at_n = candidate(
"at-n",
IngressProtocol::Responses,
Some(40),
Some(1),
CostClassV1::Paid,
);
at_n.protocol_profile.capability.context.max_input_tokens = CriticalFact::Exact(100);
at_n.protocol_profile.capability.context.max_total_tokens = CriticalFact::Exact(Some(356));
at_n.target_serialized_bytes = 100;
refresh_profile(&mut at_n);
let mut at_n_plus_one = at_n.clone();
at_n_plus_one.candidate_id = "at-n-plus-one".into();
at_n_plus_one.stable_binding_id = "binding-at-n-plus-one".into();
at_n_plus_one.target_serialized_bytes = 101;
let mut wrong_reasoning = at_n.clone();
wrong_reasoning.candidate_id = "wrong-reasoning".into();
wrong_reasoning.stable_binding_id = "binding-wrong-reasoning".into();
wrong_reasoning
.protocol_profile
.capability
.selected_reasoning_profile_id = "fixed-next".into();
refresh_profile(&mut wrong_reasoning);
let output = Planner
.plan(&input(
request(IngressProtocol::Responses, "hello"),
custom_policy(
&["at-n", "at-n-plus-one", "wrong-reasoning"],
StaticCostPolicyV1::BudgetedPaid,
),
vec![at_n, at_n_plus_one, wrong_reasoning],
))
.unwrap();
assert!(evaluation(&output, "at-n").eligible);
let estimated_over_limit = evaluation(&output, "at-n-plus-one");
assert!(estimated_over_limit.eligible);
assert!(
estimated_over_limit
.context
.as_ref()
.unwrap()
.required_total
> 356
);
assert_eq!(
evaluation(&output, "wrong-reasoning").first_exclusion,
Some(ExclusionReasonCodeV1::ReasoningProfileMismatch)
);
}
#[test]
fn planner_profile_policy_digests_and_output_bytes_are_frozen() {
let candidate = candidate(
"stable",
IngressProtocol::Responses,
Some(40),
Some(1),
CostClassV1::Paid,
);
let input = input(
request(IngressProtocol::Responses, "hello"),
custom_policy(&["stable"], StaticCostPolicyV1::BudgetedPaid),
vec![candidate],
);
let expected = Planner.plan(&input).unwrap();
let expected_bytes = expected.canonical_bytes().unwrap();
assert_eq!(expected.recompute_digest().unwrap(), expected.output_digest);
for _ in 0..32 {
let actual = Planner.plan(&input).unwrap();
assert_eq!(actual.canonical_bytes().unwrap(), expected_bytes);
assert_eq!(actual.output_digest, expected.output_digest);
}
let mut policy_tampered = input.clone();
policy_tampered.policy.limits.max_attempts += 1;
assert!(matches!(
Planner.plan(&policy_tampered),
Err(PlannerError::PolicyDigestMismatch)
));
let mut profile_tampered = input;
profile_tampered.candidates[0]
.protocol_profile
.capability
.native_model = "tampered".into();
assert!(matches!(
Planner.plan(&profile_tampered),
Err(PlannerError::ProfileDigestMismatch(candidate)) if candidate == "stable"
));
}
#[test]
fn planner_opaque_state_affinity_and_cost_are_after_streaming() {
let mut state_request = request(IngressProtocol::Responses, "continue");
state_request.stream = true;
let mut facts = candidate(
"stateful",
IngressProtocol::Responses,
Some(40),
Some(1),
CostClassV1::Unknown,
);
state_request.provider_state = vec![OpaqueProviderState {
block_index: None,
kind: "previous_response_id".into(),
value: json!("response-1"),
}];
facts.protocol_profile.capability.native_streaming = CriticalFact::Unknown;
refresh_profile(&mut facts);
let output = Planner
.plan(&input(
state_request.clone(),
custom_policy(&["stateful"], StaticCostPolicyV1::BudgetedPaid),
vec![facts.clone()],
))
.unwrap();
assert_eq!(
evaluation(&output, "stateful").first_exclusion,
Some(ExclusionReasonCodeV1::CostPolicyExcluded)
);
facts.protocol_profile.capability.native_streaming = CriticalFact::Exact(true);
refresh_profile(&mut facts);
let output = Planner
.plan(&input(
state_request,
custom_policy(&["stateful"], StaticCostPolicyV1::BudgetedPaid),
vec![facts.clone()],
))
.unwrap();
assert_eq!(
evaluation(&output, "stateful").first_exclusion,
Some(ExclusionReasonCodeV1::CostPolicyExcluded)
);
let output = Planner
.plan(&input(
request(IngressProtocol::Responses, "hello"),
custom_policy(&["stateful"], StaticCostPolicyV1::BudgetedPaid),
vec![facts],
))
.unwrap();
assert_eq!(
evaluation(&output, "stateful").first_exclusion,
Some(ExclusionReasonCodeV1::CostPolicyExcluded)
);
}
#[path = "namespace_tests.rs"]
mod namespace_tests;
#[test]
fn published_plan_candidates_keep_truthful_cost_classes_without_inventing_a_budget_quote() {
for class in [
CostClassV1::Paid,
CostClassV1::Subscription,
CostClassV1::Unknown,
] {
let mut fact = candidate(
"selected",
IngressProtocol::Responses,
None,
Some(10),
class,
);
fact.api_equivalent_cost_micros = None;
if class == CostClassV1::Paid {
fact.paid_budget_quote = PaidBudgetQuoteFactV1::Unavailable;
}
let policy = custom_policy(&["selected"], StaticCostPolicyV1::PublishedCandidates);
let output = Planner
.plan(&input(
request(IngressProtocol::Responses, "requested task"),
policy,
vec![fact],
))
.unwrap();
assert_eq!(output.ledger.ordered_candidates.len(), 1);
assert_eq!(evaluation(&output, "selected").cost_class, class);
assert_eq!(evaluation(&output, "selected").effective_cost_micros, None);
}
}