Request compression is no longer tied to the provider

codex-rs/codex-api/src/endpoint/chat.rs

@@ -6,6 +6,7 @@ use crate::common::ResponseStream;
 use crate::endpoint::streaming::StreamingClient;
 use crate::error::ApiError;
 use crate::provider::Provider;
+use crate::provider::RequestCompression;
 use crate::provider::WireApi;
 use crate::sse::chat::spawn_chat_stream;
 use crate::telemetry::SseTelemetry;
@@ -45,8 +46,13 @@ impl<T: HttpTransport, A: AuthProvider> ChatClient<T, A> {
         }
     }
 
-    pub async fn stream_request(&self, request: ChatRequest) -> Result<ResponseStream, ApiError> {
-        self.stream(request.body, request.headers).await
+    pub async fn stream_request(
+        &self,
+        request: ChatRequest,
+        request_compression: RequestCompression,
+    ) -> Result<ResponseStream, ApiError> {
+        self.stream(request.body, request.headers, request_compression)
+            .await
     }
 
     pub async fn stream_prompt(
@@ -55,6 +61,7 @@ impl<T: HttpTransport, A: AuthProvider> ChatClient<T, A> {
         prompt: &ApiPrompt,
         conversation_id: Option<String>,
         session_source: Option<SessionSource>,
+        request_compression: RequestCompression,
     ) -> Result<ResponseStream, ApiError> {
         use crate::requests::ChatRequestBuilder;
 
@@ -64,7 +71,7 @@ impl<T: HttpTransport, A: AuthProvider> ChatClient<T, A> {
                 .session_source(session_source)
                 .build(self.streaming.provider())?;
 
-        self.stream_request(request).await
+        self.stream_request(request, request_compression).await
     }
 
     fn path(&self) -> &'static str {
@@ -78,9 +85,16 @@ impl<T: HttpTransport, A: AuthProvider> ChatClient<T, A> {
         &self,
         body: Value,
         extra_headers: HeaderMap,
+        request_compression: RequestCompression,
     ) -> Result<ResponseStream, ApiError> {
         self.streaming
-            .stream(self.path(), body, extra_headers, spawn_chat_stream)
+            .stream(
+                self.path(),
+                body,
+                extra_headers,
+                request_compression,
+                spawn_chat_stream,
+            )
             .await
     }
 }

codex-rs/codex-api/src/endpoint/compact.rs

@@ -90,7 +90,7 @@ struct CompactHistoryResponse {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::provider::RequestCompression;
+
     use crate::provider::RetryConfig;
     use async_trait::async_trait;
     use codex_client::Request;
@@ -137,7 +137,6 @@ mod tests {
                 retry_5xx: true,
                 retry_transport: true,
             },
-            request_compression: RequestCompression::None,
             stream_idle_timeout: Duration::from_secs(1),
         }
     }

codex-rs/codex-api/src/endpoint/models.rs

@@ -82,7 +82,6 @@ impl<T: HttpTransport, A: AuthProvider> ModelsClient<T, A> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::provider::RequestCompression;
     use crate::provider::RetryConfig;
     use crate::provider::WireApi;
     use async_trait::async_trait;
@@ -159,7 +158,6 @@ mod tests {
                 retry_5xx: true,
                 retry_transport: true,
             },
-            request_compression: RequestCompression::None,
             stream_idle_timeout: Duration::from_secs(1),
         }
     }

codex-rs/codex-api/src/endpoint/responses.rs

@@ -6,6 +6,7 @@ use crate::common::TextControls;
 use crate::endpoint::streaming::StreamingClient;
 use crate::error::ApiError;
 use crate::provider::Provider;
+use crate::provider::RequestCompression;
 use crate::provider::WireApi;
 use crate::requests::ResponsesRequest;
 use crate::requests::ResponsesRequestBuilder;
@@ -33,6 +34,7 @@ pub struct ResponsesOptions {
     pub conversation_id: Option<String>,
     pub session_source: Option<SessionSource>,
     pub extra_headers: HeaderMap,
+    pub request_compression: RequestCompression,
 }
 
 impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
