Lightweight coding agent that runs in your terminal
Rust
Add local audio device selection to TUI voice settings (#49437)
Benjamin Carlssonfc81a7154bc6
diff --git a/codex-rs/realtime-webrtc/src/client.rs b/codex-rs/realtime-webrtc/src/client.rsindex ed2f50e37f..d6ef6af207 100644--- a/codex-rs/realtime-webrtc/src/client.rs+++ b/codex-rs/realtime-webrtc/src/client.rs@@ -12,6 +12,9 @@ use codex_utils_pty::SpawnedProcess;use tokio::sync::oneshot;use tokio::time::timeout;+use crate::AudioDevice;+use crate::AudioDeviceKind;+use crate::AudioDeviceSelection;use crate::HelperExitStage;use crate::Message;use crate::encode_frame;@@ -63,12 +66,27 @@ pub struct VoiceHost {impl VoiceHost {/// Open local devices only after answer negotiation. They initially remain muted/suppressed.- pub async fn open_devices(mut self) -> Result<Self> {- self.exchange(Message::OpenDevices {}, Message::DevicesOpened {}, DEADLINE)- .await?;+ pub async fn open_devices(mut self, selection: AudioDeviceSelection) -> Result<Self> {+ self.exchange(+ Message::OpenDevices { selection },+ Message::DevicesOpened {},+ DEADLINE,+ )+ .await?;Ok(self)}+ /// Enumerate local devices without opening streams.+ pub async fn list_devices(&mut self, kind: AudioDeviceKind) -> Result<Vec<AudioDevice>> {+ match self+ .request(Message::ListDevices { kind }, DEADLINE)+ .await?+ {+ Message::DeviceList { devices } => Ok(devices),+ _ => anyhow::bail!("unexpected voice helper response"),+ }+ }+/// Acknowledgement follows invalidation of the helper's previous capture/render generations.pub async fn set_audio_controls(&mut self, controls: crate::AudioControls) -> Result<()> {self.exchange(diff --git a/codex-rs/realtime-webrtc/src/lib.rs b/codex-rs/realtime-webrtc/src/lib.rsindex d4776cfcdd..988365628c 100644--- a/codex-rs/realtime-webrtc/src/lib.rs+++ b/codex-rs/realtime-webrtc/src/lib.rs@@ -10,6 +10,9 @@ pub use client::ConnectionError;pub use client::VoiceHost;pub use helper_exit::HelperExitStage;pub use protocol::AudioControls;+pub use protocol::AudioDevice;+pub use protocol::AudioDeviceKind;+pub use protocol::AudioDeviceSelection;pub use protocol::AudioState;pub use protocol::MAX_FRAME_BYTES;pub use protocol::Message;diff --git a/codex-rs/realtime-webrtc/src/protocol.rs b/codex-rs/realtime-webrtc/src/protocol.rsindex 2859aaea87..6c067243b4 100644--- a/codex-rs/realtime-webrtc/src/protocol.rs+++ b/codex-rs/realtime-webrtc/src/protocol.rs@@ -23,6 +23,31 @@ pub struct AudioState {pub speaker_peak: u16,}+/// Direction of a local audio device, shared by enumeration and capture/playback selection.+#[derive(Clone, Copy, Debug, Deserialize, PartialEq, Eq, Serialize)]+#[serde(rename_all = "camelCase")]+pub enum AudioDeviceKind {+ Input,+ Output,+}++/// Local device preferences fixed for the lifetime of a voice conversation.+#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]+#[serde(rename_all = "camelCase", deny_unknown_fields)]+pub struct AudioDeviceSelection {+ pub microphone: Option<String>,+ pub speaker: Option<String>,+}++/// Local device metadata; enumeration never opens streams.+#[derive(Clone, Debug, Deserialize, PartialEq, Serialize)]+#[serde(rename_all = "camelCase", deny_unknown_fields)]+pub struct AudioDevice {+ pub name: String,+ pub channels: u16,+ pub is_default: bool,+}+/// SDP contains ICE credentials. Bound it at construction and never expose it in diagnostics.#[derive(Deserialize, PartialEq, Serialize)]#[serde(try_from = "String")]@@ -82,7 +107,9 @@ pub enum Message {ApplyAnswer { sdp: SessionDescription },TransportReady {},TransportTimedOut {},- OpenDevices {},+ ListDevices { kind: AudioDeviceKind },+ DeviceList { devices: Vec<AudioDevice> },+ OpenDevices { selection: AudioDeviceSelection },DevicesOpened {},SetAudioControls { controls: AudioControls },AudioControlsApplied {},diff --git a/codex-rs/realtime-webrtc/src/session.rs b/codex-rs/realtime-webrtc/src/session.rsindex fee0c39669..badbf41e38 100644--- a/codex-rs/realtime-webrtc/src/session.rs+++ b/codex-rs/realtime-webrtc/src/session.rs@@ -16,6 +16,7 @@ use futures::future::Abortable;use tokio::sync::mpsc;use crate::AudioControls;+use crate::AudioDeviceSelection;use crate::ConnectionError;use crate::SessionDescription;use crate::VoiceHost;@@ -93,7 +94,10 @@ impl RealtimeWebrtcSession {}/// Called off the UI thread. Cancellation also owns startup before a handle is returned.- pub fn start(abort: AbortRegistration) -> Result<StartedRealtimeWebrtcSession> {+ pub fn start(+ abort: AbortRegistration,+ selection: AudioDeviceSelection,+ ) -> Result<StartedRealtimeWebrtcSession> {let package = codex_install_context::InstallContext::current().package_layout.clone()@@ -147,7 +151,7 @@ impl RealtimeWebrtcSession {offer.send(Ok(sdp.into_sdp())).map_err(|_| anyhow::anyhow!("voice startup cancelled"))?;- run(host, receiver, &state, &controls).await+ run(host, receiver, &state, &controls, selection).await};let result = runtime.block_on(Abortable::new(Abortable::new(task, abort), stopped));if let Ok(Ok(Err(error))) = result {@@ -266,6 +270,7 @@ async fn run(mut commands: mpsc::Receiver<Command>,state: &State,controls: &Mutex<AudioControls>,+ selection: AudioDeviceSelection,) -> Result<()> {let mut connected = false;let mut poll = tokio::time::interval(Duration::from_millis(/*millis*/ 50));@@ -277,7 +282,7 @@ async fn run(Some(Command::Answer(sdp, complete)) if !connected => {let startup = async {let mut host = report_failure(ConnectionError::Transport, host.apply_answer(sdp).await)?;- host = report_failure(ConnectionError::AudioDevices, host.open_devices().await)?;+ host = report_failure(ConnectionError::AudioDevices, host.open_devices(selection.clone()).await)?;let applied = startup_controls(&mut commands, controls, |initial| {host.begin_audio_controls(initial)});diff --git a/codex-rs/realtime-webrtc/tests/common/mod.rs b/codex-rs/realtime-webrtc/tests/common/mod.rsindex 63f8884b48..137012d28c 100644--- a/codex-rs/realtime-webrtc/tests/common/mod.rs+++ b/codex-rs/realtime-webrtc/tests/common/mod.rs@@ -148,6 +148,17 @@ fn helper() -> Result<()> {stage = Stage::Initialize;Message::Ready {}}+ Message::ListDevices { kind } if stage == Stage::Initialize => Message::DeviceList {+ devices: vec![codex_realtime_webrtc::AudioDevice {+ name: match kind {+ codex_realtime_webrtc::AudioDeviceKind::Input => "Interface",+ codex_realtime_webrtc::AudioDeviceKind::Output => "Headphones",+ }+ .into(),+ channels: 16,+ is_default: true,+ }],+ },Message::InitializeRuntime {} if stage == Stage::Initialize => {fs::write(root.join("initializing"), [])?;if root.join("hold-initialization").exists() {@@ -178,7 +189,11 @@ fn helper() -> Result<()> {stage = Stage::Devices;Message::TransportReady {}}- Message::OpenDevices {} if stage == Stage::Devices => {+ Message::OpenDevices { selection } if stage == Stage::Devices => {+ fs::write(+ root.join("input-selection"),+ serde_json::to_vec(&selection)?,+ )?;if root.join("fail-devices").exists() {anyhow::bail!("synthetic private device diagnostic");}diff --git a/codex-rs/realtime-webrtc/tests/session_actor.rs b/codex-rs/realtime-webrtc/tests/session_actor.rsindex ded26288ce..524f5ded14 100644--- a/codex-rs/realtime-webrtc/tests/session_actor.rs+++ b/codex-rs/realtime-webrtc/tests/session_actor.rs@@ -4,6 +4,8 @@ mod common;use anyhow::Result;use codex_realtime_webrtc::AudioControls;+use codex_realtime_webrtc::AudioDeviceKind;+use codex_realtime_webrtc::AudioDeviceSelection;use codex_realtime_webrtc::RealtimeWebrtcSession;use futures::future::AbortHandle;use pretty_assertions::assert_eq;@@ -24,7 +26,13 @@ fn startup_controls_meters_and_helper_loss() -> Result<()> {assert!(RealtimeWebrtcSession::is_supported());}let (_abort, registration) = AbortHandle::new_pair();- let started = RealtimeWebrtcSession::start(registration)?;+ let started = RealtimeWebrtcSession::start(+ registration,+ AudioDeviceSelection {+ microphone: Some("Zen Go Synergy Core Playback".into()),+ speaker: Some("Headphones".into()),+ },+ )?;assert_eq!(started.offer_sdp, "synthetic-offer");let handle = started.handle;handle.set_microphone_muted(/*muted*/ true)?;@@ -34,6 +42,10 @@ fn startup_controls_meters_and_helper_loss() -> Result<()> {handle.set_speaker_suppressed(/*suppressed*/ true);fs::write(root.join("release"), [])?;answer.join().expect("answer thread")?;+ assert_eq!(+ serde_json::from_slice::<serde_json::Value>(&fs::read(root.join("input-selection"))?)?,+ serde_json::json!({"microphone": "Zen Go Synergy Core Playback", "speaker": "Headphones"})+ );let initial: Vec<AudioControls> = serde_json::from_slice(&fs::read(root.join("controls"))?)?;assert_eq!(initial,@@ -84,7 +96,10 @@ fn external_cancellation_interrupts_startup() -> Result<()> {let (abort, registration) = AbortHandle::new_pair();let (result, received) = std::sync::mpsc::sync_channel(/*bound*/ 1);let startup = thread::spawn(move || {- let _ = result.send(RealtimeWebrtcSession::start(registration));+ let _ = result.send(RealtimeWebrtcSession::start(+ registration,+ AudioDeviceSelection::default(),+ ));});common::wait_for(|| root.join("initializing").exists())?;abort.abort();@@ -106,7 +121,7 @@ fn last_owner_drop_reaps_helper() -> Result<()> {return Ok(());};let (_abort, registration) = AbortHandle::new_pair();- let started = RealtimeWebrtcSession::start(registration)?;+ let started = RealtimeWebrtcSession::start(registration, AudioDeviceSelection::default())?;drop(started);common::wait_for_helper_reaped(&root)}@@ -121,7 +136,7 @@ fn device_failure_reaches_startup_completion_without_duplicate_error() -> Resultfs::write(root.join("fail-devices"), [])?;fs::write(root.join("release"), [])?;let (_abort, registration) = AbortHandle::new_pair();- let started = RealtimeWebrtcSession::start(registration)?;+ let started = RealtimeWebrtcSession::start(registration, AudioDeviceSelection::default())?;assert_eq!(started.handle.apply_answer_sdp("synthetic-answer".into()),Err(codex_realtime_webrtc::ConnectionError::AudioDevices)@@ -141,7 +156,8 @@ fn runtime_failure_reaches_offer_caller_without_native_error_text() -> Result<()};fs::write(root.join("fail-initialization"), [])?;let (_abort, registration) = AbortHandle::new_pair();- let error = RealtimeWebrtcSession::start(registration).unwrap_err();+ let error =+ RealtimeWebrtcSession::start(registration, AudioDeviceSelection::default()).unwrap_err();assert_eq!(error.downcast_ref::<codex_realtime_webrtc::ConnectionError>(),Some(&codex_realtime_webrtc::ConnectionError::RuntimeInitialization)@@ -154,3 +170,26 @@ fn runtime_failure_reaches_offer_caller_without_native_error_text() -> Result<()common::wait_for_helper_reaped(&root)?;Ok(())}++#[tokio::test]+async fn device_discovery_does_not_start_capture() -> Result<()> {+ let Some(root) = common::package("device_discovery_does_not_start_capture")? else {+ return Ok(());+ };+ let package = codex_install_context::InstallContext::current()+ .package_layout+ .as_ref()+ .unwrap();+ let mut host = codex_realtime_webrtc::VoiceHost::connect(package, common::BUILD_COMMIT).await?;+ assert_eq!(+ host.list_devices(AudioDeviceKind::Input).await?,+ vec![codex_realtime_webrtc::AudioDevice {+ name: "Interface".into(),+ channels: 16,+ is_default: true,+ }]+ );+ host.close().await?;+ assert!(!root.join("initializing").exists());+ Ok(())+}diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex f8fd11d57b..da47c0f7e9 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -2451,8 +2451,20 @@ impl App {}self.chat_widget.on_plugin_mentions_loaded(plugins);}- AppEvent::OpenRealtimeSettings => {- self.open_realtime_settings(app_server).await;+ AppEvent::OpenRealtimeSettings => self.chat_widget.open_realtime_settings(),+ AppEvent::OpenRealtimeSoundDevices => self.chat_widget.open_realtime_sound_devices(),+ AppEvent::OpenRealtimeVoices => self.open_realtime_voices(app_server).await,+ AppEvent::OpenRealtimeDevicePicker { kind } => self.list_realtime_devices(kind),+ AppEvent::RealtimeDevicesListed { origin, kind, result } => {+ if origin == self.active_thread_id {+ match result {+ Ok(devices) => self.chat_widget.open_realtime_device_picker(kind, devices),+ Err(error) => self.chat_widget.add_error_message(error),+ }+ }+ }+ AppEvent::PersistRealtimeDevice { kind, name } => {+ self.persist_realtime_device(kind, name).await;}AppEvent::PersistRealtimeVoiceSelection { voice } => {self.persist_realtime_voice(app_server, voice).await;diff --git a/codex-rs/tui/src/app/realtime_settings.rs b/codex-rs/tui/src/app/realtime_settings.rsindex 2f31148ee6..92e301bd13 100644--- a/codex-rs/tui/src/app/realtime_settings.rs+++ b/codex-rs/tui/src/app/realtime_settings.rs@@ -1,12 +1,14 @@-//! Resolve and persist voice preferences through the owning server before updating the UI.+//! Persist server voice preferences and machine-local audio selections before updating the UI.use super::*;+use crate::legacy_core::config::edit::ConfigEdit;use codex_app_server_protocol::ClientRequest;use codex_app_server_protocol::RequestId;use codex_app_server_protocol::ThreadRealtimeListVoicesParams;use codex_app_server_protocol::ThreadRealtimeListVoicesResponse;use codex_protocol::protocol::RealtimeVoice;use codex_protocol::protocol::RealtimeVoicesList;+use codex_realtime_webrtc::AudioDeviceKind;use uuid::Uuid;/// Unknown voices belong to newer servers; omit the override instead of blocking audio.@@ -29,6 +31,111 @@ fn configured_voice(}impl App {+ pub(super) async fn persist_realtime_device(+ &mut self,+ kind: AudioDeviceKind,+ name: Option<String>,+ ) {+ let key = match kind {+ AudioDeviceKind::Input => "microphone",+ AudioDeviceKind::Output => "speaker",+ };+ self.persist_realtime_audio(key, name.map(Into::into)).await;+ self.list_realtime_devices(kind);+ }++ async fn persist_realtime_audio(&mut self, key: &str, value: Option<toml::Value>) {+ // Audio runs on the TUI's machine, even when the app server is remote.+ let segments = vec!["audio".to_string(), key.to_string()];+ let edits = vec![match &value {+ Some(toml::Value::String(value)) => ConfigEdit::SetPath {+ segments,+ value: value.clone().into(),+ },+ Some(_) => unreachable!("audio device settings are names"),+ None => ConfigEdit::ClearPath { segments },+ }];+ if let Err(error) =+ ConfigEditsBuilder::for_config_path(self.local_settings.user_config_path.as_path())+ .with_edits(edits)+ .apply()+ .await+ {+ self.chat_widget+ .add_error_message(format!("Failed to save audio setting: {error}"));+ return;+ }+ match crate::legacy_core::config::load_config_toml_with_layer_stack(+ self.local_settings.codex_home.as_path(),+ /*cwd*/ None,+ self.cli_kv_overrides.clone(),+ codex_config::ConfigLoadOptions {+ loader_overrides: self.loader_overrides.clone(),+ cloud_config_bundle: self.cloud_config_bundle.clone(),+ ..Default::default()+ },+ )+ .await+ {+ Ok(config) => {+ self.config.config_layer_stack = self+ .config+ .config_layer_stack+ .with_user_layer_from(&config.config_layer_stack);+ let audio = config.config_toml.audio.unwrap_or_default();+ let effective = toml::Value::try_from(&audio)+ .ok()+ .and_then(|audio| audio.get(key).cloned());+ self.local_settings.audio = Ok(audio);+ self.chat_widget.local_settings.audio = self.local_settings.audio.clone();+ if effective == value {+ self.chat_widget.add_info_message(+ "Audio setting saved. Applies to your next voice conversation.".to_string(),+ /*hint*/ None,+ );+ } else {+ self.chat_widget.add_error_message(+ "Audio setting was saved but is overridden by another configuration layer."+ .to_string(),+ );+ }+ }+ Err(error) => self.chat_widget.add_error_message(format!(+ "Audio setting was saved, but effective settings could not be read: {error}"+ )),+ }+ }++ pub(super) fn list_realtime_devices(&self, kind: AudioDeviceKind) {+ let tx = self.app_event_tx.clone();+ let origin = self.active_thread_id;+ tokio::spawn(async move {+ let result = async {+ let package = codex_install_context::InstallContext::current()+ .package_layout+ .as_ref()+ .ok_or_else(|| anyhow::anyhow!("voice package unavailable"))?;+ let mut host = codex_realtime_webrtc::VoiceHost::connect(+ package,+ codex_build_info::BuildInfo::get().build_commit(),+ )+ .await?;+ let result = host.list_devices(kind).await;+ host.close().await?;+ result+ }+ .await;+ tx.send(AppEvent::RealtimeDevicesListed {+ origin,+ kind,+ result: result.map_err(|_| {+ "Could not list audio devices. Check your audio device and voice package."+ .to_owned()+ }),+ });+ });+ }+pub(super) async fn realtime_voices(&self,app_server: &AppServerSession,@@ -63,7 +170,7 @@ impl App {.map(Option::flatten)}- pub(super) async fn open_realtime_settings(&mut self, app_server: &AppServerSession) {+ pub(super) async fn open_realtime_voices(&mut self, app_server: &AppServerSession) {let voices = match self.realtime_voices(app_server).await {Ok(voices) => voices,Err(error) => {@@ -73,7 +180,7 @@ impl App {}};match self.effective_realtime_voice(app_server, &voices).await {- Ok(voice) => self.chat_widget.open_realtime_settings(voice, voices),+ Ok(voice) => self.chat_widget.open_realtime_voices(voice, voices),Err(error) => self.chat_widget.add_error_message(format!("Failed to read voice settings: {error}")),diff --git a/codex-rs/tui/src/app/tests/realtime_requests.rs b/codex-rs/tui/src/app/tests/realtime_requests.rsindex 16c81ceecf..57bcbf2ea6 100644--- a/codex-rs/tui/src/app/tests/realtime_requests.rs+++ b/codex-rs/tui/src/app/tests/realtime_requests.rs@@ -7,6 +7,7 @@ use crate::app::tests::session_lifecycle_requests::start_recording_realtime_speeuse crate::app::tests::session_lifecycle_requests::start_recording_remote_app_server;use crate::chatwidget::commit_realtime_history_events;use crate::chatwidget::tests::make_chatwidget_manual_with_sender;+use crate::local_settings::LocalSettings;use codex_app_server_protocol::ItemCompletedNotification;use codex_app_server_protocol::ItemStartedNotification;use codex_app_server_protocol::ServerNotification;@@ -1832,7 +1833,7 @@ async fn embedded_voice_settings_follow_project_after_thread_switch() -> Result<),);Box::pin(app.select_agent_thread(&mut tui, &mut server, thread_id)).await?;- app.open_realtime_settings(&server).await;+ app.open_realtime_voices(&server).await;let popup = crate::chatwidget::tests::helpers::render_bottom_popup(&app.chat_widget,/*width*/ 80,@@ -1872,7 +1873,7 @@ async fn remote_voice_picker_reads_server_preference() -> Result<()> {app.chat_widget.set_realtime_voice(Some(codex_protocol::protocol::RealtimeVoice::Maple));let (server, requests, proxy) = start_recording_remote_app_server(&app.config).await?;- app.open_realtime_settings(&server).await;+ app.open_realtime_voices(&server).await;assert_eq!(recorded_params(&requests, "thread/realtime/listVoices").len(),1@@ -1906,7 +1907,7 @@ async fn remote_voice_catalog_success_and_failure() -> Result<()> {).await?;while events.try_recv().is_ok() {}- app.open_realtime_settings(&server).await;+ app.open_realtime_voices(&server).await;let popup = crate::chatwidget::tests::helpers::render_bottom_popup(&app.chat_widget,/*width*/ 80,@@ -2078,3 +2079,123 @@ async fn overridden_voice_save_keeps_effective_voice() -> Result<()> {}Ok(())}++#[tokio::test]+async fn audio_devices_are_persisted() -> Result<()> {+ use codex_realtime_webrtc::AudioDeviceKind;+ let mut app = make_test_app().await;+ app.persist_realtime_device(AudioDeviceKind::Output, Some("Headphones".into()))+ .await;+ app.persist_realtime_device(AudioDeviceKind::Input, Some("Interface".into()))+ .await;+ let expected = codex_config::config_toml::RealtimeAudioToml {+ microphone: Some("Interface".into()),+ speaker: Some("Headphones".into()),+ };+ assert_eq!(app.local_settings.audio.as_ref().unwrap(), &expected);+ assert_eq!(LocalSettings::from(&app.config).audio, Ok(expected));+ app.persist_realtime_device(AudioDeviceKind::Input, /*name*/ None)+ .await;+ app.persist_realtime_device(AudioDeviceKind::Output, /*name*/ None)+ .await;+ assert_eq!(app.local_settings.audio, Ok(Default::default()));+ assert_eq!(+ app.chat_widget.local_settings.audio,+ app.local_settings.audio+ );+ Ok(())+}++#[tokio::test]+async fn audio_device_is_machine_local_across_project_and_remote_transitions() -> Result<()> {+ let mut app = make_test_app().await;+ let project = tempfile::tempdir()?;+ let remote = tempfile::tempdir()?;+ std::fs::create_dir_all(project.path().join(".codex"))?;+ std::fs::write(+ project.path().join(".codex/config.toml"),+ "default_permissions = \"work\"\n[audio]\nmicrophone = \"Project mic\"\n[permissions.work]\nextends = \":workspace\"\n",+ )?;+ crate::legacy_core::config::set_project_trust_level(+ &app.config.codex_home,+ project.path(),+ codex_protocol::config_types::TrustLevel::Trusted,+ )+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;+ app.cli_kv_overrides = vec![("default_permissions".into(), "work".into())];+ app.config = app.rebuild_config_for_cwd(project.path().into()).await?;+ app.app_server_target = AppServerTarget::Remote {+ endpoint: crate::resolve_remote_addr("ws://127.0.0.1:9")?,+ };+ app.chat_widget+ .handle_thread_session_quiet(test_thread_session(+ ThreadId::new(),+ remote.path().to_path_buf(),+ ));+ app.persist_realtime_device(+ codex_realtime_webrtc::AudioDeviceKind::Input,+ Some("Machine mic".into()),+ )+ .await;+ app.cli_kv_overrides.clear();+ assert_eq!(+ LocalSettings::from(&app.config).audio,+ app.local_settings.audio+ );+ for cwd in [project.path(), remote.path()] {+ let config = app.rebuild_config_for_cwd(cwd.to_path_buf()).await?;+ let reloaded = app.local_settings.reloaded(&config);+ assert_eq!(reloaded.audio, app.chat_widget.local_settings.audio);+ assert_eq!(+ reloaded.audio.as_ref().unwrap().microphone.as_deref(),+ Some("Machine mic")+ );+ }+ // A project value must not hide invalid machine audio.+ std::fs::write(+ app.local_settings.user_config_path.as_path(),+ std::fs::read_to_string(app.local_settings.user_config_path.as_path())?+ .replace("microphone = \"Machine mic\"", "microphone = 0"),+ )?;+ let config = app+ .rebuild_config_for_cwd(project.path().to_path_buf())+ .await?;+ app.chat_widget.local_settings = app.local_settings.reloaded(&config);+ assert!(app.chat_widget.local_settings.audio.is_err());+ app.chat_widget.open_realtime_sound_devices();+ assert!(!app.chat_widget.has_active_view());++ Ok(())+}++#[tokio::test]+async fn microphone_discovery_ignores_another_threads_completion() -> Result<()> {+ let (mut app, _events, _ops) = make_test_app_with_channels().await;+ let (mut server, _requests, proxy) = start_recording_remote_app_server(&app.config).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ app.active_thread_id = Some(ThreadId::new());+ for origin in [Some(ThreadId::new()), app.active_thread_id] {+ let result = Ok(vec![codex_realtime_webrtc::AudioDevice {+ name: "Interface".into(),+ channels: 16,+ is_default: true,+ }]);+ Box::pin(app.handle_event(+ &mut tui,+ &mut server,+ AppEvent::RealtimeDevicesListed {+ origin,+ kind: codex_realtime_webrtc::AudioDeviceKind::Input,+ result,+ },+ ))+ .await?;+ assert_eq!(+ app.chat_widget.has_active_view(),+ origin == app.active_thread_id+ );+ }+ server.shutdown().await?;+ proxy.await??;+ Ok(())+}diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__realtime_requests__remote_voice_picker_server_default.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__realtime_requests__remote_voice_picker_server_default.snapindex 7c6af54461..b4792ba8f4 100644--- a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__realtime_requests__remote_voice_picker_server_default.snap+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__realtime_requests__remote_voice_picker_server_default.snap@@ -9,5 +9,6 @@ expression: popup› 1. maple (current)2. cove3. juniper+ 4. Backenter select · esc backdiff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex 9e3a2beb75..dfedc79733 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -1220,6 +1220,20 @@ pub(crate) enum AppEvent {/// Read the owning server preference before showing the voice picker.OpenRealtimeSettings,+ OpenRealtimeSoundDevices,+ OpenRealtimeVoices,+ OpenRealtimeDevicePicker {+ kind: codex_realtime_webrtc::AudioDeviceKind,+ },+ RealtimeDevicesListed {+ origin: Option<ThreadId>,+ kind: codex_realtime_webrtc::AudioDeviceKind,+ result: Result<Vec<codex_realtime_webrtc::AudioDevice>, String>,+ },+ PersistRealtimeDevice {+ kind: codex_realtime_webrtc::AudioDeviceKind,+ name: Option<String>,+ },/// Save the voice for subsequent conversations through the app server.PersistRealtimeVoiceSelection {diff --git a/codex-rs/tui/src/chatwidget/realtime.rs b/codex-rs/tui/src/chatwidget/realtime.rsindex ccda3290f4..95e4c90cfb 100644--- a/codex-rs/tui/src/chatwidget/realtime.rs+++ b/codex-rs/tui/src/chatwidget/realtime.rs@@ -312,6 +312,9 @@ impl ChatWidget {}fn start_realtime_conversation(&mut self, thread_id: ThreadId) {+ let Some(audio) = self.realtime_audio_settings() else {+ return;+ };self.realtime_conversation.recover_late_transcripts = false;self.realtime_conversation.attempt_id =NEXT_REALTIME_ATTEMPT_ID.fetch_add(1, Ordering::Relaxed);@@ -322,9 +325,13 @@ impl ChatWidget {self.realtime_conversation.phase = RealtimeConversationPhase::Starting;self.update_realtime_footer();let app_event_tx = self.app_event_tx.clone();+ let selection = codex_realtime_webrtc::AudioDeviceSelection {+ microphone: audio.microphone,+ speaker: audio.speaker,+ };std::thread::spawn(move || {- let result =- RealtimeWebrtcSession::start(abort_registration).map_err(|error| error.to_string());+ let result = RealtimeWebrtcSession::start(abort_registration, selection)+ .map_err(|error| error.to_string());app_event_tx.send(AppEvent::RealtimeWebrtcOfferCreated {thread_id,attempt_id,diff --git a/codex-rs/tui/src/chatwidget/realtime_settings.rs b/codex-rs/tui/src/chatwidget/realtime_settings.rsindex 3057764af5..e0ff656791 100644--- a/codex-rs/tui/src/chatwidget/realtime_settings.rs+++ b/codex-rs/tui/src/chatwidget/realtime_settings.rs@@ -1,17 +1,62 @@-//! Voice selection for subsequent conversations; saving never interrupts live audio.+//! Voice settings hierarchy with parent navigation; selections apply to subsequent conversations.use super::*;use codex_protocol::protocol::RealtimeVoice;use codex_protocol::protocol::RealtimeVoicesList;+use codex_realtime_webrtc::AudioDevice;+use codex_realtime_webrtc::AudioDeviceKind;++fn back_item(parent: fn() -> AppEvent) -> SelectionItem {+ SelectionItem {+ name: "Back".to_string(),+ actions: vec![Box::new(move |tx| tx.send(parent()))],+ dismiss_on_select: true,+ ..Default::default()+ }+}impl ChatWidget {- pub(crate) fn open_realtime_settings(+ pub(super) fn realtime_audio_settings(+ &mut self,+ ) -> Option<codex_config::config_toml::RealtimeAudioToml> {+ match self.local_settings.audio.clone() {+ Ok(audio) => Some(audio),+ Err(error) => {+ self.add_error_message(error);+ None+ }+ }+ }++ pub(crate) fn open_realtime_settings(&mut self) {+ self.bottom_pane.show_selection_view(SelectionViewParams {+ title: Some("Voice settings".to_string()),+ items: vec![+ SelectionItem {+ name: "Set sound devices".to_string(),+ actions: vec![Box::new(|tx| tx.send(AppEvent::OpenRealtimeSoundDevices))],+ dismiss_on_select: true,+ ..Default::default()+ },+ SelectionItem {+ name: "Choose a voice".to_string(),+ actions: vec![Box::new(|tx| tx.send(AppEvent::OpenRealtimeVoices))],+ dismiss_on_select: true,+ ..Default::default()+ },+ ],+ footer_hint: Some(standard_popup_hint_line()),+ ..SelectionViewParams::picker()+ });+ }++ pub(crate) fn open_realtime_voices(&mut self,current: Option<RealtimeVoice>,voices: RealtimeVoicesList,) {// The TUI uses V3, which shares the V1 voice catalog.- let items = voices+ let mut items: Vec<SelectionItem> = voices.v1.into_iter().map(|voice| SelectionItem {@@ -24,11 +69,101 @@ impl ChatWidget {..Default::default()}).collect();+ items.push(back_item(|| AppEvent::OpenRealtimeSettings));self.bottom_pane.show_selection_view(SelectionViewParams {title: Some("Select voice".to_string()),subtitle: Some("Applies to your next voice conversation.".to_string()),footer_hint: Some(standard_popup_hint_line()),items,+ on_cancel: Some(Box::new(|tx| tx.send(AppEvent::OpenRealtimeSettings))),+ ..SelectionViewParams::picker()+ });+ }++ pub(crate) fn open_realtime_sound_devices(&mut self) {+ let Some(audio) = self.realtime_audio_settings() else {+ return;+ };+ let mut items = Vec::new();+ for (kind, label, selected) in [+ (AudioDeviceKind::Input, "Input device", audio.microphone),+ (AudioDeviceKind::Output, "Output device", audio.speaker),+ ] {+ items.push(SelectionItem {+ name: label.into(),+ description: Some(selected.unwrap_or_else(|| "System default".into())),+ actions: vec![Box::new(move |tx| {+ tx.send(AppEvent::OpenRealtimeDevicePicker { kind })+ })],+ dismiss_on_select: true,+ ..Default::default()+ });+ }+ items.push(back_item(|| AppEvent::OpenRealtimeSettings));+ self.bottom_pane.show_selection_view(SelectionViewParams {+ title: Some("Sound devices".to_string()),+ subtitle: Some("Applies to your next voice conversation.".into()),+ footer_hint: Some(standard_popup_hint_line()),+ items,+ on_cancel: Some(Box::new(|tx| tx.send(AppEvent::OpenRealtimeSettings))),+ ..SelectionViewParams::picker()+ });+ }++ pub(crate) fn open_realtime_device_picker(+ &mut self,+ kind: AudioDeviceKind,+ devices: Vec<AudioDevice>,+ ) {+ let Some(audio) = self.realtime_audio_settings() else {+ return;+ };+ let (title, current) = match kind {+ AudioDeviceKind::Input => ("Input device", audio.microphone),+ AudioDeviceKind::Output => ("Output device", audio.speaker),+ };+ let ambiguous: std::collections::HashSet<_> = devices+ .iter()+ .filter(|device| {+ devices+ .iter()+ .filter(|other| other.name == device.name)+ .count()+ > 1+ })+ .map(|device| device.name.clone())+ .collect();+ let mut items: Vec<SelectionItem> = std::iter::once(/*value*/ None)+ .chain(devices.into_iter().map(Some))+ .map(|device| {+ let name = device.map(|device| device.name);+ let is_current = name == current;+ let disabled_reason = name+ .as_ref()+ .filter(|name| ambiguous.contains(*name))+ .map(|_| "Identical device names; use System default.".into());+ SelectionItem {+ name: name.clone().unwrap_or_else(|| "System default".into()),+ is_current,+ disabled_reason,+ actions: vec![Box::new(move |tx| {+ tx.send(AppEvent::PersistRealtimeDevice {+ kind,+ name: name.clone(),+ })+ })],+ dismiss_on_select: true,+ ..Default::default()+ }+ })+ .collect();+ items.push(back_item(|| AppEvent::OpenRealtimeSoundDevices));+ self.bottom_pane.show_selection_view(SelectionViewParams {+ title: Some(title.into()),+ subtitle: Some("Applies to your next voice conversation.".into()),+ items,+ footer_hint: Some(standard_popup_hint_line()),+ on_cancel: Some(Box::new(|tx| tx.send(AppEvent::OpenRealtimeSoundDevices))),..SelectionViewParams::picker()});}diff --git a/codex-rs/tui/src/chatwidget/realtime_settings_tests.rs b/codex-rs/tui/src/chatwidget/realtime_settings_tests.rsindex 84657da2bd..846b0f6934 100644--- a/codex-rs/tui/src/chatwidget/realtime_settings_tests.rs+++ b/codex-rs/tui/src/chatwidget/realtime_settings_tests.rs@@ -1,4 +1,4 @@-//! Voice picker rendering and selection routing without audio hardware.+//! Voice settings hierarchy, parent navigation and selection routing without audio hardware.use super::*;use crate::chatwidget::tests::make_chatwidget_manual_with_sender;@@ -21,8 +21,18 @@ async fn voice_settings_selects_a_voice_without_starting_audio() {std::iter::from_fn(|| events.try_recv().ok()).any(|event| matches!(event, AppEvent::OpenRealtimeSettings)));- chat.open_realtime_settings(Some(RealtimeVoice::Maple), RealtimeVoicesList::builtin());+ chat.open_realtime_settings();insta::assert_snapshot!("voice_settings", render_bottom_popup(&chat, /*width*/ 80));+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Down, KeyModifiers::NONE));+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(+ std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::OpenRealtimeVoices))+ );+ chat.open_realtime_voices(Some(RealtimeVoice::Maple), RealtimeVoicesList::builtin());+ insta::assert_snapshot!("voice_choices", render_bottom_popup(&chat, /*width*/ 80));chat.bottom_pane.handle_key_event(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE));chat.bottom_pane@@ -57,7 +67,7 @@ async fn saved_voice_confirmation_snapshot() {#[tokio::test]async fn voice_settings_uses_server_catalog() {let (mut chat, _sender, _events, _ops) = make_chatwidget_manual_with_sender().await;- chat.open_realtime_settings(+ chat.open_realtime_voices(Some(RealtimeVoice::Cove),RealtimeVoicesList {v1: vec![RealtimeVoice::Cove, RealtimeVoice::Maple],@@ -69,3 +79,148 @@ async fn voice_settings_uses_server_catalog() {render_bottom_popup(&chat, /*width*/ 80));}++#[tokio::test]+async fn sound_devices_picker_routes_selection_without_starting_audio() {+ let (mut chat, _sender, mut events, mut ops) = make_chatwidget_manual_with_sender().await;+ chat.local_settings.audio.as_mut().unwrap().microphone =+ Some("Zen Go Synergy Core Playback".to_string());+ chat.open_realtime_settings();+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(+ std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::OpenRealtimeSoundDevices))+ );+ chat.open_realtime_sound_devices();+ insta::assert_snapshot!(+ "voice_settings_input_channel",+ render_bottom_popup(&chat, /*width*/ 90)+ );+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Home, KeyModifiers::NONE));+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));+ assert!(+ std::iter::from_fn(|| events.try_recv().ok()).any(|event| matches!(+ event,+ AppEvent::OpenRealtimeDevicePicker {+ kind: AudioDeviceKind::Input+ }+ ))+ );+ assert!(ops.try_recv().is_err());+ assert!(!chat.realtime_conversation_is_running());+}++#[tokio::test]+async fn submenus_return_to_their_parent_with_back_or_escape() {+ let (mut chat, _sender, mut events, mut ops) = make_chatwidget_manual_with_sender().await;+ type OpenMenu = fn(&mut ChatWidget);+ let menus: [OpenMenu; 2] = [+ |chat| chat.open_realtime_voices(/*current*/ None, RealtimeVoicesList::builtin()),+ ChatWidget::open_realtime_sound_devices,+ ];+ for open in menus {+ for key in [KeyCode::Esc, KeyCode::Enter] {+ while events.try_recv().is_ok() {}+ open(&mut chat);+ if key == KeyCode::Enter {+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::End, KeyModifiers::NONE));+ }+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(key, KeyModifiers::NONE));+ assert!(+ std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::OpenRealtimeSettings))+ );+ }+ }+ assert!(ops.try_recv().is_err());+ assert!(!chat.realtime_conversation_is_running());+}++#[tokio::test]+async fn device_pickers_route_selection() {+ let (mut chat, _sender, mut events, mut ops) = make_chatwidget_manual_with_sender().await;+ for (kind, channels, microphone, snapshot) in [+ (+ AudioDeviceKind::Input,+ 2,+ None,+ "voice_stereo_input_devices",+ ),+ (+ AudioDeviceKind::Input,+ 4,+ None,+ "voice_multichannel_input_devices",+ ),+ (+ AudioDeviceKind::Input,+ 4,+ Some("Audio interface".into()),+ "voice_multichannel_selected_input_devices",+ ),+ (AudioDeviceKind::Output, 4, None, "voice_output_devices"),+ ] {+ chat.local_settings.audio.as_mut().unwrap().microphone = microphone;+ let device = AudioDevice {+ name: "Audio interface".into(),+ channels,+ is_default: true,+ };+ let devices = vec![+ device.clone(),+ AudioDevice {+ name: "Other device".into(),+ channels: 2,+ is_default: false,+ },+ ];+ chat.open_realtime_device_picker(kind, devices.clone());+ insta::assert_snapshot!(snapshot, render_bottom_popup(&chat, /*width*/ 80));+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE));+ let selected =+ std::iter::from_fn(|| events.try_recv().ok()).find_map(|event| match event {+ AppEvent::PersistRealtimeDevice { kind, name } => Some((kind, name)),+ _ => None,+ });+ assert_eq!(selected, Some((kind, Some(device.name.clone()))));+ chat.open_realtime_device_picker(kind, devices);+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Char('4'), KeyModifiers::NONE));+ assert!(+ std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::OpenRealtimeSoundDevices))+ );+ }+ assert!(ops.try_recv().is_err());+ assert!(!chat.realtime_conversation_is_running());+}++#[tokio::test]+async fn ambiguous_device_names_cannot_select_the_wrong_device() {+ let (mut chat, _sender, mut events, _ops) = make_chatwidget_manual_with_sender().await;+ let devices = [2, 4]+ .map(|channels| AudioDevice {+ name: "USB microphone".into(),+ channels,+ is_default: false,+ })+ .to_vec();+ chat.open_realtime_device_picker(AudioDeviceKind::Input, devices);+ insta::assert_snapshot!(+ "voice_ambiguous_input_devices",+ render_bottom_popup(&chat, /*width*/ 80)+ );+ while events.try_recv().is_ok() {}+ chat.bottom_pane+ .handle_key_event(KeyEvent::new(KeyCode::Char('2'), KeyModifiers::NONE));+ assert!(+ !std::iter::from_fn(|| events.try_recv().ok())+ .any(|event| matches!(event, AppEvent::PersistRealtimeDevice { .. }))+ );+}diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_ambiguous_input_devices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_ambiguous_input_devices.snapnew file mode 100644index 0000000000..c6ca4fa34c--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_ambiguous_input_devices.snap@@ -0,0 +1,14 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Input device+ Applies to your next voice conversation.+++› 1. System default (current)+ USB microphone (disabled) Identical device names; use System default.+ USB microphone (disabled) Identical device names; use System default.+ 2. Back++ enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_choices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_choices.snapnew file mode 100644index 0000000000..531afad01a--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_choices.snap@@ -0,0 +1,18 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Select voice+ Applies to your next voice conversation.+++ 1. juniper+› 2. maple (current)+ 3. spruce+ 4. ember+ 5. vale+ 6. breeze+ 7. arbor+ 8. sol+↓+ enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_multichannel_input_devices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_multichannel_input_devices.snapnew file mode 100644index 0000000000..1ecf807257--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_multichannel_input_devices.snap@@ -0,0 +1,14 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Input device+ Applies to your next voice conversation.+++› 1. System default (current)+ 2. Audio interface+ 3. Other device+ 4. Back++ enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_multichannel_selected_input_devices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_multichannel_selected_input_devices.snapnew file mode 100644index 0000000000..919bf16779--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_multichannel_selected_input_devices.snap@@ -0,0 +1,14 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Input device+ Applies to your next voice conversation.+++ 1. System default+› 2. Audio interface (current)+ 3. Other device+ 4. Back++ enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_output_devices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_output_devices.snapnew file mode 100644index 0000000000..4f820944cc--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_output_devices.snap@@ -0,0 +1,14 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Output device+ Applies to your next voice conversation.+++› 1. System default (current)+ 2. Audio interface+ 3. Other device+ 4. Back++ enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings.snapindex 531afad01a..f42fc409e2 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings.snap@@ -2,17 +2,10 @@source: tui/src/chatwidget/realtime_settings_tests.rsexpression: "render_bottom_popup(&chat, 80)"---- Select voice- Applies to your next voice conversation.+ Voice settings- 1. juniper-› 2. maple (current)- 3. spruce- 4. ember- 5. vale- 6. breeze- 7. arbor- 8. sol-↓+› 1. Set sound devices+ 2. Choose a voice+enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_input_channel.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_input_channel.snapnew file mode 100644index 0000000000..b5c6594671--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_input_channel.snap@@ -0,0 +1,13 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 90)"+---+ Sound devices+ Applies to your next voice conversation.+++› 1. Input device Zen Go Synergy Core Playback+ 2. Output device System default+ 3. Back++ enter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_server_catalog.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_server_catalog.snapindex a78990f3dd..938025893f 100644--- a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_server_catalog.snap+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_settings_server_catalog.snap@@ -8,5 +8,6 @@ expression: "render_bottom_popup(&chat, 80)"› 1. cove (current)2. maple+ 3. Backenter select · esc backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_stereo_input_devices.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_stereo_input_devices.snapnew file mode 100644index 0000000000..1ecf807257--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__realtime_settings__tests__voice_stereo_input_devices.snap@@ -0,0 +1,14 @@+---+source: tui/src/chatwidget/realtime_settings_tests.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Input device+ Applies to your next voice conversation.+++› 1. System default (current)+ 2. Audio interface+ 3. Other device+ 4. Back++ enter select · esc backdiff --git a/codex-rs/tui/src/local_settings.rs b/codex-rs/tui/src/local_settings.rsindex 4eb78a510c..8669f96750 100644--- a/codex-rs/tui/src/local_settings.rs+++ b/codex-rs/tui/src/local_settings.rs@@ -3,6 +3,7 @@//! The resolved core config is a temporary input at local load/reload boundaries. Server thread//! responses must never refresh these values; live preference changes belong here. The remaining//! Config-based lifecycle adapters also use this conversion until their interfaces are migrated.+//! Audio preferences exclude project layers so thread cwd cannot route local capture.//! Effective animations also respect the TUI host's launch-time accessibility preference.//! The selected transcript ownership and alternate-screen restrictions survive local reloads.@@ -20,6 +21,7 @@ use codex_utils_absolute_path::AbsolutePathBuf;#[derive(Clone, Debug, PartialEq)]pub(crate) struct LocalSettings {+ pub(crate) audio: Result<codex_config::config_toml::RealtimeAudioToml, String>,pub(crate) tui: Tui,pub(crate) transcript_mode: TranscriptMode,pub(crate) history: History,@@ -56,7 +58,18 @@ impl LocalSettings {} else {config.animations};+ let mut audio = toml::Value::Table(Default::default());+ for layer in config.config_layer_stack.layers_low_to_high() {+ if !matches!(layer.name, codex_config::ConfigLayerSource::Project { .. })+ && let Some(value) = layer.config.get("audio")+ {+ codex_config::merge_toml_values(&mut audio, value);+ }+ }Self {+ audio: audio.try_into().map_err(|error: toml::de::Error| {+ format!("Invalid machine audio settings: {error}")+ }),transcript_mode: TranscriptMode::resolve(config.tui_fullscreen_transcript,config.tui_alternate_screen != codex_config::types::AltScreenMode::Never,diff --git a/codex-rs/voice-host/src/devices.rs b/codex-rs/voice-host/src/devices.rsindex a26e4aa7d5..4d5a88c0c2 100644--- a/codex-rs/voice-host/src/devices.rs+++ b/codex-rs/voice-host/src/devices.rs@@ -23,6 +23,7 @@ use std::sync::atomic::Ordering;use std::time::Duration;use std::time::Instant;+use codex_realtime_webrtc::AudioDeviceKind;use cpal::FromSample;use cpal::Sample;use cpal::SampleFormat;@@ -41,6 +42,77 @@ use buffers::Playback;use buffers::QUEUE_CAPACITY;use playback::PlaybackPort;+fn device(+ host: &cpal::Host,+ kind: AudioDeviceKind,+ name: Option<&str>,+) -> io::Result<cpal::Device> {+ let selected = match (kind, name) {+ (AudioDeviceKind::Input, None) => host.default_input_device(),+ (AudioDeviceKind::Output, None) => host.default_output_device(),+ (kind, Some(name)) => {+ let devices = match kind {+ AudioDeviceKind::Input => host.input_devices(),+ AudioDeviceKind::Output => host.output_devices(),+ }+ .map_err(io::Error::other)?;+ eligible_devices(devices, |device| device_description(device, kind))+ .find(|(_, candidate, _)| candidate == name)+ .map(|(device, _, _)| device)+ }+ };+ selected.ok_or_else(|| io::Error::other("selected audio device unavailable"))+}++pub(super) fn list_devices(+ kind: AudioDeviceKind,+) -> io::Result<Vec<codex_realtime_webrtc::AudioDevice>> {+ let host = cpal::default_host();+ let default_id = device(&host, kind, /*name*/ None)+ .ok()+ .and_then(|device| device.id().ok());+ let devices = match kind {+ AudioDeviceKind::Input => host.input_devices(),+ AudioDeviceKind::Output => host.output_devices(),+ }+ .map_err(io::Error::other)?;+ Ok(+ eligible_devices(devices, |device| device_description(device, kind))+ .map(+ |(device, name, channels)| codex_realtime_webrtc::AudioDevice {+ name,+ channels,+ is_default: default_id.is_some() && device.id().ok() == default_id,+ },+ )+ .collect(),+ )+}++fn device_description(+ device: &cpal::Device,+ kind: AudioDeviceKind,+) -> Option<(String, cpal::SupportedStreamConfig)> {+ let config = match kind {+ AudioDeviceKind::Input => device.default_input_config(),+ AudioDeviceKind::Output => device.default_output_config(),+ }+ .ok()?;+ Some((device.description().ok()?.name().to_owned(), config))+}++// Listing and named startup must agree on which endpoints can be selected.+fn eligible_devices<D>(+ devices: impl Iterator<Item = D>,+ mut describe: impl FnMut(&D) -> Option<(String, cpal::SupportedStreamConfig)>,+) -> impl Iterator<Item = (D, String, u16)> {+ devices.take(/*n*/ 64).filter_map(move |device| {+ let (name, config) = describe(&device)?;+ bounded_stream_config(&config).ok()?;+ (name.chars().count() <= 256).then(|| (device, name, config.channels()))+ })+}+const MAX_CAPTURE_AGE: Duration = Duration::from_secs(/*secs*/ 1);pub(super) struct Devices {@@ -76,14 +148,14 @@ impl Devices {self.worker.buffers.take_state()}- pub(super) fn open() -> io::Result<Self> {+ pub(super) fn open(selection: codex_realtime_webrtc::AudioDeviceSelection) -> io::Result<Self> {let host = cpal::default_host();- let input = host- .default_input_device()- .ok_or_else(|| io::Error::other("microphone unavailable"))?;- let output = host- .default_output_device()- .ok_or_else(|| io::Error::other("speaker unavailable"))?;+ let input = device(+ &host,+ AudioDeviceKind::Input,+ selection.microphone.as_deref(),+ )?;+ let output = device(&host, AudioDeviceKind::Output, selection.speaker.as_deref())?;let input_config = input.default_input_config().map_err(|_| io::Error::other("microphone configuration unavailable"))?;diff --git a/codex-rs/voice-host/src/devices_tests.rs b/codex-rs/voice-host/src/devices_tests.rsindex e9f7b40dab..ac1e1c9e47 100644--- a/codex-rs/voice-host/src/devices_tests.rs+++ b/codex-rs/voice-host/src/devices_tests.rs@@ -423,3 +423,36 @@ fn stream_xruns_recover_without_clearing_device_failure() {handle_stream_error(&buffers, cpal::ErrorKind::Xrun.into());assert!(buffers.failed.load(Ordering::Acquire));}++#[test]+fn named_startup_skips_same_name_devices_omitted_from_discovery() {+ let name = "USB interface";+ let supported = |channels| {+ cpal::SupportedStreamConfig::new(+ channels,+ /*sample_rate*/ 48_000,+ cpal::SupportedBufferSize::Range { min: 1, max: 4_096 },+ cpal::SampleFormat::F32,+ )+ };+ // A missing default configuration and a configuration outside our bounds+ // must not shadow the later selectable endpoint with the same name.+ let descriptions = [None, Some(supported(64)), Some(supported(2))];+ let candidates = || {+ eligible_devices(0..descriptions.len(), |index| {+ descriptions[*index].map(|config| (name.into(), config))+ })+ };+ assert_eq!(+ candidates().collect::<Vec<_>>(),+ vec![(2, name.to_string(), 2)]+ );+ assert_eq!(+ candidates().find(|(_, candidate, _)| candidate == name),+ Some((2, name.to_string(), 2))+ );+ assert_eq!(+ candidates().find(|(_, candidate, _)| candidate == "Unavailable"),+ None+ );+}diff --git a/codex-rs/voice-host/src/devices_unavailable.rs b/codex-rs/voice-host/src/devices_unavailable.rsindex 03af795eb1..238b5f385e 100644--- a/codex-rs/voice-host/src/devices_unavailable.rs+++ b/codex-rs/voice-host/src/devices_unavailable.rs@@ -2,31 +2,39 @@use std::io;+pub(super) fn list_devices(+ _: codex_realtime_webrtc::AudioDeviceKind,+) -> io::Result<Vec<codex_realtime_webrtc::AudioDevice>> {+ Err(io::Error::other(+ "audio devices unavailable for this helper target",+ ))+}+pub(super) struct Devices;impl Devices {pub(super) fn receive(&self, _: crate::incoming::ReceivedRtp) -> io::Result<()> {- Self::open().map(|_| ())+ Self::open(Default::default()).map(|_| ())}pub(super) fn take_state(&self) -> io::Result<codex_realtime_webrtc::AudioState> {- Self::open().map(|_| codex_realtime_webrtc::AudioState::default())+ Self::open(Default::default()).map(|_| codex_realtime_webrtc::AudioState::default())}- pub(super) fn open() -> io::Result<Self> {+ pub(super) fn open(_: codex_realtime_webrtc::AudioDeviceSelection) -> io::Result<Self> {Err(io::Error::other("audio devices unavailable for this helper target",))}pub(super) fn set_controls(&self, _: codex_realtime_webrtc::AudioControls) -> io::Result<()> {- Self::open().map(|_| ())+ Self::open(Default::default()).map(|_| ())}pub(super) async fn service(&mut self,_: &mut crate::audio_track::AudioTrack,) -> io::Result<usize> {- Self::open().map(|_| 0)+ Self::open(Default::default()).map(|_| 0)}}diff --git a/codex-rs/voice-host/src/main.rs b/codex-rs/voice-host/src/main.rsindex 709521aa0e..cd40fddf56 100644--- a/codex-rs/voice-host/src/main.rs+++ b/codex-rs/voice-host/src/main.rs@@ -168,9 +168,14 @@ fn run(.unwrap_or_default(),}}- Ok(Message::OpenDevices {}) if devices.is_none() && runtime.is_some() && answered => {+ Ok(Message::ListDevices { kind }) => Message::DeviceList {+ devices: devices::list_devices(kind)?,+ },+ Ok(Message::OpenDevices { selection })+ if devices.is_none() && runtime.is_some() && answered =>+ {phase.set(HelperExitStage::OpenDevices);- devices = Some(devices::Devices::open()?);+ devices = Some(devices::Devices::open(selection)?);Message::DevicesOpened {}}Ok(Message::SetAudioControls { controls }) => {@@ -248,7 +253,8 @@ fn run(| Message::Offer { .. }| Message::TransportReady {}| Message::TransportTimedOut {}- | Message::OpenDevices {}+ | Message::DeviceList { .. }+ | Message::OpenDevices { .. }| Message::DevicesOpened {}| Message::AudioControlsApplied {}| Message::AudioState { .. }