polish antigravity direct provider

Author: 1jehuang

src/auth/antigravity.rs

@@ -616,6 +616,12 @@ mod tests {
         );
     }
 
+    #[test]
+    fn client_metadata_uses_backend_accepted_platform() {
+        assert_eq!(metadata_platform(), "PLATFORM_UNSPECIFIED");
+        assert!(client_metadata_header().contains("\"platform\":\"PLATFORM_UNSPECIFIED\""));
+    }
+
     #[test]
     fn extract_project_id_supports_string_or_object() {
         assert_eq!(

src/cli/provider_init.rs

@@ -1041,7 +1041,7 @@ pub async fn login_and_bootstrap_provider(
             disable_subscription_runtime_mode();
             unlock_model_provider();
             crate::env::set_var("JCODE_ACTIVE_PROVIDER", "antigravity");
-            Arc::new(provider::antigravity::AntigravityCliProvider::new())
+            Arc::new(provider::antigravity::AntigravityProvider::new())
         }
         LoginProviderTarget::Google => {
             anyhow::bail!("Google login cannot be used as a model provider bootstrap");
@@ -1263,10 +1263,10 @@ async fn init_provider_with_options(
         ProviderChoice::Antigravity => {
             disable_subscription_runtime_mode();
             ensure_antigravity_auth_allowed_for_explicit_choice()?;
-            init_notice("Using Antigravity CLI provider (experimental)");
+            init_notice("Using Antigravity provider (experimental)");
             unlock_model_provider();
             crate::env::set_var("JCODE_ACTIVE_PROVIDER", "antigravity");
-            Arc::new(provider::antigravity::AntigravityCliProvider::new())
+            Arc::new(provider::antigravity::AntigravityProvider::new())
         }
         ProviderChoice::Google => {
             disable_subscription_runtime_mode();

src/provider/accessors.rs

@@ -22,7 +22,7 @@ impl MultiProvider {
             .clone()
     }
 
-    pub(super) fn antigravity_provider(&self) -> Option<Arc<antigravity::AntigravityCliProvider>> {
+    pub(super) fn antigravity_provider(&self) -> Option<Arc<antigravity::AntigravityProvider>> {
         self.antigravity
             .read()
             .unwrap_or_else(|poisoned| poisoned.into_inner())

src/provider/antigravity.rs

@@ -351,13 +351,13 @@ fn catalog_is_stale(fetched_at_rfc3339: &str) -> bool {
         >= CATALOG_REFRESH_TTL_HOURS
 }
 
-pub struct AntigravityCliProvider {
+pub struct AntigravityProvider {
     client: reqwest::Client,
     model: Arc<RwLock<String>>,
     fetched_catalog: Arc<RwLock<Vec<CatalogModel>>>,
 }
 
-impl Clone for AntigravityCliProvider {
+impl Clone for AntigravityProvider {
     fn clone(&self) -> Self {
         Self {
             client: self.client.clone(),
@@ -367,7 +367,7 @@ impl Clone for AntigravityCliProvider {
     }
 }
 
-impl AntigravityCliProvider {
+impl AntigravityProvider {
     fn persisted_catalog_path() -> Result<std::path::PathBuf> {
         Ok(crate::storage::app_config_dir()?.join("antigravity_models_cache.json"))
     }
@@ -486,18 +486,13 @@ impl AntigravityCliProvider {
     async fn fetch_available_models(&self) -> Result<Vec<CatalogModel>> {
         let mut tokens = antigravity_auth::load_or_refresh_tokens().await?;
 
-        if let Ok(models) = self
-            .fetch_available_models_with_project(&tokens.access_token, None)
-            .await
-            && !models.is_empty()
-        {
-            return Ok(models);
-        }
-
-        if let Some(project_id) = tokens.project_id.clone()
-            && !project_id.trim().is_empty()
+        if let Some(project_id) = tokens
+            .project_id
+            .as_deref()
+            .map(str::trim)
+            .filter(|value| !value.is_empty())
             && let Ok(models) = self
-                .fetch_available_models_with_project(&tokens.access_token, Some(&project_id))
+                .fetch_available_models_with_project(&tokens.access_token, Some(project_id))
                 .await
             && !models.is_empty()
         {
@@ -507,9 +502,13 @@ impl AntigravityCliProvider {
         if let Ok(project_id) = antigravity_auth::fetch_project_id(&tokens.access_token).await {
             tokens.project_id = Some(project_id.clone());
             let _ = antigravity_auth::save_tokens(&tokens);
-            return self
+            if let Ok(models) = self
                 .fetch_available_models_with_project(&tokens.access_token, Some(&project_id))
-                .await;
+                .await
+                && !models.is_empty()
+            {
+                return Ok(models);
+            }
         }
 
         self.fetch_available_models_with_project(&tokens.access_token, None)
@@ -593,14 +592,14 @@ impl AntigravityCliProvider {
     }
 }
 
-impl Default for AntigravityCliProvider {
+impl Default for AntigravityProvider {
     fn default() -> Self {
         Self::new()
     }
 }
 
 #[async_trait]
-impl Provider for AntigravityCliProvider {
+impl Provider for AntigravityProvider {
     async fn complete(
         &self,
         messages: &[Message],

src/provider/antigravity_tests.rs

@@ -18,6 +18,10 @@ fn parse_fetch_available_models_response_discovers_metadata_and_priority_order()
                 "displayName": "Gemini 3.1 Pro (High)",
                 "quotaInfo": { "remainingFraction": 0.25 }
             },
+            "gemini-3-flash": {
+                "displayName": "Gemini 3 Flash",
+                "quotaInfo": { "remainingFraction": 0, "resetTime": "2026-04-24T21:53:26Z" }
+            },
             "gpt-oss-120b-medium": {}
         }
     }))
@@ -32,11 +36,23 @@ fn parse_fetch_available_models_response_discovers_metadata_and_priority_order()
         Some("Claude Opus 4.6 (Thinking)")
     );
     assert_eq!(parsed[1].remaining_fraction_milli, Some(250));
+    let flash = parsed
+        .iter()
+        .find(|model| model.id == "gemini-3-flash")
+        .expect("gemini flash model");
+    assert!(!flash.available);
+    assert_eq!(flash.remaining_fraction_milli, Some(0));
+}
+
+#[test]
+fn client_metadata_uses_backend_accepted_platform() {
+    assert_eq!(metadata_platform(), "PLATFORM_UNSPECIFIED");
+    assert!(client_metadata_header().contains("\"platform\":\"PLATFORM_UNSPECIFIED\""));
 }
 
 #[test]
 fn available_models_display_includes_dynamic_cache_and_current_override() {
-    let provider = AntigravityCliProvider::new();
+    let provider = AntigravityProvider::new();
     *provider.fetched_catalog.write().expect("catalog lock") = vec![
         CatalogModel {
             id: "claude-opus-4-6-thinking".to_string(),
@@ -81,7 +97,7 @@ fn available_models_display_seeds_from_persisted_catalog() {
     let previous = std::env::var_os("JCODE_HOME");
     crate::env::set_var("JCODE_HOME", temp.path());
 
-    let path = AntigravityCliProvider::persisted_catalog_path().expect("catalog path");
+    let path = AntigravityProvider::persisted_catalog_path().expect("catalog path");
     crate::storage::write_json(
         &path,
         &PersistedCatalog {
@@ -102,7 +118,7 @@ fn available_models_display_seeds_from_persisted_catalog() {
     )
     .expect("write persisted catalog");
 
-    let provider = AntigravityCliProvider::new();
+    let provider = AntigravityProvider::new();
     assert!(
         provider
             .available_models_display()
@@ -143,7 +159,7 @@ fn catalog_stale_handles_invalid_timestamp() {
 
 #[tokio::test]
 async fn complete_uses_native_https_transport_not_cli_subprocess() {
-    let provider = AntigravityCliProvider::new();
+    let provider = AntigravityProvider::new();
     let mut stream = provider
         .complete(&[], &[], "say hello", None)
         .await

src/provider/mod.rs

@@ -580,8 +580,8 @@ pub struct MultiProvider {
     openai: RwLock<Option<Arc<openai::OpenAIProvider>>>,
     /// GitHub Copilot API provider (direct API, hot-swappable after login)
     copilot_api: RwLock<Option<Arc<copilot::CopilotApiProvider>>>,
-    /// Antigravity provider (CLI-backed, hot-swappable after login)
-    antigravity: RwLock<Option<Arc<antigravity::AntigravityCliProvider>>>,
+    /// Antigravity provider (direct HTTPS, hot-swappable after login)
+    antigravity: RwLock<Option<Arc<antigravity::AntigravityProvider>>>,
     /// Gemini provider (hot-swappable after login)
     gemini: RwLock<Option<Arc<gemini::GeminiProvider>>>,
     /// Cursor provider (native/direct API, hot-swappable after login)
@@ -1746,7 +1746,7 @@ impl Provider for MultiProvider {
                 .antigravity
                 .write()
                 .unwrap_or_else(|poisoned| poisoned.into_inner()) =
-                Some(Arc::new(antigravity::AntigravityCliProvider::new()));
+                Some(Arc::new(antigravity::AntigravityProvider::new()));
         }
 
         let already_has_gemini = self.gemini_provider().is_some();

src/provider/startup.rs

@@ -149,7 +149,7 @@ impl MultiProvider {
         };
 
         let antigravity_provider = if has_antigravity_creds {
-            Some(Arc::new(antigravity::AntigravityCliProvider::new()))
+            Some(Arc::new(antigravity::AntigravityProvider::new()))
         } else {
             None
         };

src/provider/tests/auth_refresh.rs

@@ -401,7 +401,7 @@ fn test_multi_provider_antigravity_routes_do_not_include_legacy_duplicate_entrie
         anthropic: RwLock::new(None),
         openai: RwLock::new(None),
         copilot_api: RwLock::new(None),
-        antigravity: RwLock::new(Some(Arc::new(antigravity::AntigravityCliProvider::new()))),
+        antigravity: RwLock::new(Some(Arc::new(antigravity::AntigravityProvider::new()))),
         gemini: RwLock::new(None),
         cursor: RwLock::new(None),
         openrouter: RwLock::new(None),