@@ -55,8 +57,10 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
     pub async fn stream_request(
         &self,
         request: ResponsesRequest,
+        request_compression: RequestCompression,
     ) -> Result<ResponseStream, ApiError> {
-        self.stream(request.body, request.headers).await
+        self.stream(request.body, request.headers, request_compression)
+            .await
     }
 
     #[instrument(level = "trace", skip_all, err)]
@@ -75,6 +79,7 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
             conversation_id,
             session_source,
             extra_headers,
+            request_compression,
         } = options;
 
         let request = ResponsesRequestBuilder::new(model, &prompt.instructions, &prompt.input)
@@ -90,7 +95,7 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
             .extra_headers(extra_headers)
             .build(self.streaming.provider())?;
 
-        self.stream_request(request).await
+        self.stream_request(request, request_compression).await
     }
 
     fn path(&self) -> &'static str {
@@ -104,9 +109,16 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
         &self,
         body: Value,
         extra_headers: HeaderMap,
+        request_compression: RequestCompression,
     ) -> Result<ResponseStream, ApiError> {
         self.streaming
-            .stream(self.path(), body, extra_headers, spawn_response_stream)
+            .stream(
+                self.path(),
+                body,
+                extra_headers,
+                request_compression,
+                spawn_response_stream,
+            )
             .await
     }
 }

codex-rs/codex-api/src/endpoint/streaming.rs

@@ -62,12 +62,11 @@ impl<T: HttpTransport, A: AuthProvider> StreamingClient<T, A> {
         path: &str,
         body: Value,
         extra_headers: HeaderMap,
+        request_compression: RequestCompression,
         spawner: fn(StreamResponse, Duration, Option<Arc<dyn SseTelemetry>>) -> ResponseStream,
     ) -> Result<ResponseStream, ApiError> {
-        let content_encoding =
-            matches!(self.provider.request_compression, RequestCompression::Zstd);
-        let encoded_body =
-            encode_body(&body, self.provider.request_compression).map_err(ApiError::Stream)?;
+        let content_encoding = matches!(request_compression, RequestCompression::Zstd);
+        let encoded_body = encode_body(&body, request_compression).map_err(ApiError::Stream)?;
 
         let builder = || {
             let mut req = self.provider.build_request(Method::POST, path);

codex-rs/codex-api/src/provider.rs

@@ -41,8 +41,9 @@ impl RetryConfig {
     }
 }
 
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Debug, Clone, Copy, Default, PartialEq, Eq)]
 pub enum RequestCompression {
+    #[default]
     None,
     Zstd,
 }
@@ -59,7 +60,6 @@ pub struct Provider {
     pub wire: WireApi,
     pub headers: HeaderMap,
     pub retry: RetryConfig,
-    pub request_compression: RequestCompression,
     pub stream_idle_timeout: Duration,
 }
 

codex-rs/codex-api/src/requests/chat.rs

@@ -351,7 +351,7 @@ fn push_tool_call_message(messages: &mut Vec<Value>, tool_call: Value, reasoning
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::provider::RequestCompression;
+
     use crate::provider::RetryConfig;
     use crate::provider::WireApi;
     use codex_protocol::models::FunctionCallOutputPayload;
@@ -375,7 +375,6 @@ mod tests {
                 retry_5xx: true,
                 retry_transport: true,
             },
-            request_compression: RequestCompression::None,
             stream_idle_timeout: Duration::from_secs(1),
         }
     }

codex-rs/codex-api/src/requests/responses.rs

@@ -172,7 +172,7 @@ fn attach_item_ids(payload_json: &mut Value, original_items: &[ResponseItem]) {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::provider::RequestCompression;
+
     use crate::provider::RetryConfig;
     use crate::provider::WireApi;
     use codex_protocol::protocol::SubAgentSource;
@@ -194,7 +194,6 @@ mod tests {
                 retry_5xx: true,
                 retry_transport: true,
             },
-            request_compression: RequestCompression::None,
             stream_idle_timeout: Duration::from_secs(5),
         }
     }

