Simplify Antigravity, Kimi, MiniMax and OpenCode providers

rust/src/providers/antigravity/cli_fallback.rs

@@ -144,13 +144,15 @@ pub(super) async fn managed_spawn_is_csrf_gated(binary: Option<PathBuf>) -> bool
     let Some(binary) = binary else {
         return false;
     };
-    let Ok(version) =
-        run_cli_command(&binary, &VERSION_ARGS, VERSION_TIMEOUT, VERSION_TOO_LARGE).await
-    else {
-        return false;
-    };
-    let version = String::from_utf8_lossy(&version);
-    is_csrf_gated_version(version.trim())
+    agy_version(&binary, VERSION_TIMEOUT)
+        .await
+        .is_ok_and(|version| is_csrf_gated_version(&version))
+}
+
+/// `agy --version` output, trimmed.
+async fn agy_version(binary: &Path, timeout: Duration) -> Result<String, LiveFailure> {
+    let version = run_cli_command(binary, &VERSION_ARGS, timeout, VERSION_TOO_LARGE).await?;
+    Ok(String::from_utf8_lossy(&version).trim().to_string())
 }
 
 async fn fetch_print_usage(binary: &Path) -> Result<ProviderFetchResult, LiveFailure> {
@@ -161,10 +163,7 @@ async fn fetch_print_usage_with_version_timeout(
     binary: &Path,
     version_timeout: Duration,
 ) -> Result<ProviderFetchResult, LiveFailure> {
-    let version =
-        run_cli_command(binary, &VERSION_ARGS, version_timeout, VERSION_TOO_LARGE).await?;
-    let version = String::from_utf8_lossy(&version);
-    if !is_supported_version(version.trim()) {
+    if !is_supported_version(&agy_version(binary, version_timeout).await?) {
         return Err(ProviderError::Parse(
             "Antigravity CLI usage reports require agy 1.1.11 or later".into(),
         )

rust/src/providers/antigravity/legacy_status.rs

@@ -13,10 +13,6 @@ pub(crate) struct UserStatusResponse {
 #[derive(Debug, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub(crate) struct UserStatus {
-    #[allow(
-        dead_code,
-        reason = "field mirrors the Antigravity API user payload; deserialized for round-trip fidelity but not read yet"
-    )]
     email: Option<String>,
     plan_status: Option<PlanStatus>,
     user_tier: Option<UserTier>,
@@ -224,9 +220,14 @@ fn model_window_id(config: &ModelConfig) -> String {
         .as_deref()
         .or(config.id.as_deref())
         .unwrap_or_else(|| model_label(config));
-    let raw = canonical_model_id(raw);
-    let slug = raw
-        .chars()
+    let slug = slug(canonical_model_id(raw));
+    format!("model-{}", if slug.is_empty() { "unknown" } else { &slug })
+}
+
+/// Lowercase ASCII alphanumerics; every other character becomes `-`, and
+/// leading or trailing dashes are dropped.
+pub(super) fn slug(raw: &str) -> String {
+    raw.chars()
         .map(|ch| {
             if ch.is_ascii_alphanumeric() {
                 ch.to_ascii_lowercase()
@@ -236,8 +237,7 @@ fn model_window_id(config: &ModelConfig) -> String {
         })
         .collect::<String>()
         .trim_matches('-')
-        .to_string();
-    format!("model-{}", if slug.is_empty() { "unknown" } else { &slug })
+        .to_string()
 }
 
 fn rate_window_from_quota(quota: &QuotaInfo) -> RateWindow {

rust/src/providers/antigravity/local_bot_id.rs

@@ -116,14 +116,7 @@ pub(super) fn append_recovered_events(
                     continue;
                 }
                 if bot_id_uses.get(bot_id) == Some(&1) {
-                    let mut turn = pending.turn.clone();
-                    turn.timestamp_ms = Some(exact.timestamp_ms);
-                    events.push(Event {
-                        session: session.to_string(),
-                        row: pending.row,
-                        turn,
-                        total: pending.total,
-                    });
+                    events.push(recovered_event(session, pending, exact.timestamp_ms));
                     recovered += 1;
                     continue;
                 }
@@ -141,16 +134,20 @@ pub(super) fn append_recovered_events(
         let Some(timestamp_ms) = timestamps.get(*offset) else {
             continue;
         };
-        let mut turn = pending.turn.clone();
-        turn.timestamp_ms = Some(*timestamp_ms);
-        events.push(Event {
-            session: session.to_string(),
-            row: pending.row,
-            turn,
-            total: pending.total,
-        });
+        events.push(recovered_event(session, pending, *timestamp_ms));
         recovered += 1;
     }
     events.sort_by_key(|event| event.row);
     recovered
 }
+
+fn recovered_event(session: &str, pending: &PendingTimestampRow, timestamp_ms: i64) -> Event {
+    let mut turn = pending.turn.clone();
+    turn.timestamp_ms = Some(timestamp_ms);
+    Event {
+        session: session.to_string(),
+        row: pending.row,
+        turn,
+        total: pending.total,
+    }
+}

rust/src/providers/antigravity/local_history.rs

@@ -9,13 +9,6 @@ use chrono::{DateTime, Utc};
 
 use crate::spend_contract::{LocalHistoryCoverage, LocalTokenHistorySummary};
 
-fn clean_env_path(value: Option<&str>) -> Option<PathBuf> {
-    value
-        .map(str::trim)
-        .filter(|value| !value.is_empty())
-        .map(PathBuf::from)
-}
-
 fn configured_database_roots(home: &Path) -> [PathBuf; 3] {
     let gemini_cli_home = std::env::var("GEMINI_CLI_HOME").ok();
     configured_database_roots_from_values(home, gemini_cli_home.as_deref())
@@ -25,7 +18,8 @@ fn configured_database_roots_from_values(
     home: &Path,
     gemini_cli_home: Option<&str>,
 ) -> [PathBuf; 3] {
-    let gemini_base = clean_env_path(gemini_cli_home).unwrap_or_else(|| home.join(".gemini"));
+    let gemini_base =
+        local_sessions::clean_env_path(gemini_cli_home).unwrap_or_else(|| home.join(".gemini"));
     local_sqlite::database_roots(&gemini_base)
 }
 

rust/src/providers/antigravity/local_proto.rs

@@ -127,11 +127,6 @@ fn identity_text(field: Field<'_>) -> Option<Option<String>> {
     Some((!value.trim().is_empty()).then(|| value.to_string()))
 }
 
-fn auxiliary_text(field: Field<'_>) -> Result<Option<String>, ()> {
-    let value = std::str::from_utf8(message(field).ok_or(())?).map_err(|_| ())?;
-    Ok((!value.trim().is_empty()).then(|| value.to_string()))
-}
-
 #[derive(Debug, Default)]
 struct AuxiliaryIdentifier {
     value: Option<String>,
@@ -150,12 +145,9 @@ impl AuxiliaryIdentifier {
         if !self.valid {
             return;
         }
-        match auxiliary_text(field) {
-            Ok(value) => self.value = value,
-            Err(()) => {
-                self.value = None;
-                self.valid = false;
-            }
+        match identity_text(field) {
+            Some(value) => self.value = value,
+            None => self.invalidate(),
         }
     }
 
@@ -165,11 +157,20 @@ impl AuxiliaryIdentifier {
     }
 }
 
+/// Positive and no later than 9999-12-31T23:59:59Z.
+fn valid_seconds(seconds: u64) -> bool {
+    seconds != 0 && seconds <= 253_402_300_799
+}
+
+fn valid_nanos(nanos: u64) -> bool {
+    nanos <= 999_999_999
+}
+
 fn timestamp_millis(seconds: Option<u64>, nanos: u64) -> Option<Option<i64>> {
     let Some(seconds) = seconds else {
         return Some(None);
     };
-    if seconds == 0 || seconds > 253_402_300_799 || nanos > 999_999_999 {
+    if !valid_seconds(seconds) || !valid_nanos(nanos) {
         return None;
     }
     let seconds = i64::try_from(seconds).ok()?;
@@ -302,29 +303,17 @@ fn parse_generation(bytes: &[u8], seconds: &mut Option<u64>, nanos: &mut u64) ->
 fn parse_timestamp_field(bytes: &[u8], seconds: &mut Option<u64>, nanos: &mut u64) -> Option<()> {
     fields(bytes, |stamp| {
         match stamp.number {
-            1 => {
-                let value = integer(stamp)?;
-                if value == 0 || value > 253_402_300_799 {
-                    return None;
-                }
-                *seconds = Some(value);
-            }
-            2 => {
-                let value = integer(stamp)?;
-                if value > 999_999_999 {
-                    return None;
-                }
-                *nanos = value;
-            }
+            1 => *seconds = Some(integer(stamp).filter(|value| valid_seconds(*value))?),
+            2 => *nanos = integer(stamp).filter(|value| valid_nanos(*value))?,
             _ => {}
         }
         Some(())
     })
 }
 
+/// Protobuf encoders for building test blobs.
 #[cfg(test)]
-mod tests {
-    use super::*;
+pub(super) mod test_fixtures {
     fn varint(mut value: u64) -> Vec<u8> {
         let mut bytes = Vec::new();
         loop {
@@ -339,17 +328,25 @@ mod tests {
             }
         }
     }
-    fn field_varint(number: u64, value: u64) -> Vec<u8> {
-        let mut b = varint(number << 3);
-        b.extend(varint(value));
-        b
+
+    pub(crate) fn field_varint(number: u64, value: u64) -> Vec<u8> {
+        let mut bytes = varint(number << 3);
+        bytes.extend(varint(value));
+        bytes
     }
-    fn field_bytes(number: u64, value: &[u8]) -> Vec<u8> {
-        let mut b = varint((number << 3) | 2);
-        b.extend(varint(value.len() as u64));
-        b.extend(value);
-        b
+
+    pub(crate) fn field_bytes(number: u64, value: &[u8]) -> Vec<u8> {
+        let mut bytes = varint((number << 3) | 2);
+        bytes.extend(varint(value.len() as u64));
+        bytes.extend(value);
+        bytes
     }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::test_fixtures::{field_bytes, field_varint};
+    use super::*;
     #[test]
     fn decodes_generation_usage_and_timestamp() {
         let mut usage = Vec::new();