refactor: remove cookie health probe and bitrate downgrade retry chain

Eliminates the ~240ms+ per-song retry overhead introduced by the
MUSIC_U cookie health detection mechanism and the bitrate-downgrade
retry logic. When a FLAC request returned 320kbps instead of 999kbps,
the old code retried up to 3 times (~80ms each) before accepting the
fallback URL. With MUSIC_U cookies this path was hit on every request.

Removed:
- MusicUCookieHealth enum, probe methods, and health cache (music_api.rs)
- should_retry_primary_after_quality_downgrade / retry_primary_bitrate_url
  / retry_attempts_for_primary_unavailable functions
- cookie health probe call-site and downgrade warning flow (bot.rs)
- MP3_MAX_BITRATE_BPS, BITRATE_PROBE_TOLERANCE_BPS, COOKIE_HEALTH_PROBE_MAX_BITRATE constants
- should_probe_cookie_health / build_cookie_expired_warning_text helpers
- All related tests (8 removed, 2 rewritten to document new behaviour)

The fallback URL is now accepted immediately without any retry.
Verified: cargo fmt/check/clippy -D warnings all clean, 154/154 tests pass.

Author: Lemonawa

src/bot.rs

@@ -24,7 +24,7 @@ use crate::audio_buffer::{AudioBuffer, ThumbnailBuffer};
 use crate::config::{Config, CoverMode, UploadLogLevel};
 use crate::database::{Database, SongInfo};
 use crate::error::{BotError, Result};
-use crate::music_api::{MusicApi, MusicUCookieHealth, format_artists};
+use crate::music_api::{MusicApi, format_artists};
 use crate::utils::{
     clean_filename, ensure_dir, extract_first_url, parse_music_id, throughput_mbps, update_peak,
 };
