Always use AVAS for realtime WebRTC calls (#28856)

## Summary

- Remove the realtime `architecture` selector from core protocol,
app-server protocol, config parsing, generated schemas, and callers.
- Always create WebRTC realtime calls with the AVAS query params:
`intent=quicksilver&architecture=avas`.
- Keep direct websocket realtime behavior on the existing config/default
path, while WebRTC starts without an explicit version now default to
realtime v1 because AVAS requires v1.

## Notes

- WebRTC realtime now means AVAS. If a caller explicitly asks to start
WebRTC with realtime v2, Codex rejects that request because the AVAS
WebRTC path only supports realtime v1. Websocket realtime is separate
and can still use realtime v2.
- The old `[realtime] architecture = "realtimeapi" | "avas"` config knob
is removed. Local configs that still set it will need to delete that
line.
- Some app-server tests that were only trying to exercise realtime v2
protocol behavior now use websocket transport, because WebRTC is
intentionally locked to AVAS/v1. Separate WebRTC tests cover the AVAS
query params, v1 startup, SDP flow, and sideband join.

## Validation

- Merged fresh `origin/main` at `83e6a786a2`.
- `just fmt`
- `just write-config-schema`
- `just write-app-server-schema`
- `git diff --check`
- `just test -p codex-api -p codex-core -p codex-app-server-protocol -p
codex-app-server realtime` (176 passed)
- `just test -p codex-protocol -p codex-config` (413 passed)

codex-rs/core/src/client.rs

@@ -77,7 +77,6 @@ use codex_protocol::models::ResponseItem;
 use codex_protocol::openai_models::ModelInfo;
 use codex_protocol::openai_models::ReasoningEffort as ReasoningEffortConfig;
 use codex_protocol::protocol::InternalSessionSource;
-use codex_protocol::protocol::RealtimeConversationArchitecture;
 use codex_protocol::protocol::SessionSource;
 use codex_protocol::protocol::W3cTraceContext;
 use codex_rollout_trace::CompactionTraceContext;
@@ -583,7 +582,6 @@ impl ModelClient {
         &self,
         sdp: String,
         session_config: ApiRealtimeSessionConfig,
-        architecture: RealtimeConversationArchitecture,
         mut extra_headers: ApiHeaderMap,
         api_provider_override: Option<ApiProvider>,
     ) -> Result<RealtimeWebrtcCallStart> {
@@ -600,12 +598,7 @@ impl ModelClient {
         let transport = ReqwestTransport::new(build_reqwest_client());
         let api_provider = api_provider_override.unwrap_or(client_setup.api_provider);
         let response = ApiRealtimeCallClient::new(transport, api_provider, client_setup.api_auth)
-            .create_with_session_architecture_and_headers(
-                sdp,
-                session_config,
-                architecture,
-                extra_headers,
-            )
+            .create_with_session_and_headers(sdp, session_config, extra_headers)
             .await
             .map_err(map_api_error)?;
         Ok(RealtimeWebrtcCallStart {

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

@@ -14,7 +14,6 @@ use codex_config::config_toml::AutoReviewToml;
 use codex_config::config_toml::ConfigToml;
 use codex_config::config_toml::ExperimentalRequestUserInput;
 use codex_config::config_toml::ProjectConfig;
-use codex_config::config_toml::RealtimeArchitecture;
 use codex_config::config_toml::RealtimeConfig;
 use codex_config::config_toml::RealtimeToml;
 use codex_config::config_toml::RealtimeTransport;
@@ -10896,7 +10895,6 @@ async fn realtime_loads_from_config_toml() -> std::io::Result<()> {
     let cfg: ConfigToml = toml::from_str(
         r#"
 [realtime]
-architecture = "avas"
 version = "v2"
 type = "transcription"
 transport = "webrtc"
@@ -10908,7 +10906,6 @@ voice = "cedar"
     assert_eq!(
         cfg.realtime,
         Some(RealtimeToml {
-            architecture: Some(RealtimeArchitecture::Avas),
             version: Some(RealtimeWsVersion::V2),
             session_type: Some(RealtimeWsMode::Transcription),
             transport: Some(RealtimeTransport::WebRtc),
@@ -10927,7 +10924,6 @@ voice = "cedar"
     assert_eq!(
         config.realtime,
         RealtimeConfig {
-            architecture: RealtimeArchitecture::Avas,
             version: RealtimeWsVersion::V2,
             session_type: RealtimeWsMode::Transcription,
             transport: RealtimeTransport::WebRtc,

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

@@ -3792,7 +3792,6 @@ impl Config {
                 .map_or_else(RealtimeConfig::default, |realtime| {
                     let defaults = RealtimeConfig::default();
                     RealtimeConfig {
-                        architecture: realtime.architecture.unwrap_or(defaults.architecture),
                         version: realtime.version.unwrap_or(defaults.version),
                         session_type: realtime.session_type.unwrap_or(defaults.session_type),
                         transport: realtime.transport.unwrap_or(defaults.transport),

codex-rs/core/src/realtime_conversation.rs

@@ -41,7 +41,6 @@ use codex_protocol::protocol::ConversationTextRole;
 use codex_protocol::protocol::ErrorEvent;
 use codex_protocol::protocol::Event;
 use codex_protocol::protocol::EventMsg;
-use codex_protocol::protocol::RealtimeConversationArchitecture;
 use codex_protocol::protocol::RealtimeConversationClosedEvent;
 use codex_protocol::protocol::RealtimeConversationRealtimeEvent;
 use codex_protocol::protocol::RealtimeConversationSdpEvent;
@@ -246,7 +245,6 @@ struct ConversationState {
 
 struct RealtimeStart {
     api_provider: ApiProvider,
-    architecture: RealtimeConversationArchitecture,
     extra_headers: Option<HeaderMap>,
     client_managed_handoffs: bool,
     codex_responses_as_items: bool,
@@ -304,7 +302,6 @@ impl RealtimeConversationManager {
     async fn start_inner(&self, start: RealtimeStart) -> CodexResult<RealtimeStartOutput> {
         let RealtimeStart {
             api_provider,
-            architecture,
             extra_headers,
             client_managed_handoffs,
             codex_responses_as_items,
@@ -351,7 +348,6 @@ impl RealtimeConversationManager {
                 .create_realtime_call_with_headers(
                     sdp,
                     session_config.clone(),
-                    architecture,
                     extra_headers.unwrap_or_default(),
                     realtime_call_api_provider,
                 )
@@ -717,7 +713,6 @@ pub(crate) async fn handle_start(
 
 struct PreparedRealtimeConversationStart {
     api_provider: ApiProvider,
-    architecture: RealtimeConversationArchitecture,
     extra_headers: Option<HeaderMap>,
     client_managed_handoffs: bool,
     codex_responses_as_items: bool,
@@ -730,6 +725,12 @@ struct PreparedRealtimeConversationStart {
     transport: ConversationStartTransport,
 }
 
+#[derive(Clone, Copy)]
+pub(crate) enum ConfiguredRealtimeVoice {
+    Use,
+    Ignore,
+}
+
 async fn prepare_realtime_start(
     sess: &Arc<Session>,
     params: ConversationStartParams,
@@ -758,16 +759,21 @@ async fn prepare_realtime_start(
         } else {
             None
         };
-    let version = params.version.unwrap_or(config.realtime.version);
-    // TODO(pbakkum): Remove the realtimeapi/AVAS branch once WebRTC realtime sessions always use AVAS.
-    let architecture = params.architecture.unwrap_or(config.realtime.architecture);
-    validate_realtime_architecture(
-        architecture,
-        version,
-        &transport,
-        config.realtime.session_type,
-    )?;
-    let session_config = build_realtime_session_config(sess, &params, version).await?;
+    let version = params.version.unwrap_or(match &transport {
+        ConversationStartTransport::Websocket => config.realtime.version,
+        ConversationStartTransport::Webrtc { .. } => RealtimeWsVersion::V1,
+    });
+    if matches!(transport, ConversationStartTransport::Webrtc { .. }) {
+        validate_avas_webrtc_start(version, config.realtime.session_type)?;
+    }
+    let configured_voice = match (&transport, params.version) {
+        (ConversationStartTransport::Webrtc { .. }, None) => ConfiguredRealtimeVoice::Ignore,
+        (ConversationStartTransport::Webrtc { .. } | ConversationStartTransport::Websocket, _) => {
+            ConfiguredRealtimeVoice::Use
+        }
+    };
+    let session_config =
+        build_realtime_session_config(sess, &params, version, configured_voice).await?;
     let requested_realtime_session_id = session_config.session_id.clone();
     let extra_headers = match transport {
         ConversationStartTransport::Websocket => {
@@ -788,7 +794,6 @@ async fn prepare_realtime_start(
     };
     Ok(PreparedRealtimeConversationStart {
         api_provider,
-        architecture,
         extra_headers,
         client_managed_handoffs: params.client_managed_handoffs,
         codex_responses_as_items: params.codex_responses_as_items,
@@ -802,28 +807,18 @@ async fn prepare_realtime_start(
     })
 }
 
-fn validate_realtime_architecture(
-    architecture: RealtimeConversationArchitecture,
+fn validate_avas_webrtc_start(
     version: RealtimeWsVersion,
-    transport: &ConversationStartTransport,
     session_type: RealtimeWsMode,
 ) -> CodexResult<()> {
-    if architecture != RealtimeConversationArchitecture::Avas {
-        return Ok(());
-    }
     if version != RealtimeWsVersion::V1 {
         return Err(CodexErr::InvalidRequest(
-            "AVAS realtime architecture requires realtime v1".to_string(),
-        ));
-    }
-    if !matches!(transport, ConversationStartTransport::Webrtc { .. }) {
-        return Err(CodexErr::InvalidRequest(
-            "AVAS realtime architecture requires WebRTC transport".to_string(),
+            "AVAS realtime calls require realtime v1".to_string(),
         ));
     }
     if session_type != RealtimeWsMode::Conversational {
         return Err(CodexErr::InvalidRequest(
-            "AVAS realtime architecture requires conversational realtime".to_string(),
+            "AVAS realtime calls require conversational realtime".to_string(),
         ));
     }
     Ok(())
@@ -833,6 +828,7 @@ pub(crate) async fn build_realtime_session_config(
     sess: &Arc<Session>,
     params: &ConversationStartParams,
     version: RealtimeWsVersion,
+    configured_voice: ConfiguredRealtimeVoice,
 ) -> CodexResult<RealtimeSessionConfig> {
     let config = sess.get_config().await;
     let prompt = prepare_realtime_backend_prompt(
@@ -879,9 +875,13 @@ pub(crate) async fn build_realtime_session_config(
         RealtimeWsMode::Conversational => RealtimeSessionMode::Conversational,
         RealtimeWsMode::Transcription => RealtimeSessionMode::Transcription,
     };
+    let config_voice = match configured_voice {
+        ConfiguredRealtimeVoice::Use => config.realtime.voice,
+        ConfiguredRealtimeVoice::Ignore => None,
+    };
     let voice = params
         .voice
-        .or(config.realtime.voice)
+        .or(config_voice)
         .unwrap_or_else(|| default_realtime_voice(version));
     validate_realtime_voice(version, voice)?;
     Ok(RealtimeSessionConfig {
@@ -960,7 +960,6 @@ async fn handle_start_inner(
 ) -> CodexResult<()> {
     let PreparedRealtimeConversationStart {
         api_provider,
-        architecture,
         extra_headers,
         client_managed_handoffs,
         codex_responses_as_items,
@@ -979,7 +978,6 @@ async fn handle_start_inner(
     };
     let start = RealtimeStart {
         api_provider,
-        architecture,
         extra_headers,
         client_managed_handoffs,
         codex_responses_as_items,