feat: drop wire_api from clients (#10498)

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

@@ -3,7 +3,6 @@ use crate::auth::add_auth_headers;
 use crate::common::CompactionInput;
 use crate::error::ApiError;
 use crate::provider::Provider;
-use crate::provider::WireApi;
 use crate::telemetry::run_with_request_telemetry;
 use codex_client::HttpTransport;
 use codex_client::RequestTelemetry;
@@ -37,9 +36,7 @@ impl<T: HttpTransport, A: AuthProvider> CompactClient<T, A> {
     }
 
     fn path(&self) -> &'static str {
-        match self.provider.wire {
-            WireApi::Compact | WireApi::Responses => "responses/compact",
-        }
+        "responses/compact"
     }
 
     pub async fn compact(
@@ -118,12 +115,11 @@ mod tests {
         }
     }
 
-    fn provider(wire: WireApi) -> Provider {
+    fn provider() -> Provider {
         Provider {
             name: "test".to_string(),
             base_url: "https://example.com/v1".to_string(),
             query_params: None,
-            wire,
             headers: HeaderMap::new(),
             retry: RetryConfig {
                 max_attempts: 1,
@@ -137,13 +133,8 @@ mod tests {
     }
 
     #[test]
-    fn path_is_responses_compact_for_supported_wire_apis() {
-        let responses_client =
-            CompactClient::new(DummyTransport, provider(WireApi::Responses), DummyAuth);
-        assert_eq!(responses_client.path(), "responses/compact");
-
-        let compact_client =
-            CompactClient::new(DummyTransport, provider(WireApi::Compact), DummyAuth);
-        assert_eq!(compact_client.path(), "responses/compact");
+    fn path_is_responses_compact() {
+        let client = CompactClient::new(DummyTransport, provider(), DummyAuth);
+        assert_eq!(client.path(), "responses/compact");
     }
 }

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

@@ -83,7 +83,6 @@ impl<T: HttpTransport, A: AuthProvider> ModelsClient<T, A> {
 mod tests {
     use super::*;
     use crate::provider::RetryConfig;
-    use crate::provider::WireApi;
     use async_trait::async_trait;
     use codex_client::Request;
     use codex_client::Response;
@@ -149,7 +148,6 @@ mod tests {
             name: "test".to_string(),
             base_url: base_url.to_string(),
             query_params: None,
-            wire: WireApi::Responses,
             headers: HeaderMap::new(),
             retry: RetryConfig {
                 max_attempts: 1,

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

@@ -6,7 +6,6 @@ use crate::common::TextControls;
 use crate::endpoint::streaming::StreamingClient;
 use crate::error::ApiError;
 use crate::provider::Provider;
-use crate::provider::WireApi;
 use crate::requests::ResponsesRequest;
 use crate::requests::ResponsesRequestBuilder;
 use crate::requests::responses::Compression;
@@ -109,9 +108,7 @@ impl<T: HttpTransport, A: AuthProvider> ResponsesClient<T, A> {
     }
 
     fn path(&self) -> &'static str {
-        match self.streaming.provider().wire {
-            WireApi::Responses | WireApi::Compact => "responses",
-        }
+        "responses"
     }
 
     pub async fn stream(

codex-rs/codex-api/src/lib.rs

@@ -31,7 +31,6 @@ pub use crate::endpoint::responses_websocket::ResponsesWebsocketClient;
 pub use crate::endpoint::responses_websocket::ResponsesWebsocketConnection;
 pub use crate::error::ApiError;
 pub use crate::provider::Provider;
-pub use crate::provider::WireApi;
 pub use crate::provider::is_azure_responses_wire_base_url;
 pub use crate::requests::ResponsesRequest;
 pub use crate::requests::ResponsesRequestBuilder;

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

@@ -8,13 +8,6 @@ use std::collections::HashMap;
 use std::time::Duration;
 use url::Url;
 
-/// Wire-level APIs supported by a `Provider`.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum WireApi {
-    Responses,
-    Compact,
-}
-
 /// High-level retry configuration for a provider.
 ///
 /// This is converted into a `RetryPolicy` used by `codex-client` to drive
@@ -51,7 +44,6 @@ pub struct Provider {
     pub name: String,
     pub base_url: String,
     pub query_params: Option<HashMap<String, String>>,
-    pub wire: WireApi,
     pub headers: HeaderMap,
     pub retry: RetryConfig,
     pub stream_idle_timeout: Duration,
@@ -94,7 +86,7 @@ impl Provider {
     }
 
     pub fn is_azure_responses_endpoint(&self) -> bool {
-        is_azure_responses_wire_base_url(self.wire.clone(), &self.name, Some(&self.base_url))
+        is_azure_responses_wire_base_url(&self.name, Some(&self.base_url))
     }
 
     pub fn websocket_url_for_path(&self, path: &str) -> Result<Url, url::ParseError> {
@@ -111,11 +103,7 @@ impl Provider {
     }
 }
 
-pub fn is_azure_responses_wire_base_url(wire: WireApi, name: &str, base_url: Option<&str>) -> bool {
-    if wire != WireApi::Responses {
-        return false;
-    }
-
+pub fn is_azure_responses_wire_base_url(name: &str, base_url: Option<&str>) -> bool {
     if name.eq_ignore_ascii_case("azure") {
         return true;
     }
@@ -156,13 +144,12 @@ mod tests {
 
         for base_url in positive_cases {
             assert!(
-                is_azure_responses_wire_base_url(WireApi::Responses, "test", Some(base_url)),
+                is_azure_responses_wire_base_url("test", Some(base_url)),
                 "expected {base_url} to be detected as Azure"
             );
         }
 
         assert!(is_azure_responses_wire_base_url(
-            WireApi::Responses,
             "Azure",
             Some("https://example.com")
         ));
@@ -175,15 +162,9 @@ mod tests {
 
         for base_url in negative_cases {
             assert!(
-                !is_azure_responses_wire_base_url(WireApi::Responses, "test", Some(base_url)),
+                !is_azure_responses_wire_base_url("test", Some(base_url)),
                 "expected {base_url} not to be detected as Azure"
             );
         }
-
-        assert!(!is_azure_responses_wire_base_url(
-            WireApi::Compact,
-            "Azure",
-            Some("https://foo.openai.azure.com/openai")
-        ));
     }
 }

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

@@ -191,7 +191,6 @@ fn attach_item_ids(payload_json: &mut Value, original_items: &[ResponseItem]) {
 mod tests {
     use super::*;
     use crate::provider::RetryConfig;
-    use crate::provider::WireApi;
     use codex_protocol::protocol::SubAgentSource;
     use http::HeaderValue;
     use pretty_assertions::assert_eq;
@@ -202,7 +201,6 @@ mod tests {
             name: name.to_string(),
             base_url: base_url.to_string(),
             query_params: None,
-            wire: WireApi::Responses,
             headers: HeaderMap::new(),
             retry: RetryConfig {
                 max_attempts: 1,

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

@@ -9,7 +9,6 @@ use codex_api::AuthProvider;
 use codex_api::Provider;
 use codex_api::ResponsesClient;
 use codex_api::ResponsesOptions;
-use codex_api::WireApi;
 use codex_api::requests::responses::Compression;
 use codex_client::HttpTransport;
 use codex_client::Request;
@@ -118,12 +117,11 @@ impl AuthProvider for StaticAuth {
     }
 }
 
-fn provider(name: &str, wire: WireApi) -> Provider {
+fn provider(name: &str) -> Provider {
     Provider {
         name: name.to_string(),
         base_url: "https://example.com/v1".to_string(),
         query_params: None,
-        wire,
         headers: HeaderMap::new(),
         retry: codex_api::provider::RetryConfig {
             max_attempts: 1,
@@ -195,26 +193,10 @@ data: {"id":"resp-1","output":[{"type":"message","role":"assistant","content":[{
 }
 
 #[tokio::test]
-async fn responses_client_uses_responses_path_for_responses_wire() -> Result<()> {
+async fn responses_client_uses_responses_path() -> Result<()> {
     let state = RecordingState::default();
     let transport = RecordingTransport::new(state.clone());
-    let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
-
-    let body = serde_json::json!({ "echo": true });
-    let _stream = client
-        .stream(body, HeaderMap::new(), Compression::None, None)
-        .await?;
-
-    let requests = state.take_stream_requests();
-    assert_path_ends_with(&requests, "/responses");
-    Ok(())
-}
-
-#[tokio::test]
-async fn responses_client_uses_responses_path_for_compact_wire() -> Result<()> {
-    let state = RecordingState::default();
-    let transport = RecordingTransport::new(state.clone());
-    let client = ResponsesClient::new(transport, provider("openai", WireApi::Compact), NoAuth);
+    let client = ResponsesClient::new(transport, provider("openai"), NoAuth);
 
     let body = serde_json::json!({ "echo": true });
     let _stream = client
@@ -231,7 +213,7 @@ async fn streaming_client_adds_auth_headers() -> Result<()> {
     let state = RecordingState::default();
     let transport = RecordingTransport::new(state.clone());
     let auth = StaticAuth::new("secret-token", "acct-1");
-    let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), auth);
+    let client = ResponsesClient::new(transport, provider("openai"), auth);
 
     let body = serde_json::json!({ "model": "gpt-test" });
     let _stream = client
@@ -266,7 +248,7 @@ async fn streaming_client_adds_auth_headers() -> Result<()> {
 async fn streaming_client_retries_on_transport_error() -> Result<()> {
     let transport = FlakyTransport::new();
 
-    let mut provider = provider("openai", WireApi::Responses);
+    let mut provider = provider("openai");
     provider.retry.max_attempts = 2;
 
     let client = ResponsesClient::new(transport.clone(), provider, NoAuth);

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

@@ -2,7 +2,6 @@ use codex_api::AuthProvider;
 use codex_api::ModelsClient;
 use codex_api::provider::Provider;
 use codex_api::provider::RetryConfig;
-use codex_api::provider::WireApi;
 use codex_client::ReqwestTransport;
 use codex_protocol::openai_models::ConfigShellToolType;
 use codex_protocol::openai_models::ModelInfo;
@@ -34,7 +33,6 @@ fn provider(base_url: &str) -> Provider {
         name: "test".to_string(),
         base_url: base_url.to_string(),
         query_params: None,
-        wire: WireApi::Responses,
         headers: HeaderMap::new(),
         retry: RetryConfig {
             max_attempts: 1,

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

@@ -8,7 +8,6 @@ use codex_api::AuthProvider;
 use codex_api::Provider;
 use codex_api::ResponseEvent;
 use codex_api::ResponsesClient;
-use codex_api::WireApi;
 use codex_api::requests::responses::Compression;
 use codex_client::HttpTransport;
 use codex_client::Request;
@@ -61,12 +60,11 @@ impl AuthProvider for NoAuth {
     }
 }
 
-fn provider(name: &str, wire: WireApi) -> Provider {
+fn provider(name: &str) -> Provider {
     Provider {
         name: name.to_string(),
         base_url: "https://example.com/v1".to_string(),
         query_params: None,
-        wire,
         headers: HeaderMap::new(),
         retry: codex_api::provider::RetryConfig {
             max_attempts: 1,
@@ -122,7 +120,7 @@ async fn responses_stream_parses_items_and_completed_end_to_end() -> Result<()>
 
     let body = build_responses_body(vec![item1, item2, completed]);
     let transport = FixtureSseTransport::new(body);
-    let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
+    let client = ResponsesClient::new(transport, provider("openai"), NoAuth);
 
     let mut stream = client
         .stream(
@@ -192,7 +190,7 @@ async fn responses_stream_aggregates_output_text_deltas() -> Result<()> {
 
     let body = build_responses_body(vec![delta1, delta2, completed]);
     let transport = FixtureSseTransport::new(body);
-    let client = ResponsesClient::new(transport, provider("openai", WireApi::Responses), NoAuth);
+    let client = ResponsesClient::new(transport, provider("openai"), NoAuth);
 
     let stream = client
         .stream(

codex-rs/core/src/model_provider_info.rs

@@ -8,7 +8,6 @@
 use crate::auth::AuthMode;
 use crate::error::EnvVarError;
 use codex_api::Provider as ApiProvider;
-use codex_api::WireApi as ApiWireApi;
 use codex_api::is_azure_responses_wire_base_url;
 use codex_api::provider::RetryConfig as ApiRetryConfig;
 use http::HeaderMap;
@@ -169,9 +168,6 @@ impl ModelProviderInfo {
             name: self.name.clone(),
             base_url,
             query_params: self.query_params.clone(),
-            wire: match self.wire_api {
-                WireApi::Responses => ApiWireApi::Responses,
-            },
             headers,
             retry,
             stream_idle_timeout: self.stream_idle_timeout(),
@@ -179,11 +175,7 @@ impl ModelProviderInfo {
     }
 
     pub(crate) fn is_azure_responses_endpoint(&self) -> bool {
-        is_azure_responses_wire_base_url(
-            ApiWireApi::Responses,
-            &self.name,
-            self.base_url.as_deref(),
-        )
+        is_azure_responses_wire_base_url(&self.name, self.base_url.as_deref())
     }
 
     /// If `env_key` is Some, returns the API key for this provider if present