codex-rs/codex-api/tests/clients.rs

@@ -11,7 +11,6 @@ use codex_api::Provider;
 use codex_api::ResponsesClient;
 use codex_api::ResponsesOptions;
 use codex_api::WireApi;
-use codex_api::provider::RequestCompression;
 use codex_client::HttpTransport;
 use codex_client::Request;
 use codex_client::Response;
@@ -133,7 +132,6 @@ fn provider(name: &str, wire: WireApi) -> Provider {
             retry_5xx: false,
             retry_transport: true,
         },
-        request_compression: RequestCompression::None,
         stream_idle_timeout: Duration::from_millis(10),
     }
 }
@@ -203,7 +201,9 @@ async fn chat_client_uses_chat_completions_path_for_chat_wire() -> Result<()> {
     let client = ChatClient::new(transport, provider("openai", WireApi::Chat), NoAuth);
 
     let body = serde_json::json!({ "echo": true });
-    let _stream = client.stream(body, HeaderMap::new()).await?;
+    let _stream = client
+        .stream(body, HeaderMap::new(), Default::default())
+        .await?;
 
     let requests = state.take_stream_requests();
     assert_path_ends_with(&requests, "/chat/completions");
@@ -217,7 +217,9 @@ async fn chat_client_uses_responses_path_for_responses_wire() -> Result<()> {
     let client = ChatClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
 
     let body = serde_json::json!({ "echo": true });
-    let _stream = client.stream(body, HeaderMap::new()).await?;
+    let _stream = client
+        .stream(body, HeaderMap::new(), Default::default())
+        .await?;
 
     let requests = state.take_stream_requests();
     assert_path_ends_with(&requests, "/responses");
@@ -231,7 +233,9 @@ async fn responses_client_uses_responses_path_for_responses_wire() -> Result<()>
     let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
 
     let body = serde_json::json!({ "echo": true });
-    let _stream = client.stream(body, HeaderMap::new()).await?;
+    let _stream = client
+        .stream(body, HeaderMap::new(), Default::default())
+        .await?;
 
     let requests = state.take_stream_requests();
     assert_path_ends_with(&requests, "/responses");
@@ -245,7 +249,9 @@ async fn responses_client_uses_chat_path_for_chat_wire() -> Result<()> {
     let client = ResponsesClient::new(transport, provider("openai", WireApi::Chat), NoAuth);
 
     let body = serde_json::json!({ "echo": true });
-    let _stream = client.stream(body, HeaderMap::new()).await?;
+    let _stream = client
+        .stream(body, HeaderMap::new(), Default::default())
+        .await?;
 
     let requests = state.take_stream_requests();
     assert_path_ends_with(&requests, "/chat/completions");
@@ -260,7 +266,9 @@ async fn streaming_client_adds_auth_headers() -> Result<()> {
     let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), auth);
 
     let body = serde_json::json!({ "model": "gpt-test" });
-    let _stream = client.stream(body, HeaderMap::new()).await?;
+    let _stream = client
+        .stream(body, HeaderMap::new(), Default::default())
+        .await?;
 
     let requests = state.take_stream_requests();
     assert_eq!(requests.len(), 1);

codex-rs/codex-api/tests/models_integration.rs

@@ -1,7 +1,6 @@
 use codex_api::AuthProvider;
 use codex_api::ModelsClient;
 use codex_api::provider::Provider;
-use codex_api::provider::RequestCompression;
 use codex_api::provider::RetryConfig;
 use codex_api::provider::WireApi;
 use codex_client::ReqwestTransport;
@@ -43,7 +42,6 @@ fn provider(base_url: &str) -> Provider {
             retry_5xx: true,
             retry_transport: true,
         },
-        request_compression: RequestCompression::None,
         stream_idle_timeout: std::time::Duration::from_secs(1),
     }
 }

codex-rs/codex-api/tests/sse_end_to_end.rs