@@ -993,7 +993,6 @@ async fn process_music(
     // Send status message and fetch song detail+URL in parallel
     let status_init_start = std::time::Instant::now();
     let bitrate_candidates = url_bitrate_candidates(state.music_api.music_u.is_some());
-    let primary_bitrate = bitrate_candidates.first().copied().unwrap_or(0);
 
     let status_fut = bot
         .send_message(msg.chat.id, "🔄 正在获取歌曲信息...")
@@ -1031,34 +1030,6 @@ async fn process_music(
         return Ok(());
     }
 
-    let has_music_u = state.music_api.music_u.is_some();
-    let should_probe_cookie = should_probe_cookie_health(has_music_u, primary_bitrate, song_url.br);
-    let cookie_quality_downgraded = if should_probe_cookie {
-        match state.music_api.probe_music_u_health().await {
-            MusicUCookieHealth::Unhealthy => true,
-            MusicUCookieHealth::Healthy => {
-                tracing::debug!(
-                    "MUSIC_U health probe is healthy for music_id {} (requested {}, got {}), skip cookie warning",
-                    music_id,
-                    primary_bitrate,
-                    song_url.br
-                );
-                false
-            }
-            MusicUCookieHealth::Unknown => {
-                tracing::warn!(
-                    "MUSIC_U health probe is inconclusive for music_id {} (requested {}, got {}), skip cookie warning",
-                    music_id,
-                    primary_bitrate,
-                    song_url.br
-                );
-                false
-            }
-        }
-    } else {
-        false
-    };
-
     let pre_upload_path_start = std::time::Instant::now();
 
     // Update status (fire-and-forget to overlap with download start)
@@ -1083,8 +1054,6 @@ async fn process_music(
         state,
         song_detail,
         &song_url,
-        primary_bitrate,
-        cookie_quality_downgraded,
         &status_msg,
         pre_upload_path_start,
         &artists,
@@ -1107,8 +1076,6 @@ async fn download_and_send_music(
     state: &Arc<BotState>,
     song_detail: Arc<crate::music_api::SongDetail>,
     song_url: &crate::music_api::SongUrl,
-    requested_primary_bitrate: u64,
-    cookie_quality_downgraded: bool,
     status_msg: &Message,
     pre_upload_path_start: std::time::Instant,
     artists: &str,
@@ -1292,23 +1259,15 @@ async fn download_and_send_music(
     );
     let (mut audio_buffer, downloaded) = downloaded_result?;
     let _upload_permit = upload_permit_result?;
-    let should_remove_song_cache = should_remove_song_cache_after_partial_failure(
-        cover_retry_exhausted,
-        cookie_quality_downgraded,
-    );
+    let should_remove_song_cache =
+        should_remove_song_cache_after_partial_failure(cover_retry_exhausted);
 
     if cover_retry_exhausted {
         tracing::warn!(
             "Cover fetch failed after retries for music_id {}. Audio will be sent without cover and cache will be removed",
             song_id
         );
     }
-    if cookie_quality_downgraded {
-        tracing::warn!(
-            "Detected downgraded bitrate for music_id {} (MUSIC_U health probe unhealthy). Audio will still be sent and cache will be removed",
-            song_id
-        );
-    }
 
     tracing::debug!(
         "Audio download completed: {} bytes (mode: {})",
@@ -1575,22 +1534,6 @@ async fn download_and_send_music(
     // Delete status message
     bot.delete_message(msg.chat.id, status_msg.id).await.ok();
 
-    if cookie_quality_downgraded {
-        let warning_text =
-            build_cookie_expired_warning_text(requested_primary_bitrate, song_info.bit_rate);
-        if let Err(e) = bot
-            .send_message(msg.chat.id, warning_text)
-            .reply_parameters(ReplyParameters::new(msg.id))
-            .await
-        {
-            tracing::warn!(
-                "Failed to send cookie-expired warning for music_id {}: {}",
-                song_id,
-                e
-            );
-        }
-    }
-
     Ok(())
 }
 
@@ -1743,43 +1686,8 @@ fn url_bitrate_candidates(has_music_u: bool) -> &'static [u64] {
     }
 }
 
-// Provider may report slightly above nominal 320 kbps; keep a small tolerance for probe trigger.
-const MP3_MAX_BITRATE_BPS: u64 = 320_000;
-const BITRATE_PROBE_TOLERANCE_BPS: u64 = 5_000;
-const COOKIE_HEALTH_PROBE_MAX_BITRATE: u64 = MP3_MAX_BITRATE_BPS + BITRATE_PROBE_TOLERANCE_BPS;
-
-fn should_probe_cookie_health(
-    has_music_u: bool,
-    requested_primary_bitrate: u64,
-    returned_bitrate: u64,
-) -> bool {
-    has_music_u
-        && requested_primary_bitrate > COOKIE_HEALTH_PROBE_MAX_BITRATE
-        && returned_bitrate > 0
-        && returned_bitrate <= COOKIE_HEALTH_PROBE_MAX_BITRATE
-}
-
-fn should_remove_song_cache_after_partial_failure(
-    cover_retry_exhausted: bool,
-    cookie_quality_downgraded: bool,
-) -> bool {
-    cover_retry_exhausted || cookie_quality_downgraded
-}
-
-fn build_cookie_expired_warning_text(
-    requested_primary_bitrate: u64,
-    actual_bitrate_bps: i64,
-) -> String {
-    if requested_primary_bitrate > 0 && actual_bitrate_bps > 0 {
-        format!(
-            "⚠️ 检测到 MUSIC_U Cookie 可能已失效，音质已从 {} kbps 降至 {} kbps。\n已发送可用音频，请尽快更新 Cookie。",
-            format_bitrate_kbps(requested_primary_bitrate as i64),
-            format_bitrate_kbps(actual_bitrate_bps)
-        )
-    } else {
-        "⚠️ 检测到 MUSIC_U Cookie 可能已失效，当前音质已降级。\n已发送可用音频，请尽快更新 Cookie。"
-            .to_string()
-    }
+fn should_remove_song_cache_after_partial_failure(cover_retry_exhausted: bool) -> bool {
+    cover_retry_exhausted
 }
 
 const MESSAGE_TASK_LINK_HINTS: [&str; 3] = ["music.163.com", "163cn.tv", "163cn.link"];
@@ -2765,68 +2673,6 @@ mod tests {
         assert_eq!(super::url_bitrate_candidates(false), &[320_000, 128_000]);
     }
 
-    #[test]
-    fn cookie_health_probe_trigger_handles_320_neighborhood() {
-        assert!(super::should_probe_cookie_health(
-            true,
-            999_000,
-            super::MP3_MAX_BITRATE_BPS
-        ));
-        assert!(super::should_probe_cookie_health(
-            true,
-            999_000,
-            super::MP3_MAX_BITRATE_BPS + 1
-        ));
-        assert!(super::should_probe_cookie_health(
-            true,
-            999_000,
-            super::COOKIE_HEALTH_PROBE_MAX_BITRATE
-        ));
-        assert!(!super::should_probe_cookie_health(
-            true,
-            999_000,
-            super::COOKIE_HEALTH_PROBE_MAX_BITRATE + 1
-        ));
-        assert!(!super::should_probe_cookie_health(
-            false,
-            999_000,
-            super::MP3_MAX_BITRATE_BPS
-        ));
-        assert!(!super::should_probe_cookie_health(
-            true,
-            super::MP3_MAX_BITRATE_BPS,
-            super::MP3_MAX_BITRATE_BPS
-        ));
-    }
-
-    #[test]
-    fn partial_failure_should_remove_song_cache() {
-        assert!(super::should_remove_song_cache_after_partial_failure(
-            true, false
-        ));
-        assert!(super::should_remove_song_cache_after_partial_failure(
-            false, true
-        ));
-        assert!(!super::should_remove_song_cache_after_partial_failure(
-            false, false
-        ));
-    }
-
-    #[test]
-    fn cookie_expired_warning_text_contains_requested_and_actual_bitrate() {
-        let text = super::build_cookie_expired_warning_text(999_000, 320_000);
-        assert!(text.contains("Cookie"));
-        assert!(text.contains("999"));
-        assert!(text.contains("320"));
-    }
-
-    #[test]
-    fn cookie_expired_warning_text_matches_caption_precision() {
-        let text = super::build_cookie_expired_warning_text(999_000, 958_321);
-        assert!(text.contains("999.00"));
-        assert!(text.contains("958.32"));
-    }
-
     #[test]
     fn spawn_gate_identifies_supported_messages() {
         assert!(super::should_spawn_message_task("/start"));