fix: resolve version gate and SSE parser misparse of CloudCodeResponse

Update upstream client version from CARGO_PKG_VERSION to dedicated
UPSTREAM_VERSION constant (1.16.5) to pass Google's version gate check.

Fix SSE parser silently misinterpreting CloudCodeResponse-wrapped JSON
as bare GenerateContentResponse when deserialization fails (e.g. missing
'role' field). The fallback parse would produce all-None fields, causing
a misleading 'no candidates' error. Now detects the wrapper key and
extracts text via JSON pointer for a meaningful error message.

Add promptFeedback/blockReason parsing for prompt-level blocking.
Add raw_data to 'no candidates' diagnostic logging.
Fix clippy warnings (collapsible_match, collapsible_if, filter_map).

Author: skyline69

src/auth/mod.rs

@@ -106,7 +106,12 @@ impl HttpClient {
     ) -> Result<Vec<u8>, String> {
         let os = std::env::consts::OS;
         let arch = std::env::consts::ARCH;
-        let user_agent = format!("antigravity/{} {}/{}", env!("CARGO_PKG_VERSION"), os, arch);
+        let user_agent = format!(
+            "antigravity/{} {}/{}",
+            crate::cloudcode::request::UPSTREAM_VERSION,
+            os,
+            arch
+        );
 
         let client_metadata = r#"{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}"#;
 
@@ -151,7 +156,12 @@ impl HttpClient {
     ) -> Result<Vec<u8>, String> {
         let os = std::env::consts::OS;
         let arch = std::env::consts::ARCH;
-        let user_agent = format!("antigravity/{} {}/{}", env!("CARGO_PKG_VERSION"), os, arch);
+        let user_agent = format!(
+            "antigravity/{} {}/{}",
+            crate::cloudcode::request::UPSTREAM_VERSION,
+            os,
+            arch
+        );
 
         let client_metadata = r#"{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}"#;
 

src/cloudcode/request.rs

@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use std::sync::LazyLock;
 
 use crate::format::google::CloudCodeRequest;
-use crate::format::{convert_request, MessagesRequest};
+use crate::format::{MessagesRequest, convert_request};
 use crate::models::{get_model_family, is_thinking_model};
 
 const SYSTEM_INSTRUCTION: &str = "You are Antigravity, a powerful agentic AI coding assistant designed by the Google Deepmind team working on Advanced Agentic Coding.You are pair programming with a USER to solve their coding task. The task may require creating a new codebase, modifying or debugging an existing codebase, or simply answering a question.**Absolute paths only****Proactiveness**";
@@ -18,10 +18,15 @@ static SYSTEM_INSTRUCTION_IGNORE: LazyLock<String> = LazyLock::new(|| {
     )
 });
 
+/// The upstream Antigravity client version to impersonate.
+/// This must be kept up to date with the latest Antigravity release
+/// to avoid Google's version gate ("This version of Antigravity is no longer supported").
+pub const UPSTREAM_VERSION: &str = "1.16.5";
+
 static USER_AGENT: LazyLock<String> = LazyLock::new(|| {
     let os = std::env::consts::OS;
     let arch = std::env::consts::ARCH;
-    format!("antigravity/{} {}/{}", env!("CARGO_PKG_VERSION"), os, arch)
+    format!("antigravity/{} {}/{}", UPSTREAM_VERSION, os, arch)
 });
 
 pub fn build_headers(

src/cloudcode/sse.rs

@@ -18,6 +18,7 @@ pub struct SseParser {
     output_tokens: u32,
     cache_read_tokens: u32,
     stop_reason: Option<String>,
+    last_raw_data: String,
 }
 
 #[derive(Clone, Copy, PartialEq)]
@@ -41,6 +42,7 @@ impl SseParser {
             output_tokens: 0,
             cache_read_tokens: 0,
             stop_reason: None,
+            last_raw_data: String::new(),
         }
     }
 
@@ -93,18 +95,55 @@ impl SseParser {
             return Some(vec![create_message_stop()]);
         }
 
+        // Store raw data for diagnostic logging
+        self.last_raw_data.clear();
+        self.last_raw_data
+            .push_str(&data.chars().take(500).collect::<String>());
+
         // Parse JSON - try CloudCodeResponse wrapper first, then direct GenerateContentResponse
         let response: GenerateContentResponse =
             match serde_json::from_str::<CloudCodeResponse>(data) {
                 Ok(wrapper) => wrapper.response,
-                Err(_) => match serde_json::from_str(data) {
-                    Ok(r) => r,
-                    Err(_) => {
-                        // Try to detect error responses from Google API
-                        // Google may return {"error": {"code": 404, "message": "...", "status": "NOT_FOUND"}}
-                        if let Ok(raw) = serde_json::from_str::<serde_json::Value>(data)
-                            && let Some(error_obj) = raw.get("error")
-                        {
+                Err(wrapper_err) => {
+                    // Before falling through, check if the JSON has a "response" key.
+                    // If it does, this IS a CloudCodeResponse wrapper but with unexpected
+                    // structure (e.g. missing "role" on content). Falling through to parse
+                    // as bare GenerateContentResponse would silently produce all-None fields
+                    // since serde ignores unknown keys.
+                    if let Ok(raw) = serde_json::from_str::<serde_json::Value>(data) {
+                        if raw.get("response").is_some() {
+                            // Extract any text from the response for a useful error message
+                            let text = raw
+                                .pointer("/response/candidates/0/content/parts/0/text")
+                                .and_then(|v| v.as_str());
+
+                            let message = if let Some(msg) = text {
+                                msg.to_string()
+                            } else {
+                                format!(
+                                    "Failed to parse CloudCodeResponse ({}). Raw: {}",
+                                    wrapper_err,
+                                    data.chars().take(300).collect::<String>()
+                                )
+                            };
+
+                            tracing::warn!(
+                                model = %self.model,
+                                message = %message,
+                                "Unparseable CloudCodeResponse wrapper"
+                            );
+
+                            return Some(vec![StreamEvent::Error {
+                                error: ErrorData {
+                                    error_type: "api_error".to_string(),
+                                    message,
+                                },
+                            }]);
+                        }
+
+                        // Check for top-level error responses from Google API
+                        // e.g. {"error": {"code": 404, "message": "...", "status": "NOT_FOUND"}}
+                        if let Some(error_obj) = raw.get("error") {
                             let code = error_obj.get("code").and_then(|c| c.as_i64()).unwrap_or(0);
                             let message = error_obj
                                 .get("message")
@@ -130,13 +169,20 @@ impl SseParser {
                                 },
                             }]);
                         }
-                        tracing::debug!(
-                            data = %data.chars().take(200).collect::<String>(),
-                            "Failed to parse SSE data"
-                        );
-                        return None;
                     }
-                },
+
+                    // Try direct GenerateContentResponse parse (for non-wrapper responses)
+                    match serde_json::from_str(data) {
+                        Ok(r) => r,
+                        Err(_) => {
+                            tracing::debug!(
+                                data = %data.chars().take(200).collect::<String>(),
+                                "Failed to parse SSE data"
+                            );
+                            return None;
+                        }
+                    }
+                }
             };
 
         // Check for error in the parsed response
