Skip to content

armgit / codex

Public Imported from GitHub
0

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.rs
index 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.rs
index 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.rs
index 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.rs
new file mode 100644
index 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.rs
index 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<()>)>,