Remove ranked minimal selection compatibility helper

2026-09-01 17:00:21 +08:00 · 2026-04-27 15:52:26 +08:00
parent e5e09b49f4
commit e9f03d8d29
11 changed files with 103 additions and 161 deletions
--- a/apps/aether-gateway/src/data/candidate_selection.rs
+++ b/apps/aether-gateway/src/data/candidate_selection.rs
@@ -4,8 +4,8 @@ use aether_scheduler_core::{
    auth_constraints_allow_api_format, collect_global_model_names_for_required_capability,
    enumerate_minimal_candidate_selection, normalize_api_format,
    resolve_requested_global_model_name, row_supports_requested_model,
-    BuildMinimalCandidateSelectionInput, SchedulerAuthConstraints,
-    SchedulerMinimalCandidateSelectionCandidate, SchedulerPriorityMode,
+    EnumerateMinimalCandidateSelectionInput, SchedulerAuthConstraints,
+    SchedulerMinimalCandidateSelectionCandidate,
 };
 use async_trait::async_trait;
 use std::collections::BTreeSet;
@@ -77,7 +77,7 @@ pub(crate) async fn enumerate_minimal_candidate_selection_with_required_capabili
        return Ok(Vec::new());
    };
    let auth_constraints = auth_snapshot.map(auth_snapshot_constraints);
-    enumerate_minimal_candidate_selection(BuildMinimalCandidateSelectionInput {
+    enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
        rows,
        normalized_api_format: &normalized_api_format,
        requested_model_name,
@@ -85,8 +85,6 @@ pub(crate) async fn enumerate_minimal_candidate_selection_with_required_capabili
        require_streaming,
        required_capabilities,
        auth_constraints: auth_constraints.as_ref(),
-        affinity_key: None,
-        priority_mode: SchedulerPriorityMode::Provider,
    })
 }

@@ -172,12 +170,6 @@ pub(crate) async fn read_global_model_names_for_api_format(
    Ok(model_names.into_iter().collect())
 }

-fn auth_snapshot_affinity_key(auth_snapshot: Option<&GatewayAuthApiKeySnapshot>) -> Option<&str> {
-    auth_snapshot
-        .map(|snapshot| snapshot.api_key_id.trim())
-        .filter(|value| !value.is_empty())
-}
-
 fn auth_snapshot_constraints(snapshot: &GatewayAuthApiKeySnapshot) -> SchedulerAuthConstraints {
    SchedulerAuthConstraints {
        allowed_providers: snapshot
--- a/apps/aether-gateway/src/data/tests.rs
+++ b/apps/aether-gateway/src/data/tests.rs
@@ -24,8 +24,8 @@ use aether_data_contracts::repository::video_tasks::{
    UpsertVideoTask, VideoTaskLookupKey, VideoTaskStatus, VideoTaskWriteRepository,
 };
 use aether_scheduler_core::{
-    build_ranked_minimal_candidate_selection, BuildMinimalCandidateSelectionInput,
-    SchedulerAuthConstraints, SchedulerPriorityMode,
+    enumerate_minimal_candidate_selection, EnumerateMinimalCandidateSelectionInput,
+    SchedulerAuthConstraints,
 };
 use serde_json::json;

@@ -622,18 +622,17 @@ async fn data_state_reads_minimal_candidate_selection_with_auth_filters() {
            .map(|items| items.to_vec()),
    };

-    let selection = build_ranked_minimal_candidate_selection(BuildMinimalCandidateSelectionInput {
-        rows,
-        normalized_api_format: "openai:chat",
-        requested_model_name: "gpt-4.1",
-        resolved_global_model_name: "gpt-4.1",
-        require_streaming: false,
-        required_capabilities: None,
-        auth_constraints: Some(&auth_constraints),
-        affinity_key: Some(auth_snapshot.api_key_id.as_str()),
-        priority_mode: SchedulerPriorityMode::Provider,
-    })
-    .expect("selection should read");
+    let selection =
+        enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
+            rows,
+            normalized_api_format: "openai:chat",
+            requested_model_name: "gpt-4.1",
+            resolved_global_model_name: "gpt-4.1",
+            require_streaming: false,
+            required_capabilities: None,
+            auth_constraints: Some(&auth_constraints),
+        })
+        .expect("selection should read");

    assert_eq!(selection.len(), 2);
    assert_eq!(selection[0].provider_id, "provider-1");