@@ -199,10 +245,28 @@ impl SseParser {
             }
         }
 
+        // Check for prompt-level blocking (promptFeedback with blockReason)
+        if let Some(feedback) = &response.prompt_feedback
+            && let Some(reason) = &feedback.block_reason
+        {
+            tracing::warn!(
+                model = %self.model,
+                block_reason = %reason,
+                "Prompt blocked by Google API"
+            );
+            return vec![StreamEvent::Error {
+                error: ErrorData {
+                    error_type: "invalid_request_error".to_string(),
+                    message: format!("Prompt blocked by Google API (reason: {})", reason),
+                },
+            }];
+        }
+
         // Check for no candidates at all (model unavailable or empty response)
         if first_candidate.is_none() && !self.has_emitted_start {
             tracing::warn!(
                 model = %self.model,
+                raw_data = %self.last_raw_data,
                 "Google API returned response with no candidates"
             );
             return vec![StreamEvent::Error {
@@ -636,4 +700,30 @@ mod tests {
             _ => panic!("Expected Error event, got {:?}", events[0]),
         }
     }
+
+    #[test]
+    fn test_sse_parser_version_gate_response() {
+        // Reproduce the exact response Google returns when client version is outdated.
+        // The response has candidates with content but no "role" field on the content object,
+        // causing CloudCodeResponse parsing to fail. We should extract the text and return
+        // it as an error instead of silently misreporting "no candidates."
+        let mut parser = SseParser::new("claude-opus-4-6-thinking");
+
+        let data = "data: {\"response\": {\"candidates\": [{\"content\": {\"parts\": [{\"text\": \"This version of Antigravity is no longer supported. Please update to receive the latest features!\"}]}}]}}\n\n";
+
+        let events = parser.feed(data);
+
+        assert_eq!(events.len(), 1);
+        match &events[0] {
+            StreamEvent::Error { error } => {
+                assert_eq!(error.error_type, "api_error");
+                assert!(
+                    error.message.contains("no longer supported"),
+                    "Error message should contain the version gate text, got: {}",
+                    error.message
+                );
+            }
+            _ => panic!("Expected Error event, got {:?}", events[0]),
+        }
+    }
 }

src/format/google.rs

@@ -159,6 +159,17 @@ pub struct GenerateContentResponse {
     pub usage_metadata: Option<UsageMetadata>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub error: Option<GoogleError>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub prompt_feedback: Option<PromptFeedback>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct PromptFeedback {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub block_reason: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub safety_ratings: Option<Vec<serde_json::Value>>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]

src/format/openai_convert.rs

@@ -146,11 +146,12 @@ pub fn openai_to_anthropic(request: &ChatCompletionRequest) -> MessagesRequest {
             serde_json::Value::Object(obj) => {
                 // {"type": "function", "function": {"name": "..."}}
                 if let Some(func) = obj.get("function")
-                    && let Some(name) = func.get("name").and_then(|n| n.as_str()) {
-                        return Some(crate::format::anthropic::ToolChoice::Tool {
-                            name: name.to_string(),
-                        });
-                    }
+                    && let Some(name) = func.get("name").and_then(|n| n.as_str())
+                {
+                    return Some(crate::format::anthropic::ToolChoice::Tool {
+                        name: name.to_string(),
+                    });
+                }
                 None
             }
             _ => None,
@@ -163,9 +164,10 @@ pub fn openai_to_anthropic(request: &ChatCompletionRequest) -> MessagesRequest {
             let json_instruction =
                 "You must respond with valid JSON. Output only JSON, no other text.";
             match system {
-                Some(SystemPrompt::Text(existing)) => {
-                    Some(SystemPrompt::Text(format!("{}\n\n{}", existing, json_instruction)))
-                }
+                Some(SystemPrompt::Text(existing)) => Some(SystemPrompt::Text(format!(
+                    "{}\n\n{}",
+                    existing, json_instruction
+                ))),
                 None => Some(SystemPrompt::Text(json_instruction.to_string())),
                 other => other,
             }
@@ -290,12 +292,10 @@ fn convert_chat_content(content: &ChatContent) -> MessageContent {
             let blocks: Vec<ContentBlock> = parts
                 .iter()
                 .map(|p| match p {
-                    crate::format::openai::ChatContentPart::Text { text } => {
-                        ContentBlock::Text {
-                            text: text.clone(),
-                            cache_control: None,
-                        }
-                    }
+                    crate::format::openai::ChatContentPart::Text { text } => ContentBlock::Text {
+                        text: text.clone(),
+                        cache_control: None,
+                    },
                     crate::format::openai::ChatContentPart::ImageUrl { image_url } => {
                         // Try to parse data URL
                         if let Some(data) = parse_data_url(&image_url.url) {

src/format/responses_convert.rs

@@ -79,10 +79,11 @@ pub fn responses_to_anthropic(request: &ResponsesRequest) -> MessagesRequest {
                             // Try to append to last assistant message
                             if let Some(last) = messages.last_mut()
                                 && matches!(last.role, Role::Assistant)
-                                && let MessageContent::Blocks(blocks) = &mut last.content {
-                                    blocks.push(block);
-                                    continue;
-                                }
+                                && let MessageContent::Blocks(blocks) = &mut last.content
+                            {
+                                blocks.push(block);
+                                continue;
+                            }
 
                             messages.push(Message {
                                 role: Role::Assistant,
@@ -102,10 +103,11 @@ pub fn responses_to_anthropic(request: &ResponsesRequest) -> MessagesRequest {
                             // Try to append to last user message
                             if let Some(last) = messages.last_mut()
                                 && matches!(last.role, Role::User)
-                                && let MessageContent::Blocks(blocks) = &mut last.content {
-                                    blocks.push(block);
-                                    continue;
-                                }
+                                && let MessageContent::Blocks(blocks) = &mut last.content
+                            {
+                                blocks.push(block);
+                                continue;
+                            }
 
                             messages.push(Message {
                                 role: Role::User,

src/format/to_anthropic.rs

@@ -172,6 +172,7 @@ mod tests {
                 cached_content_token_count: 0,
             }),
             error: None,
+            prompt_feedback: None,
         }
     }
 
@@ -226,6 +227,7 @@ mod tests {
                 cached_content_token_count: 800,
             }),
             error: None,
+            prompt_feedback: None,
         };
 
         let result = convert_response(&response, "test", "req_cache");
@@ -242,6 +244,7 @@ mod tests {
             candidates: None,
             usage_metadata: None,
             error: None,
+            prompt_feedback: None,
         };
 
         let result = convert_response(&response, "test", "req_empty");

src/format/to_google.rs

@@ -7,8 +7,8 @@ use crate::format::google::{
     InlineData, InlineDataPart, Part, TextPart, ThinkingConfig, ThoughtPart, ToolConfig,
 };
 use crate::format::signature_cache::{
-    get_cached_tool_signature, is_signature_compatible, ModelFamily, GEMINI_SKIP_SIGNATURE,
-    MIN_SIGNATURE_LENGTH,
+    GEMINI_SKIP_SIGNATURE, MIN_SIGNATURE_LENGTH, ModelFamily, get_cached_tool_signature,
+    is_signature_compatible,
 };
 use crate::models::{get_model_family, is_thinking_model};