@@ -9,7 +9,6 @@ use codex_api::Provider;
 use codex_api::ResponseEvent;
 use codex_api::ResponsesClient;
 use codex_api::WireApi;
-use codex_api::provider::RequestCompression;
 use codex_client::HttpTransport;
 use codex_client::Request;
 use codex_client::Response;
@@ -75,7 +74,6 @@ fn provider(name: &str, wire: WireApi) -> Provider {
             retry_5xx: false,
             retry_transport: true,
         },
-        request_compression: RequestCompression::None,
         stream_idle_timeout: Duration::from_millis(50),
     }
 }
@@ -126,7 +124,11 @@ async fn responses_stream_parses_items_and_completed_end_to_end() -> Result<()>
     let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
 
     let mut stream = client
-        .stream(serde_json::json!({"echo": true}), HeaderMap::new())
+        .stream(
+            serde_json::json!({"echo": true}),
+            HeaderMap::new(),
+            Default::default(),
+        )
         .await?;
 
     let mut events = Vec::new();
@@ -191,7 +193,11 @@ async fn responses_stream_aggregates_output_text_deltas() -> Result<()> {
     let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
 
     let stream = client
-        .stream(serde_json::json!({"echo": true}), HeaderMap::new())
+        .stream(
+            serde_json::json!({"echo": true}),
+            HeaderMap::new(),
+            Default::default(),
+        )
         .await?;
 
     let mut stream = stream.aggregate();

codex-rs/core/src/client.rs

@@ -156,9 +156,12 @@ impl ModelClient {
         let mut refreshed = false;
         loop {
             let auth = auth_manager.as_ref().and_then(|m| m.auth());
+            let request_compression = self
+                .provider
+                .request_compression_for(auth.as_ref().map(|a| a.mode), &self.config.features);
             let api_provider = self
                 .provider
-                .to_api_provider(auth.as_ref().map(|a| a.mode), &self.config.features)?;
+                .to_api_provider(auth.as_ref().map(|a| a.mode))?;
             let api_auth = auth_provider_from_auth(auth.clone(), &self.provider).await?;
             let transport = ReqwestTransport::new(build_reqwest_client());
             let (request_telemetry, sse_telemetry) = self.build_streaming_telemetry();
@@ -171,6 +174,7 @@ impl ModelClient {
                     &api_prompt,
                     Some(conversation_id.clone()),
                     Some(session_source.clone()),
+                    request_compression,
                 )
                 .await;
 
@@ -245,9 +249,12 @@ impl ModelClient {
         let mut refreshed = false;
         loop {
             let auth = auth_manager.as_ref().and_then(|m| m.auth());
+            let request_compression = self
+                .provider
+                .request_compression_for(auth.as_ref().map(|a| a.mode), &self.config.features);
             let api_provider = self
                 .provider
-                .to_api_provider(auth.as_ref().map(|a| a.mode), &self.config.features)?;
+                .to_api_provider(auth.as_ref().map(|a| a.mode))?;
             let api_auth = auth_provider_from_auth(auth.clone(), &self.provider).await?;
             let transport = ReqwestTransport::new(build_reqwest_client());
             let (request_telemetry, sse_telemetry) = self.build_streaming_telemetry();
@@ -263,6 +270,7 @@ impl ModelClient {
                 conversation_id: Some(conversation_id.clone()),
                 session_source: Some(session_source.clone()),
                 extra_headers: beta_feature_headers(&self.config),
+                request_compression,
             };
 
             let stream_result = client
@@ -332,7 +340,7 @@ impl ModelClient {
         let auth = auth_manager.as_ref().and_then(|m| m.auth());
         let api_provider = self
             .provider
-            .to_api_provider(auth.as_ref().map(|a| a.mode), &self.config.features)?;
+            .to_api_provider(auth.as_ref().map(|a| a.mode))?;
         let api_auth = auth_provider_from_auth(auth.clone(), &self.provider).await?;
         let transport = ReqwestTransport::new(build_reqwest_client());
         let request_telemetry = self.build_request_telemetry();

codex-rs/core/src/config/mod.rs

@@ -3090,7 +3090,6 @@ model_verbosity = "high"
             base_url: Some("https://api.openai.com/v1".to_string()),
             env_key: Some("OPENAI_API_KEY".to_string()),
             wire_api: crate::WireApi::Chat,
-            request_compression: crate::RequestCompression::None,
             env_key_instructions: None,
             experimental_bearer_token: None,
             query_params: None,

codex-rs/core/src/lib.rs

@@ -56,7 +56,6 @@ pub use model_provider_info::DEFAULT_OLLAMA_PORT;
 pub use model_provider_info::LMSTUDIO_OSS_PROVIDER_ID;
 pub use model_provider_info::ModelProviderInfo;
 pub use model_provider_info::OLLAMA_OSS_PROVIDER_ID;
-pub use model_provider_info::RequestCompression;
 pub use model_provider_info::WireApi;
 pub use model_provider_info::built_in_model_providers;
 pub use model_provider_info::create_oss_provider_with_base_url;

codex-rs/core/src/model_provider_info.rs

@@ -49,15 +49,6 @@ pub enum WireApi {
     Chat,
 }
 
-/// Body compression to use for outbound requests.
-#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum RequestCompression {
-    #[default]
-    None,
-    Zstd,
-}
-
 /// Serializable representation of a provider definition.
 #[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
 pub struct ModelProviderInfo {
@@ -81,10 +72,6 @@ pub struct ModelProviderInfo {
     #[serde(default)]
     pub wire_api: WireApi,
 
-    /// Compression applied to request bodies.
-    #[serde(default)]
-    pub request_compression: RequestCompression,
-
     /// Optional query parameters to append to the base URL.
     pub query_params: Option<HashMap<String, String>>,
 
@@ -145,7 +132,6 @@ impl ModelProviderInfo {
     pub(crate) fn to_api_provider(
         &self,
         auth_mode: Option<AuthMode>,
-        features: &Features,
     ) -> crate::error::Result<ApiProvider> {
         let default_base_url = if matches!(auth_mode, Some(AuthMode::ChatGPT)) {
             "https://chatgpt.com/backend-api/codex"
@@ -176,10 +162,6 @@ impl ModelProviderInfo {
             },
             headers,
             retry,
-            request_compression: match self.request_compression_for(auth_mode, features) {
-                RequestCompression::None => codex_api::provider::RequestCompression::None,
-                RequestCompression::Zstd => codex_api::provider::RequestCompression::Zstd,
-            },
             stream_idle_timeout: self.stream_idle_timeout(),
         })
     }
@@ -245,7 +227,6 @@ impl ModelProviderInfo {
             env_key_instructions: None,
             experimental_bearer_token: None,
             wire_api: WireApi::Responses,
-            request_compression: RequestCompression::None,
             query_params: None,
             http_headers: Some(
                 [("version".to_string(), env!("CARGO_PKG_VERSION").to_string())]
@@ -279,14 +260,14 @@ impl ModelProviderInfo {
         &self,
         auth_mode: Option<AuthMode>,
         features: &Features,
-    ) -> RequestCompression {
+    ) -> codex_api::provider::RequestCompression {
         if self.is_openai()
             && matches!(auth_mode, Some(AuthMode::ChatGPT))
             && features.enabled(Feature::RequestCompression)
         {
-            RequestCompression::Zstd
+            codex_api::provider::RequestCompression::Zstd
         } else {
-            RequestCompression::None
+            codex_api::provider::RequestCompression::None
         }
     }
 }
@@ -349,7 +330,6 @@ pub fn create_oss_provider_with_base_url(base_url: &str, wire_api: WireApi) -> M
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -378,7 +358,6 @@ base_url = "http://localhost:11434/v1"
             env_key_instructions: None,
             experimental_bearer_token: None,
             wire_api: WireApi::Chat,
-            request_compression: RequestCompression::None,
             query_params: None,
             http_headers: None,
             env_http_headers: None,
@@ -407,7 +386,6 @@ query_params = { api-version = "2025-04-01-preview" }
             env_key_instructions: None,
             experimental_bearer_token: None,
             wire_api: WireApi::Chat,
-            request_compression: RequestCompression::None,
             query_params: Some(maplit::hashmap! {
                 "api-version".to_string() => "2025-04-01-preview".to_string(),
             }),
@@ -439,7 +417,6 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
             env_key_instructions: None,
             experimental_bearer_token: None,
             wire_api: WireApi::Chat,
-            request_compression: RequestCompression::None,
             query_params: None,
             http_headers: Some(maplit::hashmap! {
                 "X-Example-Header".to_string() => "example-value".to_string(),
@@ -475,7 +452,6 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
                 env_key_instructions: None,
                 experimental_bearer_token: None,
                 wire_api: WireApi::Responses,
-                request_compression: RequestCompression::None,
                 query_params: None,
                 http_headers: None,
                 env_http_headers: None,
@@ -484,9 +460,7 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
                 stream_idle_timeout_ms: None,
                 requires_openai_auth: false,
             };
-            let api = provider
-                .to_api_provider(None, &Features::with_defaults())
-                .expect("api provider");
+            let api = provider.to_api_provider(None).expect("api provider");
             assert!(
                 api.is_azure_responses_endpoint(),
                 "expected {base_url} to be detected as Azure"
@@ -500,7 +474,6 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
             env_key_instructions: None,
             experimental_bearer_token: None,
             wire_api: WireApi::Responses,
-            request_compression: RequestCompression::None,
             query_params: None,
             http_headers: None,
             env_http_headers: None,
@@ -509,9 +482,7 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
             stream_idle_timeout_ms: None,
             requires_openai_auth: false,
         };
-        let named_api = named_provider
-            .to_api_provider(None, &Features::with_defaults())
-            .expect("api provider");
+        let named_api = named_provider.to_api_provider(None).expect("api provider");
         assert!(named_api.is_azure_responses_endpoint());
 
         let negative_cases = [
@@ -527,7 +498,6 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
                 env_key_instructions: None,
                 experimental_bearer_token: None,
                 wire_api: WireApi::Responses,
-                request_compression: RequestCompression::None,
                 query_params: None,
                 http_headers: None,
                 env_http_headers: None,
@@ -536,9 +506,7 @@ env_http_headers = { "X-Example-Env-Header" = "EXAMPLE_ENV_VAR" }
                 stream_idle_timeout_ms: None,
                 requires_openai_auth: false,
             };
-            let api = provider
-                .to_api_provider(None, &Features::with_defaults())
-                .expect("api provider");
+            let api = provider.to_api_provider(None).expect("api provider");
             assert!(
                 !api.is_azure_responses_endpoint(),
                 "expected {base_url} not to be detected as Azure"

codex-rs/core/src/models_manager/manager.rs

@@ -98,9 +98,7 @@ impl ModelsManager {
             return Ok(());
         }
         let auth = self.auth_manager.auth();
-        let api_provider = self
-            .provider
-            .to_api_provider(Some(AuthMode::ChatGPT), &config.features)?;
+        let api_provider = self.provider.to_api_provider(Some(AuthMode::ChatGPT))?;
         let api_auth = auth_provider_from_auth(auth.clone(), &self.provider).await?;
         let transport = ReqwestTransport::new(build_reqwest_client());
         let client = ModelsClient::new(transport, api_provider, api_auth);
@@ -327,7 +325,6 @@ mod tests {
     use super::cache::ModelsCache;
     use super::*;
     use crate::CodexAuth;
-    use crate::RequestCompression;
     use crate::auth::AuthCredentialsStoreMode;
     use crate::config::ConfigBuilder;
     use crate::features::Feature;
@@ -382,7 +379,6 @@ mod tests {
             env_key_instructions: None,
             experimental_bearer_token: None,
             wire_api: WireApi::Responses,
-            request_compression: RequestCompression::None,
             query_params: None,
             http_headers: None,
             env_http_headers: None,

codex-rs/core/tests/chat_completions_payload.rs

@@ -10,7 +10,6 @@ use codex_core::LocalShellStatus;
 use codex_core::ModelClient;
 use codex_core::ModelProviderInfo;
 use codex_core::Prompt;
-use codex_core::RequestCompression;
 use codex_core::ResponseItem;
 use codex_core::WireApi;
 use codex_core::models_manager::manager::ModelsManager;
@@ -53,7 +52,6 @@ async fn run_request(input: Vec<ResponseItem>) -> Value {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Chat,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,

codex-rs/core/tests/chat_completions_sse.rs

@@ -8,7 +8,6 @@ use codex_core::ContentItem;
 use codex_core::ModelClient;
 use codex_core::ModelProviderInfo;
 use codex_core::Prompt;
-use codex_core::RequestCompression;
 use codex_core::ResponseEvent;
 use codex_core::ResponseItem;
 use codex_core::WireApi;
@@ -52,7 +51,6 @@ async fn run_stream_with_bytes(sse_body: &[u8]) -> Vec<ResponseEvent> {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Chat,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,

codex-rs/core/tests/responses_headers.rs

@@ -7,7 +7,6 @@ use codex_core::ContentItem;
 use codex_core::ModelClient;
 use codex_core::ModelProviderInfo;
 use codex_core::Prompt;
-use codex_core::RequestCompression;
 use codex_core::ResponseEvent;
 use codex_core::ResponseItem;
 use codex_core::WireApi;
@@ -48,7 +47,6 @@ async fn responses_stream_includes_subagent_header_on_review() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -143,7 +141,6 @@ async fn responses_stream_includes_subagent_header_on_other() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -234,7 +231,6 @@ async fn responses_respects_model_family_overrides_from_config() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -342,7 +338,6 @@ async fn responses_request_body_is_zstd_encoded() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -440,7 +435,6 @@ async fn responses_request_body_is_uncompressed_when_disabled() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,

codex-rs/core/tests/suite/client.rs

@@ -9,7 +9,6 @@ use codex_core::ModelClient;
 use codex_core::ModelProviderInfo;
 use codex_core::NewConversation;
 use codex_core::Prompt;
-use codex_core::RequestCompression;
 use codex_core::ResponseEvent;
 use codex_core::ResponseItem;
 use codex_core::WireApi;
@@ -1127,7 +1126,6 @@ async fn azure_responses_request_includes_store_and_reasoning_ids() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,
@@ -1626,7 +1624,6 @@ async fn azure_overrides_assign_properties_used_for_responses_url() {
         )])),
         env_key_instructions: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         http_headers: Some(std::collections::HashMap::from([(
             "Custom-Header".to_string(),
             "Value".to_string(),
@@ -1710,7 +1707,6 @@ async fn env_var_overrides_loaded_auth() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         http_headers: Some(std::collections::HashMap::from([(
             "Custom-Header".to_string(),
             "Value".to_string(),

codex-rs/core/tests/suite/stream_error_allows_next_turn.rs

@@ -1,5 +1,4 @@
 use codex_core::ModelProviderInfo;
-use codex_core::RequestCompression;
 use codex_core::WireApi;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::Op;
@@ -67,7 +66,6 @@ async fn continue_after_stream_error() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,

codex-rs/core/tests/suite/stream_no_completed.rs

@@ -2,7 +2,6 @@
 //! delivering a `response.completed` event.
 
 use codex_core::ModelProviderInfo;
-use codex_core::RequestCompression;
 use codex_core::WireApi;
 use codex_core::protocol::EventMsg;
 use codex_core::protocol::Op;
@@ -74,7 +73,6 @@ async fn retries_on_early_close() {
         env_key_instructions: None,
         experimental_bearer_token: None,
         wire_api: WireApi::Responses,
-        request_compression: RequestCompression::None,
         query_params: None,
         http_headers: None,
         env_http_headers: None,