--- a/apps/aether-gateway/src/scheduler/candidate/tests/affinity.rs
+++ b/apps/aether-gateway/src/scheduler/candidate/tests/affinity.rs
@@ -10,8 +10,10 @@ use aether_data_contracts::repository::candidates::{
    RequestCandidateStatus, StoredRequestCandidate,
 };
 use aether_scheduler_core::{
-    build_ranked_minimal_candidate_selection, BuildMinimalCandidateSelectionInput,
-    SchedulerMinimalCandidateSelectionCandidate, SchedulerPriorityMode,
+    apply_scheduler_candidate_ranking, enumerate_minimal_candidate_selection,
+    EnumerateMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
+    SchedulerPriorityMode, SchedulerRankableCandidate, SchedulerRankingContext,
+    SchedulerRankingMode,
 };

 use crate::cache::SchedulerAffinityTarget;
@@ -94,18 +96,36 @@ async fn same_priority_candidates_are_distributed_by_affinity_key() {
            .await
            .expect("selection rows should read")
            .expect("selection rows should match requested model");
-    let selection = build_ranked_minimal_candidate_selection(BuildMinimalCandidateSelectionInput {
-        rows,
-        normalized_api_format: "openai:chat",
-        requested_model_name: "gpt-4.1",
-        resolved_global_model_name: "gpt-4.1",
-        require_streaming: false,
-        required_capabilities: None,
-        auth_constraints: None,
-        affinity_key: Some(auth_snapshot.api_key_id.as_str()),
-        priority_mode: SchedulerPriorityMode::Provider,
-    })
-    .expect("selection should succeed");
+    let mut selection =
+        enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
+            rows,
+            normalized_api_format: "openai:chat",
+            requested_model_name: "gpt-4.1",
+            resolved_global_model_name: "gpt-4.1",
+            require_streaming: false,
+            required_capabilities: None,
+            auth_constraints: None,
+        })
+        .expect("selection should succeed");
+    let rankables = selection
+        .iter()
+        .enumerate()
+        .map(|(index, candidate)| {
+            SchedulerRankableCandidate::from_candidate(candidate, index).with_affinity_hash(Some(
+                candidate_affinity_hash(auth_snapshot.api_key_id.as_str(), candidate),
+            ))
+        })
+        .collect::<Vec<_>>();
+    apply_scheduler_candidate_ranking(
+        &mut selection,
+        &rankables,
+        SchedulerRankingContext {
+            priority_mode: SchedulerPriorityMode::Provider,
+            ranking_mode: SchedulerRankingMode::CacheAffinity,
+            include_health: false,
+            load_balance_seed: 0,
+        },
+    );

    assert_eq!(selection.len(), 2);

--- a/apps/aether-gateway/src/tests/architecture/runtime_and_security.rs
+++ b/apps/aether-gateway/src/tests/architecture/runtime_and_security.rs
@@ -481,30 +481,9 @@ fn scheduler_candidate_runtime_paths_depend_on_scheduler_core_and_state_trait()
    }

    assert!(
-        workspace_file_exists("crates/aether-scheduler-core/src/candidate/selection.rs"),
-        "core candidate/selection.rs should host legacy minimal selection compatibility helper"
+        !workspace_file_exists("crates/aether-scheduler-core/src/candidate/selection.rs"),
+        "core candidate/selection.rs compatibility helper should be removed"
    );
-    let core_candidate_selection =
-        read_workspace_file("crates/aether-scheduler-core/src/candidate/selection.rs");
-    for expected in [
-        "build_ranked_minimal_candidate_selection",
-        "apply_scheduler_candidate_ranking",
-    ] {
-        assert!(
-            core_candidate_selection.contains(expected),
-            "core candidate/selection.rs should host compatibility helper {expected}"
-        );
-    }
-    for forbidden in [
-        "collect_selectable_candidates_from_keys",
-        "reorder_candidates_by_scheduler_health",
-        "compare_candidates_by_priority_mode",
-    ] {
-        assert!(
-            !core_candidate_selection.contains(forbidden),
-            "core candidate/selection.rs should not keep removed legacy helper {forbidden}"
-        );
-    }

    let affinity_cache = read_workspace_file("apps/aether-gateway/src/cache/scheduler_affinity.rs");
    assert!(
--- a/crates/aether-scheduler-core/src/candidate/capability.rs
+++ b/crates/aether-scheduler-core/src/candidate/capability.rs
@@ -65,26 +65,7 @@ pub fn requested_capability_priority_for_candidate(
    )
 }

