feat: add bucket score global router

src/cluster/bucketed_service.rs

@@ -52,7 +52,7 @@ impl BucketedService {
         let bucket_views = self
             .buckets
             .iter()
-            .map(|bucket| bucket.cluster.bucket_view(bucket.id, &bucket.cfg))
+            .map(|bucket| bucket.cluster.bucket_view(bucket.id, &bucket.cfg, req, now))
             .collect::<Vec<_>>();
         let global = self.global_router.route(req, &bucket_views, now)?;
         let bucket = &mut self.buckets[global.chosen_bucket as usize];
@@ -213,21 +213,4 @@ mod tests {
         assert!(err.to_string().contains("no bucket"));
         assert!(err.to_string().contains("input_length=36"));
     }
-
-    #[test]
-    fn bucket_score_placeholder_reports_strict_fallback() {
-        let mut cfg = test_config();
-        cfg.cluster.global_router.mode = GlobalRouterMode::BucketScore;
-        let mut service = BucketedService::new(&cfg, &cfg.model);
-
-        let stats = service
-            .route_and_admit(&req(4, 24, &[30, 31]), 0.0)
-            .unwrap();
-
-        assert_eq!(stats.decision.global_mode, "strict_input_length");
-        assert!(stats
-            .decision
-            .global_reason
-            .contains("bucket_score is not implemented"));
-    }
 }

src/cluster/cluster.rs

@@ -171,7 +171,19 @@ impl Cluster {
         }
     }
 
-    pub fn bucket_view(&self, bucket_id: BucketId, cfg: &BucketConfig) -> BucketView {
+    pub fn bucket_view(
+        &self,
+        bucket_id: BucketId,
+        cfg: &BucketConfig,
+        req: &RequestRecord,
+        now: f64,
+    ) -> BucketView {
+        let predicted_prefix = self
+            .meta_store
+            .score_prefix(&req.hash_ids, now, self.instances.len())
+            .into_iter()
+            .max()
+            .unwrap_or(0);
         BucketView {
             id: bucket_id,
             input_length_min: cfg.input_length_min,
@@ -179,6 +191,7 @@ impl Cluster {
             num_instances: self.instances.len() as u32,
             total_queue_len: self.instances.iter().map(Instance::queue_len).sum(),
             total_load_blocks: self.instances.iter().map(|inst| inst.kv_blocks_used).sum(),
+            predicted_prefix,
         }
     }