feat: v1.3 - OpenAI tool streaming, Responses API function calls, thinking config, CORS, and more

skyline69 · skyline69 · commit 88a620085743 · 2026-02-11T22:38:09.000+01:00
Add OpenAI streaming tool call support with ContentBlockStart/Delta/Stop
handling to emit ChunkToolCall events with incremental argument streaming.

Add Responses API function_call and function_call_output input items with
conversion to Anthropic ToolUse/ToolResult blocks, plus streaming events
for FunctionCallArgumentsDelta and FunctionCallArgumentsDone.

Add client-provided thinking configuration (ThinkingConfig with
budget_tokens) respected in Anthropic-to-Google conversion.

Add OpenAI response_format/JSON mode with system prompt injection,
tool_choice conversion (auto/required/none/specific function), and
image URL fallback for non-data URLs.

Extend cache key to include max_tokens, top_p, top_k, stop_sequences
for correct cache discrimination.

Add CORS preflight handler and headers on all response types.
Add 300s streaming frame timeout on all streaming loops.
Replace hardcoded user agent with dynamic CARGO_PKG_VERSION.
Replace timestamp-based request IDs with cryptographic random IDs.
diff --git a/src/auth/mod.rs b/src/auth/mod.rs
@@ -106,7 +106,7 @@ impl HttpClient {
     ) -> Result<Vec<u8>, String> {
         let os = std::env::consts::OS;
         let arch = std::env::consts::ARCH;
-        let user_agent = format!("antigravity/1.15.8 {}/{}", os, arch);
+        let user_agent = format!("antigravity/{} {}/{}", env!("CARGO_PKG_VERSION"), os, arch);
 
         let client_metadata = r#"{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}"#;
 
@@ -151,7 +151,7 @@ impl HttpClient {
     ) -> Result<Vec<u8>, String> {
         let os = std::env::consts::OS;
         let arch = std::env::consts::ARCH;
-        let user_agent = format!("antigravity/1.15.8 {}/{}", os, arch);
+        let user_agent = format!("antigravity/{} {}/{}", env!("CARGO_PKG_VERSION"), os, arch);
 
         let client_metadata = r#"{"ideType":"IDE_UNSPECIFIED","platform":"PLATFORM_UNSPECIFIED","pluginType":"GEMINI"}"#;
 
diff --git a/src/cache.rs b/src/cache.rs
@@ -64,13 +64,19 @@ impl ResponseCache {
     /// Generate a cache key from request parameters using SHA-256.
     ///
     /// The key is a deterministic hash of the model, messages, system prompt,
-    /// tools, and temperature. Returns a hex-encoded string (64 chars).
+    /// tools, temperature, max_tokens, top_p, top_k, and stop_sequences.
+    /// Returns a hex-encoded string (64 chars).
+    #[allow(clippy::too_many_arguments)]
     pub fn make_key(
         model: &str,
         messages_json: &str,
         system_json: Option<&str>,
         tools_json: Option<&str>,
         temperature: Option<f32>,
+        max_tokens: u32,
+        top_p: Option<f32>,
+        top_k: Option<u32>,
+        stop_sequences: Option<&str>,
     ) -> String {
         let mut hasher = Sha256::new();
         hasher.update(model.as_bytes());
@@ -88,6 +94,20 @@ impl ResponseCache {
         if let Some(temp) = temperature {
             hasher.update(temp.to_le_bytes());
         }
+        hasher.update(b"|");
+        hasher.update(max_tokens.to_le_bytes());
+        hasher.update(b"|");
+        if let Some(tp) = top_p {
+            hasher.update(tp.to_le_bytes());
+        }
+        hasher.update(b"|");
+        if let Some(tk) = top_k {
+            hasher.update(tk.to_le_bytes());
+        }
+        hasher.update(b"|");
+        if let Some(stop) = stop_sequences {
+            hasher.update(stop.as_bytes());
+        }
         let result = hasher.finalize();
         // Use a pre-allocated string and write hex directly (avoids per-byte format!)
         let mut hex = String::with_capacity(64);
@@ -211,7 +231,17 @@ mod tests {
     fn test_cache_basic_operations() {
         let mut cache = ResponseCache::new(true, 3600, 100);
 
-        let key = ResponseCache::make_key("claude-3", r#"[{"role":"user"}]"#, None, None, None);
+        let key = ResponseCache::make_key(
+            "claude-3",
+            r#"[{"role":"user"}]"#,
+            None,
+            None,
+            None,
+            1024,
+            None,
+            None,
+            None,
+        );
         let response = b"test response".to_vec();
 
         // Initially empty
@@ -276,13 +306,21 @@ mod tests {
             Some("system prompt"),
             None,
             Some(0.7),
+            1024,
+            None,
+            None,
+            None,
         );
         let key2 = ResponseCache::make_key(
             "claude-3",
             r#"[{"role":"user","content":"hello"}]"#,
             Some("system prompt"),
             None,
             Some(0.7),
+            1024,
+            None,
+            None,
+            None,
         );
         assert_eq!(key1, key2);
 
@@ -293,6 +331,10 @@ mod tests {
             Some("system prompt"),
             None,
             Some(0.7),
+            1024,
+            None,
+            None,
+            None,
         );
         assert_ne!(key1, key3);
 
@@ -303,6 +345,10 @@ mod tests {
             Some("system prompt"),
             None,
             Some(0.7),
+            1024,
+            None,
+            None,
+            None,
         );
         assert_ne!(key1, key4);
 
@@ -313,6 +359,10 @@ mod tests {
             Some("system prompt"),
             None,
             Some(0.9),
+            1024,
+            None,
+            None,
+            None,
         );
         assert_ne!(key1, key5);
 
@@ -323,9 +373,27 @@ mod tests {
             Some("different system"),
             None,
             Some(0.7),
+            1024,
+            None,
+            None,
+            None,
         );
         assert_ne!(key1, key6);
 
+        // Different max_tokens should produce different key
+        let key7 = ResponseCache::make_key(
+            "claude-3",
+            r#"[{"role":"user","content":"hello"}]"#,
+            Some("system prompt"),
+            None,
+            Some(0.7),
+            2048,
+            None,
+            None,
+            None,
+        );
+        assert_ne!(key1, key7);
+
         // Key should be valid hex (64 chars for SHA-256)
         assert_eq!(key1.len(), 64);
         assert!(key1.chars().all(|c| c.is_ascii_hexdigit()));
diff --git a/src/cloudcode/request.rs b/src/cloudcode/request.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use std::sync::LazyLock;
 
 use crate::format::google::CloudCodeRequest;
-use crate::format::{MessagesRequest, convert_request};
+use crate::format::{convert_request, MessagesRequest};
 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**";
@@ -21,7 +21,7 @@ static SYSTEM_INSTRUCTION_IGNORE: LazyLock<String> = LazyLock::new(|| {
 static USER_AGENT: LazyLock<String> = LazyLock::new(|| {
     let os = std::env::consts::OS;
     let arch = std::env::consts::ARCH;
-    format!("antigravity/1.15.8 {}/{}", os, arch)
+    format!("antigravity/{} {}/{}", env!("CARGO_PKG_VERSION"), os, arch)
 });
 
 pub fn build_headers(
diff --git a/src/format/anthropic.rs b/src/format/anthropic.rs
@@ -21,6 +21,19 @@ pub struct MessagesRequest {
     pub stop_sequences: Option<Vec<String>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tool_choice: Option<ToolChoice>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub thinking: Option<ThinkingConfig>,
+}
+
+/// Client-provided thinking configuration.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(tag = "type", rename_all = "snake_case")]
+pub enum ThinkingConfig {
+    Enabled {
+        #[serde(skip_serializing_if = "Option::is_none")]
+        budget_tokens: Option<u32>,
+    },
+    Disabled,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
diff --git a/src/format/openai.rs b/src/format/openai.rs
@@ -25,6 +25,8 @@ pub struct ChatCompletionRequest {
     pub n: Option<u32>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub user: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub response_format: Option<ResponseFormat>,
 }
 
 #[derive(Debug, Clone, Serialize, Deserialize)]
@@ -34,6 +36,16 @@ pub enum StopSequence {
     Multiple(Vec<String>),
 }
 
+/// Response format specification for JSON mode.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ResponseFormat {
+    #[serde(rename = "type")]
+    pub format_type: String,
+    /// JSON schema (for structured output mode)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub json_schema: Option<serde_json::Value>,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct ChatMessage {
     pub role: String,
diff --git a/src/format/openai_convert.rs b/src/format/openai_convert.rs
@@ -134,6 +134,48 @@ pub fn openai_to_anthropic(request: &ChatCompletionRequest) -> MessagesRequest {
             .collect()
     });
 
+    // Convert tool_choice
+    let tool_choice = request.tool_choice.as_ref().and_then(|tc| {
+        match tc {
+            serde_json::Value::String(s) => match s.as_str() {
+                "auto" => Some(crate::format::anthropic::ToolChoice::Auto),
+                "required" | "any" => Some(crate::format::anthropic::ToolChoice::Any),
+                "none" => None, // No tool choice = don't use tools
+                _ => None,
+            },
+            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(),
+                        });
+                    }
+                None
+            }
+            _ => None,
+        }
+    });
+
+    // Handle response_format: inject JSON instruction into system prompt if JSON mode requested
+    let system = if let Some(ref fmt) = request.response_format {
+        if fmt.format_type == "json_object" {
+            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)))
+                }
+                None => Some(SystemPrompt::Text(json_instruction.to_string())),
+                other => other,
+            }
+        } else {
+            system
+        }
+    } else {
+        system
+    };
+
     MessagesRequest {
         model: request.model.clone(),
         messages,
@@ -145,7 +187,8 @@ pub fn openai_to_anthropic(request: &ChatCompletionRequest) -> MessagesRequest {
         stop_sequences,
         stream: request.stream,
         tools,
-        tool_choice: None,
+        tool_choice,
+        thinking: None,
     }
 }
 
@@ -246,25 +289,30 @@ fn convert_chat_content(content: &ChatContent) -> MessageContent {
         ChatContent::Parts(parts) => {
             let blocks: Vec<ContentBlock> = parts
                 .iter()
-                .filter_map(|p| match p {
+                .map(|p| match p {
                     crate::format::openai::ChatContentPart::Text { text } => {
-                        Some(ContentBlock::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) {
-                            Some(ContentBlock::Image {
+                            ContentBlock::Image {
                                 source: crate::format::anthropic::ImageSource {
                                     source_type: "base64".to_string(),
                                     media_type: data.0,
                                     data: data.1,
                                 },
-                            })
+                            }
                         } else {
-                            None
+                            // Non-data URL: include as text reference since
+                            // the upstream API does not support URL-based images
+                            ContentBlock::Text {
+                                text: format!("[Image: {}]", image_url.url),
+                                cache_control: None,
+                            }
                         }
                     }
                 })
@@ -324,6 +372,7 @@ mod tests {
             tool_choice: None,
             n: None,
             user: None,
+            response_format: None,
         };
 
         let anthropic = openai_to_anthropic(&request);
diff --git a/src/format/responses.rs b/src/format/responses.rs
@@ -57,6 +57,18 @@ pub enum ResponseInputItem {
         role: String,
         content: ResponseInputContent,
     },
+    #[serde(rename = "function_call")]
+    FunctionCall {
+        id: Option<String>,
+        call_id: Option<String>,
+        name: Option<String>,
+        arguments: Option<String>,
+    },
+    #[serde(rename = "function_call_output")]
+    FunctionCallOutput {
+        call_id: Option<String>,
+        output: Option<String>,
+    },
     #[serde(other)]
     Other,
 }
@@ -257,6 +269,15 @@ pub enum ResponseStreamEvent {
         text: String,
     },
 
+    #[serde(rename = "response.function_call_arguments.delta")]
+    FunctionCallArgumentsDelta { output_index: usize, delta: String },
+
+    #[serde(rename = "response.function_call_arguments.done")]
+    FunctionCallArgumentsDone {
+        output_index: usize,
+        arguments: String,
+    },
+
     #[serde(rename = "response.completed")]
     ResponseCompleted { response: Box<ResponsesResponse> },
 }
diff --git a/src/format/responses_convert.rs b/src/format/responses_convert.rs
diff --git a/src/format/to_google.rs b/src/format/to_google.rs
diff --git a/src/server.rs b/src/server.rs
