feat: add per-request compression override fields (#416)

Author: CLEMENTINATOR

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "edgee"
-version = "2.0.4"
+version = "2.0.5"
 edition = "2021"
 authors = ["Edgee <opensource@edgee.ai>"]
 license = "Apache-2.0"
@@ -48,4 +48,4 @@ path = "examples/tools.rs"
 
 [[example]]
 name = "compression"
-path = "examples/compression.rs"
+path = "examples/compression.rs"

Cargo.toml

@@ -9,7 +9,7 @@
 //! This example includes a large context in the user message to demonstrate meaningful
 //! compression savings.
 
-use edgee::{Edgee, InputObject, Message};
+use edgee::{CompressionConfiguration, Edgee, InputObject, Message};
 
 // Large context document to demonstrate input compression
 const LARGE_CONTEXT: &str = r#"
@@ -82,8 +82,11 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Create input with compression settings using builder pattern
     let input = InputObject::new(vec![Message::user(user_message)])
-        .with_compression(true)
-        .with_compression_rate(0.5);
+        .with_compression_model("agentic")
+        .with_compression_configuration(CompressionConfiguration {
+            rate: Some(0.5),
+            semantic_preservation_threshold: None,
+        });
 
     let response = client.send("anthropic/claude-haiku-4-5", input).await?;
 

examples/compression.rs

@@ -47,8 +47,8 @@ struct ParsedInput {
     tools: Option<Vec<Tool>>,
     tool_choice: Option<serde_json::Value>,
     tags: Option<Vec<String>>,
-    enable_compression: Option<bool>,
-    compression_rate: Option<f64>,
+    compression_model: Option<String>,
+    compression_configuration: Option<CompressionConfiguration>,
 }
 
 /// Main client for interacting with the Edgee AI Gateway
@@ -119,11 +119,11 @@ impl Edgee {
         if let Some(tags) = parsed.tags {
             body["tags"] = json!(tags);
         }
-        if let Some(enable_compression) = parsed.enable_compression {
-            body["enable_compression"] = json!(enable_compression);
+        if let Some(compression_model) = &parsed.compression_model {
+            body["compression_model"] = json!(compression_model);
         }
-        if let Some(compression_rate) = parsed.compression_rate {
-            body["compression_rate"] = json!(compression_rate);
+        if let Some(config) = &parsed.compression_configuration {
+            body["compression_configuration"] = json!(config);
         }
 
         let response = self
@@ -198,11 +198,11 @@ impl Edgee {
         if let Some(tags) = parsed.tags {
             body["tags"] = json!(tags);
         }
-        if let Some(enable_compression) = parsed.enable_compression {
-            body["enable_compression"] = json!(enable_compression);
+        if let Some(compression_model) = &parsed.compression_model {
+            body["compression_model"] = json!(compression_model);
         }
-        if let Some(compression_rate) = parsed.compression_rate {
-            body["compression_rate"] = json!(compression_rate);
+        if let Some(config) = &parsed.compression_configuration {
+            body["compression_configuration"] = json!(config);
         }
 
         let response = self
@@ -284,16 +284,16 @@ impl Edgee {
                 tools: None,
                 tool_choice: None,
                 tags: None,
-                enable_compression: None,
-                compression_rate: None,
+                compression_model: None,
+                compression_configuration: None,
             },
             Input::Object(obj) => ParsedInput {
                 messages: obj.messages,
                 tools: obj.tools,
                 tool_choice: obj.tool_choice,
                 tags: obj.tags,
-                enable_compression: obj.enable_compression,
-                compression_rate: obj.compression_rate,
+                compression_model: obj.compression_model,
+                compression_configuration: obj.compression_configuration,
             },
         }
     }

src/client.rs

@@ -183,6 +183,18 @@ pub enum ToolChoice {
     },
 }
 
+/// Configuration for the compression model.
+/// Only relevant for the `agentic` compression model.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct CompressionConfiguration {
+    /// Compression rate (0.0-1.0). Defaults to 0.8 when not specified.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub rate: Option<f64>,
+    /// Semantic preservation threshold (0-100).
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub semantic_preservation_threshold: Option<i32>,
+}
+
 /// Input for the chat completion request
 #[derive(Debug, Clone, Serialize)]
 pub struct InputObject {
@@ -193,14 +205,16 @@ pub struct InputObject {
     pub tool_choice: Option<serde_json::Value>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub tags: Option<Vec<String>>,
-    /// Enable token compression for this request (overrides API key settings if present)
+    /// Compression model for this request (agentic, claude, opencode, cursor, or customer).
+    /// Only one compression model per request. Each model is a bundle of strategies.
     /// This is a gateway-internal field and is never sent to providers.
     #[serde(default, skip_serializing)]
-    pub enable_compression: Option<bool>,
-    /// Compression rate for this request (0.0-1.0, overrides API key settings if present)
+    pub compression_model: Option<String>,
+    /// Configuration for the compression model (rate, semantic preservation threshold).
+    /// Only relevant for the `agentic` compression model.
     /// This is a gateway-internal field and is never sent to providers.
     #[serde(default, skip_serializing)]
-    pub compression_rate: Option<f64>,
+    pub compression_configuration: Option<CompressionConfiguration>,
 }
 
 impl InputObject {
@@ -211,8 +225,8 @@ impl InputObject {
             tools: None,
             tool_choice: None,
             tags: None,
-            enable_compression: None,
-            compression_rate: None,
+            compression_model: None,
+            compression_configuration: None,
         }
     }
 
@@ -234,15 +248,15 @@ impl InputObject {
         self
     }
 
-    /// Enable or disable token compression for this request
-    pub fn with_compression(mut self, enable: bool) -> Self {
-        self.enable_compression = Some(enable);
+    /// Set the compression model for this request (agentic, claude, opencode, cursor, customer)
+    pub fn with_compression_model(mut self, model: impl Into<String>) -> Self {
+        self.compression_model = Some(model.into());
         self
     }
 
-    /// Set compression rate for this request (0.0-1.0)
-    pub fn with_compression_rate(mut self, rate: f64) -> Self {
-        self.compression_rate = Some(rate);
+    /// Set the compression configuration (only relevant for agentic model)
+    pub fn with_compression_configuration(mut self, config: CompressionConfiguration) -> Self {
+        self.compression_configuration = Some(config);
         self
     }
 }
@@ -424,10 +438,15 @@ mod tests {
     #[test]
     fn test_input_object_with_compression_builder() {
         let input = InputObject::new(vec![Message::user("Hello")])
-            .with_compression(true)
-            .with_compression_rate(0.5);
-
-        assert_eq!(input.enable_compression, Some(true));
-        assert_eq!(input.compression_rate, Some(0.5));
+            .with_compression_model("agentic")
+            .with_compression_configuration(CompressionConfiguration {
+                rate: Some(0.5),
+                semantic_preservation_threshold: Some(60),
+            });
+
+        assert_eq!(input.compression_model, Some("agentic".to_string()));
+        let config = input.compression_configuration.unwrap();
+        assert_eq!(config.rate, Some(0.5));
+        assert_eq!(config.semantic_preservation_threshold, Some(60));
     }
 }