-pub(crate) fn enabled_required_capabilities(
-    required_capabilities: Option<&serde_json::Value>,
-) -> Vec<RequiredCapabilityDescriptor<'_>> {
-    let Some(required_capabilities) = required_capabilities.and_then(serde_json::Value::as_object)
-    else {
-        return Vec::new();
-    };
-
-    required_capabilities
-        .iter()
-        .filter_map(|(capability, value)| {
-            requested_capability_is_enabled(value).then_some(RequiredCapabilityDescriptor {
-                name: capability.as_str(),
-                compatible: requested_capability_is_compatible(capability),
-            })
-        })
-        .collect()
-}
-
-pub(crate) fn requested_capability_priority_for_candidate_descriptors<'a, I>(
+fn requested_capability_priority_for_candidate_descriptors<'a, I>(
    required_capabilities: I,
    candidate: &SchedulerMinimalCandidateSelectionCandidate,
 ) -> (u32, u32)
--- a/crates/aether-scheduler-core/src/candidate/enumeration.rs
+++ b/crates/aether-scheduler-core/src/candidate/enumeration.rs
@@ -4,13 +4,13 @@ use aether_data_contracts::repository::candidate_selection::StoredMinimalCandida
 use aether_data_contracts::DataLayerError;

 use super::types::{
-    BuildMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
+    EnumerateMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
 };

 pub fn enumerate_minimal_candidate_selection(
-    input: BuildMinimalCandidateSelectionInput<'_>,
+    input: EnumerateMinimalCandidateSelectionInput<'_>,
 ) -> Result<Vec<SchedulerMinimalCandidateSelectionCandidate>, DataLayerError> {
-    let BuildMinimalCandidateSelectionInput {
+    let EnumerateMinimalCandidateSelectionInput {
        rows,
        normalized_api_format,
        requested_model_name,
--- a/crates/aether-scheduler-core/src/candidate/mod.rs
+++ b/crates/aether-scheduler-core/src/candidate/mod.rs
@@ -1,7 +1,6 @@
 pub mod capability;
 pub mod enumeration;
 pub mod selectability;
-pub mod selection;
 pub mod types;

 pub use capability::{
@@ -14,9 +13,8 @@ pub use selectability::{
    auth_api_key_concurrency_limit_reached, candidate_is_selectable_with_runtime_state,
    candidate_runtime_skip_reason_with_state, CandidateRuntimeSelectabilityInput,
 };
-pub use selection::build_ranked_minimal_candidate_selection;
 pub use types::{
-    BuildMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
+    EnumerateMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
    SchedulerPriorityMode,
 };

@@ -33,11 +31,10 @@ mod tests {
    use aether_data_contracts::repository::provider_catalog::StoredProviderCatalogKey;

    use super::{
-        auth_api_key_concurrency_limit_reached, build_ranked_minimal_candidate_selection,
-        candidate_is_selectable_with_runtime_state, candidate_supports_required_capability,
-        collect_global_model_names_for_required_capability, BuildMinimalCandidateSelectionInput,
-        CandidateRuntimeSelectabilityInput, SchedulerMinimalCandidateSelectionCandidate,
-        SchedulerPriorityMode,
+        auth_api_key_concurrency_limit_reached, candidate_is_selectable_with_runtime_state,
+        candidate_supports_required_capability, collect_global_model_names_for_required_capability,
+        CandidateRuntimeSelectabilityInput, EnumerateMinimalCandidateSelectionInput,
+        SchedulerMinimalCandidateSelectionCandidate,
    };
    use crate::SchedulerAuthConstraints;

@@ -176,7 +173,7 @@ mod tests {
    }

    #[test]
-    fn builds_ranked_minimal_candidate_selection_with_auth_constraints() {
+    fn enumerates_minimal_candidate_selection_with_auth_constraints() {
        let mut disallowed = sample_row("2");
        disallowed.provider_id = "provider-blocked".to_string();
        disallowed.provider_name = "Blocked".to_string();
@@ -187,7 +184,7 @@ mod tests {
            allowed_models: Some(vec!["gpt-5".to_string()]),
        };
        let candidates =
-            build_ranked_minimal_candidate_selection(BuildMinimalCandidateSelectionInput {
+            super::enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
                rows: vec![sample_row("1"), disallowed],
                normalized_api_format: "openai:chat",
                requested_model_name: "gpt-5",
@@ -195,8 +192,6 @@ mod tests {
                require_streaming: false,
                required_capabilities: None,
                auth_constraints: Some(&constraints),
-                affinity_key: None,
-                priority_mode: SchedulerPriorityMode::Provider,
            })
            .expect("candidate selection should build");

@@ -213,7 +208,7 @@ mod tests {
        earlier_priority.provider_priority = 0;

        let candidates =
-            super::enumerate_minimal_candidate_selection(BuildMinimalCandidateSelectionInput {
+            super::enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
                rows: vec![later_priority, earlier_priority],
                normalized_api_format: "openai:chat",
                requested_model_name: "gpt-5",
@@ -221,8 +216,6 @@ mod tests {
                require_streaming: false,
                required_capabilities: None,
                auth_constraints: None,
-                affinity_key: None,
-                priority_mode: SchedulerPriorityMode::Provider,
            })
            .expect("candidate enumeration should build");

@@ -255,8 +248,7 @@ mod tests {
    }

    #[test]
-    fn ranked_minimal_candidate_selection_prefers_matching_requested_capabilities_before_priority()
-    {
+    fn requested_capability_priority_counts_missing_compatible_capabilities() {
        let mut missing_capability = sample_row("1");
        missing_capability.key_capabilities = Some(serde_json::json!({"cache_1h": false}));
        missing_capability.provider_priority = 0;
@@ -267,7 +259,7 @@ mod tests {

        let required_capabilities = serde_json::json!({"cache_1h": true});
        let candidates =
-            build_ranked_minimal_candidate_selection(BuildMinimalCandidateSelectionInput {
+            super::enumerate_minimal_candidate_selection(EnumerateMinimalCandidateSelectionInput {
                rows: vec![missing_capability, matching_capability],
                normalized_api_format: "openai:chat",
                requested_model_name: "gpt-5",
@@ -275,14 +267,20 @@ mod tests {
                require_streaming: false,
                required_capabilities: Some(&required_capabilities),
                auth_constraints: None,
-                affinity_key: None,
-                priority_mode: SchedulerPriorityMode::Provider,
            })
            .expect("candidate selection should build");
+        let priority = candidates
+            .iter()
+            .map(|candidate| {
+                super::requested_capability_priority_for_candidate(
+                    Some(&required_capabilities),
+                    candidate,
+                )
+            })
+            .collect::<Vec<_>>();

        assert_eq!(candidates.len(), 2);
-        assert_eq!(candidates[0].key_id, "key-2");
-        assert_eq!(candidates[1].key_id, "key-1");
+        assert_eq!(priority, vec![(0, 1), (0, 0)]);
    }

    #[test]
--- a/crates/aether-scheduler-core/src/candidate/selection.rs
+++ b/crates/aether-scheduler-core/src/candidate/selection.rs
@@ -1,45 +0,0 @@
-use aether_data_contracts::DataLayerError;
-
-use super::capability::{
-    enabled_required_capabilities, requested_capability_priority_for_candidate_descriptors,
-};
-use super::enumeration::enumerate_minimal_candidate_selection;
-use super::types::{
-    BuildMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
-};
-
-pub fn build_ranked_minimal_candidate_selection(
-    input: BuildMinimalCandidateSelectionInput<'_>,
-) -> Result<Vec<SchedulerMinimalCandidateSelectionCandidate>, DataLayerError> {
-    let priority_mode = input.priority_mode;
-    let affinity_key = input.affinity_key.map(str::to_string);
-    let required_capabilities = enabled_required_capabilities(input.required_capabilities);
-    let mut candidates = enumerate_minimal_candidate_selection(input)?;
-    let rankables = candidates
-        .iter()
-        .enumerate()
-        .map(|(index, candidate)| {
-            crate::SchedulerRankableCandidate::from_candidate(candidate, index)
-                .with_capability_priority(requested_capability_priority_for_candidate_descriptors(
-                    required_capabilities.iter().copied(),
-                    candidate,
-                ))
-                .with_affinity_hash(
-                    affinity_key
-                        .as_deref()
-                        .map(|key| crate::candidate_affinity_hash(key, candidate)),
-                )
-        })
-        .collect::<Vec<_>>();
-    crate::apply_scheduler_candidate_ranking(
-        &mut candidates,
-        &rankables,
-        crate::SchedulerRankingContext {
-            priority_mode,
-            ranking_mode: crate::SchedulerRankingMode::CacheAffinity,
-            include_health: false,
-            load_balance_seed: 0,
-        },
-    );
-    Ok(candidates)
-}
--- a/crates/aether-scheduler-core/src/candidate/types.rs
+++ b/crates/aether-scheduler-core/src/candidate/types.rs
@@ -28,7 +28,7 @@ pub struct SchedulerMinimalCandidateSelectionCandidate {
    pub mapping_matched_model: Option<String>,
 }

-pub struct BuildMinimalCandidateSelectionInput<'a> {
+pub struct EnumerateMinimalCandidateSelectionInput<'a> {
    pub rows: Vec<StoredMinimalCandidateSelectionRow>,
    pub normalized_api_format: &'a str,
    pub requested_model_name: &'a str,
@@ -36,6 +36,4 @@ pub struct BuildMinimalCandidateSelectionInput<'a> {
    pub require_streaming: bool,
    pub required_capabilities: Option<&'a serde_json::Value>,
    pub auth_constraints: Option<&'a crate::SchedulerAuthConstraints>,
-    pub affinity_key: Option<&'a str>,
-    pub priority_mode: SchedulerPriorityMode,
 }
--- a/crates/aether-scheduler-core/src/lib.rs
+++ b/crates/aether-scheduler-core/src/lib.rs
@@ -16,12 +16,12 @@ pub use auth::{
    auth_constraints_allow_provider, provider_matches_allowed_value, SchedulerAuthConstraints,
 };
 pub use candidate::{
-    auth_api_key_concurrency_limit_reached, build_ranked_minimal_candidate_selection,
-    candidate_is_selectable_with_runtime_state, candidate_runtime_skip_reason_with_state,
-    candidate_supports_required_capability, collect_global_model_names_for_required_capability,
-    enumerate_minimal_candidate_selection, requested_capability_priority_for_candidate,
-    BuildMinimalCandidateSelectionInput, CandidateRuntimeSelectabilityInput,
-    SchedulerMinimalCandidateSelectionCandidate, SchedulerPriorityMode,
+    auth_api_key_concurrency_limit_reached, candidate_is_selectable_with_runtime_state,
+    candidate_runtime_skip_reason_with_state, candidate_supports_required_capability,
+    collect_global_model_names_for_required_capability, enumerate_minimal_candidate_selection,
+    requested_capability_priority_for_candidate, CandidateRuntimeSelectabilityInput,
+    EnumerateMinimalCandidateSelectionInput, SchedulerMinimalCandidateSelectionCandidate,
+    SchedulerPriorityMode,
 };
 pub use health::{
    aggregate_provider_key_health_score, count_recent_active_requests_for_api_key,
--- a/crates/aether-scheduler-core/src/ranking/mod.rs
+++ b/crates/aether-scheduler-core/src/ranking/mod.rs
@@ -209,6 +209,26 @@ mod tests {
        );
    }

+    #[test]
+    fn capability_priority_precedes_provider_priority() {
+        let matching_capability = candidate("matching", 10, 0, None);
+        let mut missing_compatible_capability = candidate("missing", 0, 0, None);
+        missing_compatible_capability.capability_priority = (0, 1);
+
+        assert_eq!(
+            ranked_ids(
+                &[missing_compatible_capability, matching_capability],
+                SchedulerRankingContext {
+                    priority_mode: SchedulerPriorityMode::Provider,
+                    ranking_mode: SchedulerRankingMode::FixedOrder,
+                    include_health: false,
+                    load_balance_seed: 0,
+                },
+            ),
+            vec!["provider-matching", "provider-missing"]
+        );
+    }
+
    #[test]
    fn cache_affinity_can_promote_cached_candidate_and_reports_reason() {
        let high_priority = candidate("high", 0, 0, Some(0));