Use realtime call client auth setup

Co-authored-by: Codex <noreply@openai.com>

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

@@ -1,62 +0,0 @@
-use crate::auth::AuthProvider;
-use crate::endpoint::session::EndpointSession;
-use crate::error::ApiError;
-use crate::provider::Provider;
-use codex_client::HttpTransport;
-use codex_client::RequestTelemetry;
-use http::HeaderMap;
-use http::Method;
-use serde::Serialize;
-use serde_json::Value;
-use serde_json::to_value;
-use std::sync::Arc;
-use tracing::instrument;
-
-pub struct CodexBackendRealtimeCallClient<T: HttpTransport, A: AuthProvider> {
-    session: EndpointSession<T, A>,
-}
-
-#[derive(Serialize)]
-struct CodexBackendRealtimeCallRequest<'a> {
-    sdp: &'a str,
-    session: &'a Value,
-}
-
-impl<T: HttpTransport, A: AuthProvider> CodexBackendRealtimeCallClient<T, A> {
-    pub fn new(transport: T, provider: Provider, auth: A) -> Self {
-        Self {
-            session: EndpointSession::new(transport, provider, auth),
-        }
-    }
-
-    pub fn with_telemetry(self, request: Option<Arc<dyn RequestTelemetry>>) -> Self {
-        Self {
-            session: self.session.with_request_telemetry(request),
-        }
-    }
-
-    fn path() -> &'static str {
-        "api/codex/realtime/calls"
-    }
-
-    #[instrument(
-        name = "codex_backend_realtime_call.create",
-        level = "info",
-        skip_all,
-        fields(
-            http.method = "POST",
-            api.path = "api/codex/realtime/calls"
-        )
-    )]
-    pub async fn create(&self, sdp: &str, session: &Value) -> Result<String, ApiError> {
-        let body = to_value(CodexBackendRealtimeCallRequest { sdp, session })
-            .map_err(|err| ApiError::Stream(format!("failed to encode realtime call: {err}")))?;
-        let resp = self
-            .session
-            .execute(Method::POST, Self::path(), HeaderMap::new(), Some(body))
-            .await?;
-
-        String::from_utf8(resp.body.to_vec())
-            .map_err(|err| ApiError::Stream(format!("failed to decode realtime call SDP: {err}")))
-    }
-}

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

@@ -1,4 +1,3 @@
-pub mod codex_backend_realtime_call;
 pub mod compact;
 pub mod memories;
 pub mod models;

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

@@ -28,7 +28,6 @@ pub use crate::common::WS_REQUEST_HEADER_TRACEPARENT_CLIENT_METADATA_KEY;
 pub use crate::common::WS_REQUEST_HEADER_TRACESTATE_CLIENT_METADATA_KEY;
 pub use crate::common::create_text_param_for_request;
 pub use crate::common::response_create_client_metadata;
-pub use crate::endpoint::codex_backend_realtime_call::CodexBackendRealtimeCallClient;
 pub use crate::endpoint::compact::CompactClient;
 pub use crate::endpoint::memories::MemoriesClient;
 pub use crate::endpoint::models::ModelsClient;

codex-rs/core/src/client.rs

@@ -31,7 +31,6 @@ use std::sync::atomic::AtomicBool;
 use std::sync::atomic::AtomicU64;
 use std::sync::atomic::Ordering;
 
-use codex_api::CodexBackendRealtimeCallClient as ApiCodexBackendRealtimeCallClient;
 use codex_api::CompactClient as ApiCompactClient;
 use codex_api::CompactionInput as ApiCompactionInput;
 use codex_api::MemoriesClient as ApiMemoriesClient;
@@ -443,32 +442,12 @@ impl ModelClient {
         session: serde_json::Value,
     ) -> Result<String> {
         let client_setup = self.current_client_setup().await?;
-        let auth_mode = client_setup.auth.as_ref().map(CodexAuth::auth_mode);
         let transport = ReqwestTransport::new(build_reqwest_client());
-        match auth_mode {
-            Some(AuthMode::Chatgpt | AuthMode::ChatgptAuthTokens) => {
-                ApiCodexBackendRealtimeCallClient::new(
-                    transport,
-                    client_setup.api_provider,
-                    client_setup.api_auth,
-                )
-                .create(&sdp, &session)
-                .await
-                .map_err(map_api_error)
-            }
-            Some(AuthMode::ApiKey) => ApiRealtimeCallClient::new(
-                transport,
-                client_setup.api_provider,
-                client_setup.api_auth,
-            )
+        ApiRealtimeCallClient::new(transport, client_setup.api_provider, client_setup.api_auth)
             .create_with_session(sdp, session)
             .await
             .map(|response| response.sdp)
-            .map_err(map_api_error),
-            None => Err(CodexErr::InvalidRequest(
-                "codex account authentication required to create realtime call".to_string(),
-            )),
-        }
+            .map_err(map_api_error)
     }
 
     /// Builds memory summaries for each provided normalized raw memory.