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::*;
fn id_validation_draft(id: &str) -> NativeModelConnectionDraftV1 {
NativeModelConnectionDraftV1 {
display_template_id: None,
inference_model_id: None,
candidate_ref: None,
lineage_ref: "lineage/native/id-validation".into(),
trusted_lineage_digest: None,
display_name: "中文接入名称".into(),
existing_source_id: None,
edit_revision: 1,
check_id: "check/id-validation".into(),
base_url: "http://127.0.0.1:8123/v1".into(),
base_kind: ModelConnectionBaseKindV1::ApiRoot,
request_path_override: None,
inventory_path_override: None,
protocol: UpstreamProtocol::Responses,
protocol_profile_id: "profile/custom/responses".into(),
protocol_profile_revision: 1,
protocol_header_semantics: GatewayHeaderSemanticsV1 {
content_type: "application/json".into(),
required_headers: Vec::new(),
forbidden_forward_headers: Vec::new(),
},
authentication: GatewayAuthenticationSemanticsV1::None,
additional_native_endpoints: Vec::new(),
provenance: NativeConnectionProvenanceInputV1::UserConfigured {
configuration_revision: 1,
},
qualification: NativeConnectionQualificationV1 {
free_access: None,
evidence_ref: None,
},
runtime_fallback_denied_model_ids: Default::default(),
models: vec![NativeModelDeclarationV1 {
upstream_model_id: id.into(),
display_name: "中文模型名称".into(),
catalog_configuration_id: None,
membership: ComputeModelMembershipV2::UserDeclared,
capabilities: NativeModelCapabilityDeclarationV1::default(),
}],
}
}
#[test]
fn native_draft_uses_the_same_opaque_id_contract_for_models_inference_and_denials() {
for id in [
"内网模型".to_owned(),
"Model A/@revision?实验#1".into(),
"\u{feff}模型\u{feff}".into(),
"\u{feff}".into(),
"模型🧠".into(),
"🧠".repeat(128),
"x".repeat(512),
"界".repeat(170) + "ab",
] {
let mut draft = id_validation_draft(&id);
validate_draft(&draft, &NativeModelConnectionCredentialV1::NotRequired).unwrap();
draft.inference_model_id = Some(id.clone());
validate_draft(&draft, &NativeModelConnectionCredentialV1::NotRequired).unwrap();
draft.inference_model_id = None;
draft.runtime_fallback_denied_model_ids.insert(id);
validate_draft(&draft, &NativeModelConnectionCredentialV1::NotRequired).unwrap();
}
}
#[test]
fn native_draft_rejects_invalid_provider_ids_before_any_probe() {
for id in [
" bad".to_owned(),
"bad\u{a0}".into(),
"bad\tmodel".into(),
"bad\0model".into(),
"bad\u{85}model".into(),
"\u{85}bad".into(),
"bad\u{85}".into(),
"界".repeat(171),
"🧠".repeat(129),
] {
let invalid = id_validation_draft(&id);
assert!(matches!(
validate_draft(&invalid, &NativeModelConnectionCredentialV1::NotRequired),
Err(NativeModelConnectionErrorV1::InvalidDraft)
));
let mut denied = id_validation_draft("内网模型");
denied.runtime_fallback_denied_model_ids.insert(id);
assert!(validate_draft(&denied, &NativeModelConnectionCredentialV1::NotRequired).is_err());
}
}
fn known<T>(value: T) -> NativeCandidateFactValueV1<T> {
NativeCandidateFactValueV1 {
value: Some(value),
basis: NativeCandidateFactBasisV1::UserDeclared,
}
}
fn complete_capabilities(
reasoning: NativeReasoningCapabilityV1,
) -> NativeModelCapabilityDeclarationV1 {
NativeModelCapabilityDeclarationV1 {
tool: known(true),
vision: known(false),
streaming: known(true),
context_tokens: known(32_768),
max_output_tokens: known(4_096),
native_reasoning: known(reasoning),
}
}
fn fixed_reasoning() -> NativeReasoningCapabilityV1 {
NativeReasoningCapabilityV1::Fixed {
profile: "provider-default".into(),
}
}
fn model(id: &str, capabilities: NativeModelCapabilityDeclarationV1) -> NativeModelDeclarationV1 {
NativeModelDeclarationV1 {
upstream_model_id: id.into(),
display_name: id.into(),
catalog_configuration_id: None,
membership: ComputeModelMembershipV2::UserDeclared,
capabilities,
}
}
fn assert_unknown_preserved(capabilities: NativeModelCapabilityDeclarationV1) {
assert!(model_is_selectable(&capabilities));
let candidate = candidate_models(
"candidate/native/incomplete",
&[model("incomplete-model", capabilities)],
&[],
true,
false,
&Default::default(),
)
.unwrap()
.pop()
.unwrap();
assert!(candidate.selectable);
assert_eq!(candidate.reason, None);
}
#[test]
fn unknown_capabilities_allow_text_selection_without_inventing_facts() {
let complete = complete_capabilities(fixed_reasoning());
assert!(model_is_selectable(&complete));
let mut missing_tool = complete.clone();
missing_tool.tool = NativeCandidateFactValueV1::unknown();
assert_unknown_preserved(missing_tool);
let mut missing_vision = complete.clone();
missing_vision.vision = NativeCandidateFactValueV1::unknown();
assert_unknown_preserved(missing_vision);
let mut missing_streaming = complete.clone();
missing_streaming.streaming = NativeCandidateFactValueV1::unknown();
assert_unknown_preserved(missing_streaming);
let mut missing_reasoning = complete;
missing_reasoning.native_reasoning = NativeCandidateFactValueV1::unknown();
assert_unknown_preserved(missing_reasoning);
}
#[test]
fn explicit_false_capability_facts_are_complete() {
let mut declaration = complete_capabilities(fixed_reasoning());
declaration.tool = known(false);
declaration.vision = known(false);
declaration.streaming = known(false);
assert!(model_is_selectable(&declaration));
}
#[test]
fn native_reasoning_shapes_are_preserved_without_effort_mapping() {
let native = vec![
NativeReasoningCapabilityV1::Fixed {
profile: "provider-default".into(),
},
NativeReasoningCapabilityV1::Discrete {
parameter: "output_config.effort".into(),
profiles: vec!["low".into(), "max".into()],
default_profile: None,
},
NativeReasoningCapabilityV1::Budget {
parameter: "thinking.budget_tokens".into(),
minimum_tokens: 1_024,
maximum_tokens: 4_096,
step_tokens: 1_024,
},
];
for reasoning in native {
let declaration = complete_capabilities(reasoning.clone());
assert!(model_is_selectable(&declaration));
let converted = convert_capabilities(&declaration);
assert_eq!(converted.native_reasoning.value, Some(reasoning));
assert_eq!(
converted.native_reasoning.basis,
ComputeCandidateFactBasisV2::UserDeclared
);
}
}
#[test]
fn invalid_bounds_are_rejected_but_missing_limits_remain_unknown() {
let complete = complete_capabilities(fixed_reasoning());
let mut missing = complete.clone();
missing.context_tokens = NativeCandidateFactValueV1::unknown();
assert!(model_is_selectable(&missing));
let mut inverted = complete;
inverted.context_tokens = known(4_096);
inverted.max_output_tokens = known(8_192);
assert!(!model_is_selectable(&inverted));
let mut invalid_reasoning = complete_capabilities(fixed_reasoning());
invalid_reasoning.native_reasoning = known(NativeReasoningCapabilityV1::Discrete {
parameter: "reasoning_effort".into(),
profiles: Vec::new(),
default_profile: None,
});
assert!(!model_is_selectable(&invalid_reasoning));
}
#[test]
fn incomplete_model_does_not_block_complete_model_selection() {
let mut incomplete = complete_capabilities(fixed_reasoning());
incomplete.vision = NativeCandidateFactValueV1::unknown();
let models = candidate_models(
"candidate/native/mixed",
&[
model("incomplete-model", incomplete),
model("ready-model", complete_capabilities(fixed_reasoning())),
],
&[],
true,
false,
&Default::default(),
)
.unwrap();
let incomplete = models
.iter()
.find(|model| model.upstream_model_id == "incomplete-model")
.unwrap();
assert!(incomplete.selectable);
assert_eq!(incomplete.capabilities.vision.value, None);
assert_eq!(incomplete.reason, None);
let ready = models
.iter()
.find(|model| model.upstream_model_id == "ready-model")
.unwrap();
assert!(ready.selectable);
assert_eq!(ready.reason, None);
}
#[test]
fn unknown_observed_text_model_gets_only_the_marked_conservative_facts() {
let candidate = candidate_models(
"candidate/native/runtime-fallback",
&[],
&["provider-new-text-model".into()],
true,
true,
&Default::default(),
)
.unwrap()
.pop()
.unwrap();
assert!(candidate.selectable);
assert_eq!(candidate.catalog_configuration_id, None);
assert_eq!(candidate.membership, ComputeModelMembershipV2::Observed);
assert_eq!(candidate.capabilities.tool.value, None);
assert_eq!(candidate.capabilities.vision.value, None);
assert_eq!(candidate.capabilities.streaming.value, None);
assert_eq!(candidate.capabilities.context_tokens.value, None);
assert_eq!(candidate.capabilities.max_output_tokens.value, None);
assert_eq!(candidate.capabilities.native_reasoning.value, None);
assert_eq!(
candidate.capabilities.tool.basis,
ComputeCandidateFactBasisV2::Unknown
);
}
#[test]
fn catalog_denied_unknown_model_stays_unselectable() {
let denied = std::collections::BTreeSet::from(["gpt-image-2".to_owned()]);
let candidate = candidate_models(
"candidate/native/non-text",
&[],
&["gpt-image-2".into()],
true,
false,
&denied,
)
.unwrap()
.pop()
.unwrap();
assert!(!candidate.selectable);
assert_eq!(
candidate.reason.as_deref(),
Some("model_connections.runtime_fallback_ineligible")
);
assert_eq!(
candidate.capabilities.tool.basis,
ComputeCandidateFactBasisV2::Unknown
);
}