Lightweight coding agent that runs in your terminal
Rust
Use server defaults when starting TUI background tasks (#43261)
Eric Traut7bab4526f9df
diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rsindex 16ccf159ec..d8167e3851 100644--- a/codex-rs/tui/src/app/agents_overview.rs+++ b/codex-rs/tui/src/app/agents_overview.rs@@ -644,12 +644,73 @@ impl App {.add_error_message("Permission profile has different settings.".to_string());}self.apply_runtime_policy_overrides(&mut config, RuntimePolicyOverrideScope::All);+ let defaults_cwd = match app_server.thread_params_mode() {+ crate::app_server_session::ThreadParamsMode::Embedded => config.cwd.as_path(),+ crate::app_server_session::ThreadParamsMode::Remote => remote_cwd+ .as_deref()+ .or_else(|| app_server.remote_cwd_override())+ .unwrap_or(Path::new(".")),+ };+ let mut server_model_cleared = false;+ match super::new_session::read_new_session_defaults(app_server, defaults_cwd).await {+ Ok(Some(defaults)) => {+ server_model_cleared = defaults.model.is_none();+ let use_server_provider = matches!(+ app_server.thread_params_mode(),+ crate::app_server_session::ThreadParamsMode::Embedded+ ) && self.harness_overrides.model.is_none()+ && !super::new_session::has_launch_setting(+ &config,+ &self.cli_kv_overrides,+ "model",+ )+ && self.harness_overrides.model_provider.is_none()+ && !super::new_session::has_launch_setting(+ &config,+ &self.cli_kv_overrides,+ "model_provider",+ );+ super::new_session::overlay_new_session_defaults(+ &mut config,+ &defaults,+ &self.cli_kv_overrides,+ &self.harness_overrides,+ );+ // Embedded thread/start sends a provider ID alongside the selected model.+ if use_server_provider {+ config.model_provider_id = defaults+ .model_provider+ .unwrap_or_else(|| "openai".to_string());+ }+ }+ Ok(None) => {}+ Err(error) => {+ self.restore_agents_overview_prompt(prompt);+ return self.chat_widget.add_error_message(format!(+ "Failed to load background task settings: {error}"+ ));+ }+ }apply_managed_new_thread_defaults(&mut config,app_server.managed_new_thread_defaults(),&self.cli_kv_overrides,&self.harness_overrides,);+ if server_model_cleared+ && config.model.is_none()+ && config.features.enabled(Feature::FastMode)+ {+ // Bootstrap's fallback model may be seeded from the client. Resolve tiers+ // against the server catalog when config/read cleared the model.+ config.model = self+ .model_catalog+ .models+ .iter()+ .find(|model| model.is_default)+ .or_else(|| self.model_catalog.models.first())+ .map(|model| model.model.clone());+ }match app_server.start_thread_with_session_start_source(&self.local_settings,diff --git a/codex-rs/tui/src/app/new_session.rs b/codex-rs/tui/src/app/new_session.rsindex d4f986d7b0..d0361d8fcf 100644--- a/codex-rs/tui/src/app/new_session.rs+++ b/codex-rs/tui/src/app/new_session.rs@@ -36,31 +36,36 @@ pub(super) async fn read_new_session_defaults(}}+pub(super) fn has_launch_setting(+ config: &Config,+ cli_kv_overrides: &[(String, TomlValue)],+ key: &str,+) -> bool {+ // A remote server cannot resolve this invocation's explicitly selected local profile.+ cli_kv_overrides.iter().any(|(path, _)| path == key)+ || config.config_layer_stack.layers_high_to_low().any(|layer| {+ layer.disabled_reason.is_none()+ && matches!(+ layer.name,+ ConfigLayerSource::User {+ profile: Some(_),+ ..+ }+ )+ && layer.config.get(key).is_some()+ })+}+pub(super) fn overlay_new_session_defaults(config: &mut Config,defaults: &codex_app_server_protocol::Config,cli_kv_overrides: &[(String, TomlValue)],harness_overrides: &ConfigOverrides,) {- // A remote server cannot resolve this invocation's explicitly selected local profile.- let has_launch_setting = |key: &str| {- cli_kv_overrides.iter().any(|(path, _)| path == key)- || config.config_layer_stack.layers_high_to_low().any(|layer| {- layer.disabled_reason.is_none()- && matches!(- layer.name,- ConfigLayerSource::User {- profile: Some(_),- ..- }- )- && layer.config.get(key).is_some()- })- };- if harness_overrides.model.is_none() && !has_launch_setting("model") {+ if harness_overrides.model.is_none() && !has_launch_setting(config, cli_kv_overrides, "model") {config.model = defaults.model.clone();}- if !has_launch_setting("model_reasoning_effort") {+ if !has_launch_setting(config, cli_kv_overrides, "model_reasoning_effort") {config.model_reasoning_effort = defaults.model_reasoning_effort.clone();}}diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rsindex 6526014bd1..045369ce10 100644--- a/codex-rs/tui/src/app/tests.rs+++ b/codex-rs/tui/src/app/tests.rs@@ -15,6 +15,8 @@ mod backend_banner_recovery_tests;mod backend_banner_startup_tests;#[path = "tests/background_exit_tests.rs"]mod background_exit_tests;+#[path = "tests/background_task_defaults_tests.rs"]+mod background_task_defaults_tests;#[path = "tests/buffered_replay.rs"]mod buffered_replay;#[path = "tests/connector_policy.rs"]diff --git a/codex-rs/tui/src/app/tests/background_task_defaults_tests.rs b/codex-rs/tui/src/app/tests/background_task_defaults_tests.rsnew file mode 100644index 0000000000..504f0f7c84--- /dev/null+++ b/codex-rs/tui/src/app/tests/background_task_defaults_tests.rs@@ -0,0 +1,369 @@+//! Request-level coverage for background-task server defaults and dispatch recovery.++use super::*;+use crate::app::agents_overview::AGENTS_OVERVIEW_VIEW_ID;+use crate::app::tests::session_lifecycle_requests::HistoryCapabilities;+use crate::app::tests::session_lifecycle_requests::recorded_params;+use crate::app::tests::session_lifecycle_requests::start_recording_app_server_with_history;+use crate::test_support::PathBufExt;+use codex_state::SqliteConfig;+use pretty_assertions::assert_eq;++#[tokio::test]+async fn background_task_reads_server_defaults_for_actual_destination() -> Result<()> {+ for (mode, explicit_cwd, launch_override, expected_cwd, expected_model) in [+ ("local", false, false, "launch", "server-model"),+ ("local", true, false, "destination", "destination-model"),+ ("local-cli-provider", false, false, "launch", "server-model"),+ ("local-cli-model", false, false, "launch", "cli-model"),+ (+ "local-default-provider",+ false,+ false,+ "launch",+ "server-model",+ ),+ ("remote", true, true, "destination", "destination-model"),+ ("remote", false, true, "launch", "server-model"),+ ("remote", false, false, ".", "server-model"),+ ("remote-null-fast", false, false, ".", ""),+ ] {+ let client_home = tempdir()?;+ let server_home = tempdir()?;+ let launch = tempdir()?;+ let destination = tempdir()?;+ std::fs::write(+ client_home.path().join("config.toml"),+ format!(+ "model = \"{}\"\nmodel_reasoning_effort = \"low\"\n{}",+ if mode == "remote-null-fast" {+ "gpt-5.2"+ } else {+ "client-model"+ },+ if mode == "local-default-provider" {+ "model_provider = \"ollama\"\n"+ } else {+ ""+ }+ ),+ )?;+ std::fs::write(+ server_home.path().join("config.toml"),+ format!(+ "{}model_reasoning_effort = \"high\"\n{}",+ if mode == "remote-null-fast" {+ ""+ } else {+ "model = \"server-model\"\n"+ },+ if mode == "local" || mode == "local-cli-provider" || mode == "local-cli-model" {+ "model_provider = \"ollama\"\n"+ } else {+ ""+ }+ ),+ )?;+ std::fs::create_dir(destination.path().join(".codex"))?;+ std::fs::write(+ destination.path().join(".codex/config.toml"),+ "model = \"destination-model\"\nservice_tier = \"flex\"\n",+ )?;+ for home in [client_home.path(), server_home.path()] {+ crate::legacy_core::config::set_project_trust_level(+ home,+ destination.path(),+ codex_protocol::config_types::TrustLevel::Trusted,+ )+ .map_err(|error| color_eyre::eyre::eyre!(error.to_string()))?;+ }+ let mut app = make_test_app_with_channels().await.0;+ if mode == "local" && explicit_cwd {+ app.harness_overrides.model_provider = Some("openai".into());+ }+ if mode == "local-cli-provider" {+ app.cli_kv_overrides+ .push(("model_provider".into(), TomlValue::String("openai".into())));+ }+ if mode == "local-cli-model" {+ app.harness_overrides.model = Some("cli-model".into());+ }+ app.chat_widget.set_service_tier(Some("priority".into()));+ app.harness_overrides.cwd = Some(launch.path().to_path_buf());+ app.config = ConfigBuilder::default()+ .codex_home(client_home.path().to_path_buf())+ .loader_overrides(app.loader_overrides.clone())+ .cli_overrides(app.cli_kv_overrides.clone())+ .harness_overrides(app.harness_overrides.clone())+ .build()+ .await?;+ if mode == "remote-null-fast" {+ app.config.features.enable(Feature::FastMode)?;+ }+ app.chat_widget+ .handle_thread_session_quiet(test_thread_session(+ ThreadId::new(),+ launch.path().to_path_buf(),+ ));+ let mut server_config = app.config.clone();+ server_config.codex_home = server_home.path().to_path_buf().abs();+ server_config.sqlite = SqliteConfig::new_for_testing(server_home.path().abs());+ let thread_mode = if mode.starts_with("remote") {+ crate::app_server_session::ThreadParamsMode::Remote+ } else {+ crate::app_server_session::ThreadParamsMode::Embedded+ };+ let (mut server, requests, proxy) = start_recording_app_server_with_history(+ &server_config,+ HistoryCapabilities::Current,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ thread_mode,+ LoaderOverrides {+ user_config_path: Some(server_home.path().join("config.toml").abs()),+ ..LoaderOverrides::default()+ },+ )+ .await?;+ if launch_override {+ server = server.with_remote_cwd_override(Some(launch.path().to_path_buf()));+ }+ let bootstrap = server.bootstrap(&app.config).await?;+ let expected_model = if mode == "remote-null-fast" {+ let default_model = bootstrap+ .available_models+ .iter()+ .find(|model| model.is_default)+ .or_else(|| bootstrap.available_models.first())+ .expect("server catalog model")+ .model+ .clone();+ app.model_catalog = Arc::new(ModelCatalog::new(bootstrap.available_models));+ default_model+ } else {+ expected_model.to_string()+ };+ app.dispatch_agents_overview_task(+ &mut server,+ "background prompt".into(),+ explicit_cwd.then(|| destination.path().to_path_buf().abs()),+ )+ .await;+ let cwd = match expected_cwd {+ "launch" => launch.path().display().to_string(),+ "destination" => destination.path().display().to_string(),+ "." => ".".to_string(),+ _ => unreachable!(),+ };+ assert_eq!(+ recorded_params(&requests, "config/read"),+ vec![serde_json::json!({"cwd": cwd})],+ "{mode} {expected_cwd}"+ );+ let starts = recorded_params(&requests, "thread/start");+ assert_eq!(starts.len(), 1, "{mode} {expected_cwd}");+ assert_eq!(+ (+ &starts[0]["cwd"],+ &starts[0]["model"],+ &starts[0]["modelProvider"],+ &starts[0]["config"]["model_reasoning_effort"],+ &starts[0]["serviceTier"],+ ),+ (+ &if mode.starts_with("remote") && !explicit_cwd && !launch_override {+ serde_json::Value::Null+ } else {+ serde_json::json!(cwd)+ },+ &serde_json::json!(expected_model),+ &if mode.starts_with("remote") {+ serde_json::Value::Null+ } else if mode == "local" && !explicit_cwd {+ serde_json::json!("ollama")+ } else {+ serde_json::json!("openai")+ },+ &serde_json::json!("high"),+ &serde_json::json!(if mode == "local" && explicit_cwd {+ "flex"+ } else {+ "priority"+ }),+ ),+ "{mode} {expected_cwd}"+ );+ assert_eq!(recorded_params(&requests, "turn/start").len(), 1);+ server.shutdown().await?;+ proxy.await??;+ }+ Ok(())+}++#[tokio::test]+async fn background_task_preserves_explicit_choices_and_managed_defaults() -> Result<()> {+ for (choice, expected_model, expected_effort) in [+ ("saved", "server-model", "high"),+ ("cli_effort", "server-model", "low"),+ ("profile_model", "profile-model", "high"),+ ("managed", "managed-model", "medium"),+ ] {+ let client_home = tempdir()?;+ let server_home = tempdir()?;+ std::fs::write(+ client_home.path().join("config.toml"),+ "model = \"client-model\"\nmodel_reasoning_effort = \"low\"\n",+ )?;+ std::fs::write(+ server_home.path().join("config.toml"),+ "model = \"server-model\"\nmodel_reasoning_effort = \"high\"\n",+ )?;+ if choice == "managed" || choice.starts_with("cli_") {+ std::fs::write(+ server_home.path().join("requirements.toml"),+ "[models.new_thread]\nmodel = \"managed-model\"\nmodel_reasoning_effort = \"medium\"\n",+ )?;+ }+ let mut app = make_test_app_with_channels().await.0;+ match choice {+ "cli_effort" => app.cli_kv_overrides.push((+ "model_reasoning_effort".into(),+ TomlValue::String("low".into()),+ )),+ "profile_model" => {+ let path = client_home.path().join("work.config.toml");+ std::fs::write(&path, "model = \"profile-model\"\n")?;+ app.loader_overrides.user_config_path = Some(path.abs());+ app.loader_overrides.user_config_profile = Some("work".parse()?);+ }+ _ => {}+ }+ app.config = ConfigBuilder::default()+ .codex_home(client_home.path().to_path_buf())+ .loader_overrides(app.loader_overrides.clone())+ .cli_overrides(app.cli_kv_overrides.clone())+ .harness_overrides(app.harness_overrides.clone())+ .build()+ .await?;+ let mut server_config = app.config.clone();+ server_config.codex_home = server_home.path().to_path_buf().abs();+ server_config.sqlite = SqliteConfig::new_for_testing(server_home.path().abs());+ let (mut server, requests, proxy) = start_recording_app_server_with_history(+ &server_config,+ HistoryCapabilities::Current,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Remote,+ LoaderOverrides {+ user_config_path: Some(server_home.path().join("config.toml").abs()),+ system_requirements_path: Some(server_home.path().join("requirements.toml")),+ ..LoaderOverrides::default()+ },+ )+ .await?;+ server.bootstrap(&app.config).await?;+ app.dispatch_agents_overview_task(+ &mut server,+ "background prompt".into(),+ /*cwd*/ None,+ )+ .await;+ let starts = recorded_params(&requests, "thread/start");+ assert_eq!(starts.len(), 1, "{choice}");+ assert_eq!(+ (+ &starts[0]["model"],+ &starts[0]["config"]["model_reasoning_effort"]+ ),+ (+ &serde_json::json!(expected_model),+ &serde_json::json!(expected_effort)+ ),+ "{choice}"+ );+ assert_eq!(+ recorded_params(&requests, "turn/start").len(),+ 1,+ "{choice}"+ );+ server.shutdown().await?;+ proxy.await??;+ }+ Ok(())+}++#[tokio::test]+async fn background_task_read_failure_keeps_prompt_and_does_not_start() -> Result<()> {+ for capability in [+ HistoryCapabilities::ConfigReadFails,+ HistoryCapabilities::ConfigReadUnsupported(-32600),+ HistoryCapabilities::ConfigReadUnsupported(-32601),+ ] {+ let (mut app, mut events, _) = make_test_app_with_channels().await;+ app.harness_overrides.model = Some("local-model".into());+ let view = app.agents_overview_view(Vec::new(), /*selected_thread_id*/ None);+ app.chat_widget.show_bottom_pane_view(Box::new(view));+ let (mut server, requests, proxy) = start_recording_app_server_with_history(+ &app.config,+ capability,+ /*blocked_thread_list*/ None,+ /*failed_thread_name*/ None,+ crate::app_server_session::ThreadParamsMode::Embedded,+ LoaderOverrides::default(),+ )+ .await?;+ app.dispatch_agents_overview_task(+ &mut server,+ "retry background prompt".into(),+ /*cwd*/ None,+ )+ .await;+ let failed = capability == HistoryCapabilities::ConfigReadFails;+ assert_eq!(recorded_params(&requests, "config/read").len(), 1);+ assert_eq!(+ recorded_params(&requests, "thread/start").len(),+ usize::from(!failed)+ );+ assert_eq!(+ recorded_params(&requests, "turn/start").len(),+ usize::from(!failed)+ );+ if failed {+ assert!(app.agents_overview.dispatched_requests.is_empty());+ assert_eq!(+ app.agents_overview+ .view_state+ .lock()+ .unwrap()+ .composer+ .as_ref()+ .unwrap()+ .current_text_with_pending(),+ "retry background prompt"+ );+ assert!(+ app.chat_widget+ .selected_index_for_present_view(AGENTS_OVERVIEW_VIEW_ID)+ .is_some()+ );+ let error = std::iter::from_fn(|| events.try_recv().ok())+ .filter_map(|event| match event {+ AppEvent::InsertHistoryCell(cell) => {+ Some(lines_to_single_string(&cell.display_lines(/*width*/ 80)))+ }+ _ => None,+ })+ .find(|message| message.contains("Failed to load background task settings"))+ .expect("visible read error");+ insta::assert_snapshot!(error, @"■ Failed to load background task settings: config/read failed in TUI");+ } else {+ assert_eq!(+ recorded_params(&requests, "thread/start")[0]["model"],+ "local-model"+ );+ }+ server.shutdown().await?;+ proxy.await??;+ }+ Ok(())+}diff --git a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rsindex aac8229467..e8ff9b153e 100644--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs@@ -99,7 +99,7 @@ async fn same_thread_retry_keeps_subscription_and_restores_draft() -> Result<()>}#[derive(Clone, Copy, Debug, Eq, PartialEq)]-enum HistoryCapabilities {+pub(super) enum HistoryCapabilities {Current,LegacyOnly,LegacyOnlyUnsupportedVariant,@@ -158,7 +158,7 @@ pub(super) async fn start_recording_remote_app_server(}/// Proxies a real app server while optionally rejecting modern pagination like an older server.-async fn start_recording_app_server_with_history(+pub(super) async fn start_recording_app_server_with_history(config: &Config,history_capabilities: HistoryCapabilities,mut blocked_thread_list: Option<(ThreadId, oneshot::Sender<()>, oneshot::Receiver<()>)>,