codex: clarify realtime WebRTC sideband names

codex-rs/codex-api/src/endpoint/realtime_websocket/methods.rs

@@ -465,11 +465,11 @@ impl RealtimeWebsocketClient {
             config.event_parser,
             config.session_mode,
         )?;
-        self.connect_url(ws_url, config, extra_headers, default_headers)
+        self.connect_realtime_websocket_url(ws_url, config, extra_headers, default_headers)
             .await
     }
 
-    pub async fn connect_call_id(
+    pub async fn connect_webrtc_sideband(
         &self,
         config: RealtimeSessionConfig,
         call_id: &str,
@@ -478,7 +478,7 @@ impl RealtimeWebsocketClient {
     ) -> Result<RealtimeWebsocketConnection, ApiError> {
         for attempt in 0..=self.provider.retry.max_attempts {
             let result = self
-                .connect_call_id_once(
+                .connect_webrtc_sideband_once(
                     config.clone(),
                     call_id,
                     extra_headers.clone(),
@@ -506,7 +506,7 @@ impl RealtimeWebsocketClient {
         ))
     }
 
-    async fn connect_call_id_once(
+    async fn connect_webrtc_sideband_once(
         &self,
         config: RealtimeSessionConfig,
         call_id: &str,
@@ -518,11 +518,11 @@ impl RealtimeWebsocketClient {
             self.provider.query_params.as_ref(),
             call_id,
         )?;
-        self.connect_url(ws_url, config, extra_headers, default_headers)
+        self.connect_realtime_websocket_url(ws_url, config, extra_headers, default_headers)
             .await
     }
 
-    async fn connect_url(
+    async fn connect_realtime_websocket_url(
         &self,
         ws_url: Url,
         config: RealtimeSessionConfig,

codex-rs/codex-api/tests/realtime_websocket_e2e.rs

@@ -196,7 +196,7 @@ async fn realtime_ws_e2e_session_create_and_event_flow() {
 }
 
 #[tokio::test]
-async fn realtime_ws_connect_call_id_retries_join_until_server_is_available() {
+async fn realtime_ws_connect_webrtc_sideband_retries_join_until_server_is_available() {
     let reserving_listener = TcpListener::bind("127.0.0.1:0").await.expect("bind");
     let addr = reserving_listener.local_addr().expect("local addr");
     drop(reserving_listener);
@@ -239,7 +239,7 @@ async fn realtime_ws_connect_call_id_retries_join_until_server_is_available() {
 
     let client = RealtimeWebsocketClient::new(provider);
     let connection = client
-        .connect_call_id(
+        .connect_webrtc_sideband(
             RealtimeSessionConfig {
                 instructions: "backend prompt".to_string(),
                 model: Some("realtime-test-model".to_string()),

codex-rs/core/src/client.rs

@@ -259,13 +259,13 @@ enum WebsocketStreamOutcome {
     FallbackToHttp,
 }
 
-pub(crate) struct RealtimeCallStart {
+pub(crate) struct RealtimeWebrtcCallStart {
     pub(crate) sdp: String,
     pub(crate) call_id: String,
     pub(crate) sideband_headers: ApiHeaderMap,
 }
 
-fn api_auth_headers(api_auth: &CoreAuthProvider) -> ApiHeaderMap {
+fn sideband_websocket_auth_headers(api_auth: &CoreAuthProvider) -> ApiHeaderMap {
     let mut headers = ApiHeaderMap::new();
     if let Some(token) = api_auth.token.as_ref()
         && let Ok(value) = HeaderValue::from_str(&format!("Bearer {token}"))
@@ -472,17 +472,17 @@ impl ModelClient {
         sdp: String,
         session_config: ApiRealtimeSessionConfig,
         extra_headers: ApiHeaderMap,
-    ) -> Result<RealtimeCallStart> {
+    ) -> Result<RealtimeWebrtcCallStart> {
         let client_setup = self.current_client_setup().await?;
         let mut sideband_headers = extra_headers.clone();
-        sideband_headers.extend(api_auth_headers(&client_setup.api_auth));
+        sideband_headers.extend(sideband_websocket_auth_headers(&client_setup.api_auth));
         let transport = ReqwestTransport::new(build_reqwest_client());
         let response =
             ApiRealtimeCallClient::new(transport, client_setup.api_provider, client_setup.api_auth)
                 .create_with_session_and_headers(sdp, session_config, extra_headers)
                 .await
                 .map_err(map_api_error)?;
-        Ok(RealtimeCallStart {
+        Ok(RealtimeWebrtcCallStart {
             sdp: response.sdp,
             call_id: response.call_id,
             sideband_headers,

codex-rs/core/src/realtime_conversation.rs

@@ -206,7 +206,7 @@ impl RealtimeConversationManager {
                 )
                 .await?;
             let connection = client
-                .connect_call_id(
+                .connect_webrtc_sideband(
                     session_config,
                     &call.call_id,
                     call.sideband_headers,