feat(grokbuild): add first-class Grok Build support (#5453)

* feat(grokbuild): add backend integration

* feat(grokbuild): add provider and management UI

* test(grokbuild): cover configuration and integrations

* fix(grokbuild): address backend review feedback

* fix(grokbuild): complete UI review feedback

* feat(grokbuild): add CLI lifecycle management

* fix(grokbuild): align provider icon fallback

* test(grokbuild): cover provider icon persistence

src-tauri/src/proxy/usage/calculator.rs

@@ -59,7 +59,7 @@ impl CostCalculator {
         pricing: &ModelPricing,
         cost_multiplier: Decimal,
     ) -> CostBreakdown {
-        let input_includes_cache_read = matches!(app_type, "codex" | "gemini");
+        let input_includes_cache_read = matches!(app_type, "codex" | "gemini" | "grokbuild");
         Self::calculate_with_cache_semantics(
             usage,
             pricing,
@@ -211,6 +211,25 @@ mod tests {
         assert_eq!(cost.total_cost, Decimal::from_str("0.010035").unwrap());
     }
 
+    #[test]
+    fn grokbuild_does_not_double_bill_cached_input() {
+        let usage = TokenUsage {
+            input_tokens: 1000,
+            output_tokens: 0,
+            cache_read_tokens: 600,
+            cache_creation_tokens: 0,
+            model: None,
+            message_id: None,
+        };
+        let pricing = ModelPricing::from_strings("10", "0", "1", "0").unwrap();
+
+        let cost = CostCalculator::calculate_for_app("grokbuild", &usage, &pricing, Decimal::ONE);
+
+        assert_eq!(cost.input_cost, Decimal::from_str("0.004").unwrap());
+        assert_eq!(cost.cache_read_cost, Decimal::from_str("0.0006").unwrap());
+        assert_eq!(cost.total_cost, Decimal::from_str("0.0046").unwrap());
+    }
+
     #[test]
     fn test_cost_multiplier() {
         let usage = TokenUsage {

src-tauri/src/proxy/usage/logger.rs

@@ -71,11 +71,12 @@ impl<'a> UsageLogger<'a> {
             };
 
         let created_at = chrono::Utc::now().timestamp();
-        let input_token_semantics = if matches!(log.app_type.as_str(), "codex" | "gemini") {
-            INPUT_TOKEN_SEMANTICS_TOTAL
-        } else {
-            INPUT_TOKEN_SEMANTICS_FRESH
-        };
+        let input_token_semantics =
+            if matches!(log.app_type.as_str(), "codex" | "gemini" | "grokbuild") {
+                INPUT_TOKEN_SEMANTICS_TOTAL
+            } else {
+                INPUT_TOKEN_SEMANTICS_FRESH
+            };
 
         conn.execute(
             "INSERT OR REPLACE INTO proxy_request_logs (
@@ -459,4 +460,39 @@ mod tests {
         assert_eq!(error, Some("Internal Server Error".to_string()));
         Ok(())
     }
+
+    #[test]
+    fn grokbuild_logs_total_input_token_semantics() -> Result<(), AppError> {
+        let db = Database::memory()?;
+        let logger = UsageLogger::new(&db);
+        let log = RequestLog {
+            request_id: "grok-semantics".to_string(),
+            provider_id: "grok-provider".to_string(),
+            app_type: "grokbuild".to_string(),
+            model: "grok-4.5".to_string(),
+            request_model: "grok-4.5".to_string(),
+            pricing_model: String::new(),
+            usage: TokenUsage::default(),
+            cost: None,
+            latency_ms: 1,
+            first_token_ms: None,
+            status_code: 200,
+            error_message: None,
+            session_id: None,
+            provider_type: Some("grokbuild".to_string()),
+            is_streaming: false,
+            cost_multiplier: "1".to_string(),
+        };
+
+        logger.log_request(&log)?;
+
+        let conn = crate::database::lock_conn!(db.conn);
+        let semantics: i64 = conn.query_row(
+            "SELECT input_token_semantics FROM proxy_request_logs WHERE request_id = 'grok-semantics'",
+            [],
+            |row| row.get(0),
+        )?;
+        assert_eq!(semantics, INPUT_TOKEN_SEMANTICS_TOTAL);
+        Ok(())
+    }
 }