Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Keep TUI prompt history tied to local settings (#42791)

Eric Trauta07158c7846e
diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rs
index 2bef831f0e..16ccf159ec 100644
--- a/codex-rs/tui/src/app/agents_overview.rs
+++ b/codex-rs/tui/src/app/agents_overview.rs
@@ -652,6 +652,7 @@ impl App {
);
match app_server
.start_thread_with_session_start_source(
+ &self.local_settings,
&config,
/*session_start_source*/ None,
remote_cwd.as_deref(),
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index b44fcedb6a..8ecb84b3b4 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -483,6 +483,7 @@ impl App {
Ok(_) => {
app_server
.start_thread_with_session_start_source(
+&self.local_settings,
&config, /*session_start_source*/ None,
/*remote_cwd_override*/ None,
)
diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs
index 1516e3f11d..57adffe69a 100644
--- a/codex-rs/tui/src/app/session_lifecycle.rs
+++ b/codex-rs/tui/src/app/session_lifecycle.rs
@@ -857,6 +857,7 @@ impl App {
);
match app_server
.start_thread_with_session_start_source(
+ &self.local_settings,
&config,
session_start_source,
/*remote_cwd_override*/ None,
diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs
index edbcf2d590..1a459dd9bb 100644
--- a/codex-rs/tui/src/app/startup.rs
+++ b/codex-rs/tui/src/app/startup.rs
@@ -22,6 +22,7 @@ async fn resolve_runtime_model_provider_base_url(provider: &ModelProviderInfo) -
fn spawn_startup_thread_start(
app_server: &AppServerSession,
+ local_settings: crate::local_settings::LocalSettings,
config: Config,
app_event_tx: AppEventSender,
) {
@@ -32,6 +33,7 @@ fn spawn_startup_thread_start(
tokio::spawn(async move {
let result = crate::app_server_session::start_thread_with_request_handle(
request_handle,
+ &local_settings,
config,
thread_params_mode,
remote_cwd_override,
@@ -288,7 +290,12 @@ impl App {
| SessionSelection::Exit
| SessionSelection::AgentsOverview => {
if !start_in_agents_overview {
- spawn_startup_thread_start(&app_server, config.clone(), app_event_tx.clone());
+ spawn_startup_thread_start(
+ &app_server,
+ local_settings.clone(),
+ config.clone(),
+ app_event_tx.clone(),
+ );
}
// Count a startup tooltip once the initial chat widget can render it.
let startup_tooltip_override = if start_in_agents_overview {
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index be41bbfd28..8eae20f130 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -702,7 +702,16 @@ async fn history_lookup_response_is_routed_to_requesting_thread() -> Result<()>
let (mut app, mut app_event_rx, _op_rx) = make_test_app_with_channels().await;
let thread_id = ThreadId::new();
- app.lookup_message_history_entry(thread_id, /*offset*/ 0, /*log_id*/ 1)
+ let local_home = tempfile::tempdir()?;
+ app.local_settings.codex_home = AbsolutePathBuf::from_absolute_path(local_home.path())?;
+ let history_config = codex_message_history::HistoryConfig::new(
+ app.local_settings.codex_home.clone(),
+ &app.local_settings.history,
+ );
+ codex_message_history::append_entry("local prompt", thread_id, &history_config).await?;
+ let (log_id, _) = codex_message_history::history_metadata(&history_config).await;
+
+ app.lookup_message_history_entry(thread_id, /*offset*/ 0, log_id)
.await?;
let app_event = tokio::time::timeout(Duration::from_secs(1), app_event_rx.recv())
@@ -722,13 +731,13 @@ async fn history_lookup_response_is_routed_to_requesting_thread() -> Result<()>
event,
HistoryLookupResponse::Entry {
offset: 0,
- log_id: 1,
- entry: None,
+ log_id,
+ entry: Some("local prompt".to_string()),
}
);
- let cursor = codex_message_history::HistoryBatchCursor::new(/*end_offset*/ 10);
- app.lookup_message_history_batch(thread_id, cursor, /*log_id*/ 1)
+ let cursor = codex_message_history::HistoryBatchCursor::new(/*end_offset*/ 1);
+ app.lookup_message_history_batch(thread_id, cursor, log_id)
.await?;
let app_event = tokio::time::timeout(Duration::from_secs(1), app_event_rx.recv())
.await
@@ -744,7 +753,15 @@ async fn history_lookup_response_is_routed_to_requesting_thread() -> Result<()>
assert_eq!(routed_thread_id, thread_id);
assert_eq!(
event,
- HistoryLookupResponse::BatchError { cursor, log_id: 1 }
+ HistoryLookupResponse::Batch {
+ cursor,
+ log_id,
+ entries: vec![HistoryBatchEntryResponse {
+ offset: 0,
+ entry: Some("local prompt".to_string()),
+ }],
+ next_older_cursor: None,
+ }
);
Ok(())
diff --git a/codex-rs/tui/src/app/tests/disconnect_tests.rs b/codex-rs/tui/src/app/tests/disconnect_tests.rs
index 8410711ac0..59bb0fd583 100644
--- a/codex-rs/tui/src/app/tests/disconnect_tests.rs
+++ b/codex-rs/tui/src/app/tests/disconnect_tests.rs
@@ -322,6 +322,7 @@ async fn lost_initial_thread_reply_keeps_startup_draft_offline() -> Result<()> {
);
let result = crate::app_server_session::start_thread_with_request_handle(
session.request_handle(),
+ &app.local_settings,
app.config.clone(),
ThreadParamsMode::Remote,
/*remote_cwd_override*/ None,
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 3a751d426e..91046dfc3d 100644
--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
@@ -532,6 +532,7 @@ async fn external_transport_registers_dynamic_tools_and_finds_task_mentions() ->
assert!(app_server.task_tools_available(started.session.thread_id));
let startup = crate::app_server_session::start_thread_with_request_handle(
app_server.request_handle(),
+ &app.local_settings,
app.config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
@@ -690,6 +691,7 @@ async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths()
assert!(app_server.task_tools_available(thread_id));
let startup = crate::app_server_session::start_thread_with_request_handle(
app_server.request_handle(),
+ &app.local_settings,
app.config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
@@ -1050,6 +1052,7 @@ async fn older_external_server_starts_without_unsupported_dynamic_tools_or_histo
assert!(!app_server.task_tools_available(started.session.thread_id));
let startup = crate::app_server_session::start_thread_with_request_handle(
app_server.request_handle(),
+ &app.local_settings,
app.config.clone(),
crate::app_server_session::ThreadParamsMode::Embedded,
/*remote_cwd_override*/ None,
diff --git a/codex-rs/tui/src/app/working_directory.rs b/codex-rs/tui/src/app/working_directory.rs
index 66e4eacf59..09ec332341 100644
--- a/codex-rs/tui/src/app/working_directory.rs
+++ b/codex-rs/tui/src/app/working_directory.rs
@@ -156,7 +156,10 @@ impl App {
} else {
app_server
.start_thread_with_session_start_source(
- &config, /*session_start_source*/ None, /*remote_cwd_override*/ None,
+ &local_settings,
+ &config,
+ /*session_start_source*/ None,
+ /*remote_cwd_override*/ None,
)
.await
};
diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs
index f68dddb88e..c38e085d1d 100644
--- a/codex-rs/tui/src/app_server_session.rs
+++ b/codex-rs/tui/src/app_server_session.rs
@@ -769,13 +769,17 @@ impl AppServerSession {
#[cfg(test)]
pub(crate) async fn start_thread(&mut self, config: &Config) -> Result<AppServerStartedThread> {
self.start_thread_with_session_start_source(
- config, /*session_start_source*/ None, /*remote_cwd_override*/ None,
+ &LocalSettings::from(config),
+ config,
+ /*session_start_source*/ None,
+ /*remote_cwd_override*/ None,
)
.await
}
pub(crate) async fn start_thread_with_session_start_source(
&mut self,
+ local_settings: &LocalSettings,
config: &Config,
session_start_source: Option<ThreadStartSource>,
remote_cwd_override: Option<&std::path::Path>,
@@ -802,8 +806,13 @@ impl AppServerSession {
if history_support == ThreadHistorySupport::LegacyOnly {
self.history_support = ThreadHistorySupport::LegacyOnly;
}
- let mut started =
- started_thread_from_start_response(response, config, self.thread_params_mode()).await?;
+ let mut started = started_thread_from_start_response(
+ response,
+ local_settings,
+ config,
+ self.thread_params_mode(),
+ )
+ .await?;
started.task_tools_available = task_tools_available;
if task_tools_available {
self.remember_task_tool_thread(started.session.thread_id);
@@ -958,8 +967,13 @@ impl AppServerSession {
"preserving the created fork after bounded history hydration failed"
);
}
- let mut started =
- started_thread_from_fork_response(response, &config, self.thread_params_mode()).await?;
+ let mut started = started_thread_from_fork_response(
+ response,
+ local_settings,
+ &config,
+ self.thread_params_mode(),
+ )
+ .await?;
started.session.fork_parent_title = fork_parent.and_then(|thread| thread.name);
if self.task_tools_available(thread_id) {
started.task_tools_available = true;
@@ -1621,6 +1635,7 @@ impl AppServerSession {
pub(crate) async fn start_thread_with_request_handle(
request_handle: AppServerRequestHandle,
+ local_settings: &LocalSettings,
config: Config,
thread_params_mode: ThreadParamsMode,
remote_cwd_override: Option<PathBuf>,
@@ -1641,7 +1656,8 @@ pub(crate) async fn start_thread_with_request_handle(
bootstrap_request_error("thread/start failed during TUI bootstrap", err)
})?;
let mut started =
- started_thread_from_start_response(response, &config, thread_params_mode).await?;
+ started_thread_from_start_response(response, local_settings, &config, thread_params_mode)
+ .await?;
started.task_tools_available = task_tools_available;
Ok(started)
}
@@ -2069,14 +2085,19 @@ fn thread_cwd_from_config(
async fn started_thread_from_start_response(
response: ThreadStartResponse,
+ local_settings: &LocalSettings,
config: &Config,
thread_params_mode: ThreadParamsMode,
) -> Result<AppServerStartedThread> {
let blocks_direct_input = thread_blocks_direct_input(&response.thread);
- let session =
- thread_session_state_from_thread_start_response(&response, config, thread_params_mode)
- .await
- .map_err(color_eyre::eyre::Report::msg)?;
+ let session = thread_session_state_from_thread_start_response(
+ &response,
+ local_settings,
+ config,
+ thread_params_mode,
+ )
+ .await
+ .map_err(color_eyre::eyre::Report::msg)?;
Ok(AppServerStartedThread {
session,
turns: response.thread.turns,
@@ -2087,14 +2108,19 @@ async fn started_thread_from_start_response(
async fn started_thread_from_resume_response(
response: ThreadResumeResponse,
+ local_settings: &LocalSettings,
config: &Config,
thread_params_mode: ThreadParamsMode,
) -> Result<AppServerStartedThread> {
let blocks_direct_input = thread_blocks_direct_input(&response.thread);
- let session =
- thread_session_state_from_thread_resume_response(&response, config, thread_params_mode)
- .await
- .map_err(color_eyre::eyre::Report::msg)?;
+ let session = thread_session_state_from_thread_resume_response(
+ &response,
+ local_settings,
+ config,
+ thread_params_mode,
+ )
+ .await
+ .map_err(color_eyre::eyre::Report::msg)?;
Ok(AppServerStartedThread {
session,
turns: response.thread.turns,
@@ -2105,14 +2131,19 @@ async fn started_thread_from_resume_response(
async fn started_thread_from_fork_response(
response: ThreadForkResponse,
+ local_settings: &LocalSettings,
config: &Config,
thread_params_mode: ThreadParamsMode,
) -> Result<AppServerStartedThread> {
let blocks_direct_input = thread_blocks_direct_input(&response.thread);
- let session =
- thread_session_state_from_thread_fork_response(&response, config, thread_params_mode)
- .await
- .map_err(color_eyre::eyre::Report::msg)?;
+ let session = thread_session_state_from_thread_fork_response(
+ &response,
+ local_settings,
+ config,
+ thread_params_mode,
+ )
+ .await
+ .map_err(color_eyre::eyre::Report::msg)?;
Ok(AppServerStartedThread {
session,
turns: response.thread.turns,
@@ -2123,6 +2154,7 @@ async fn started_thread_from_fork_response(
async fn thread_session_state_from_thread_start_response(
response: &ThreadStartResponse,
+ local_settings: &LocalSettings,
config: &Config,
thread_params_mode: ThreadParamsMode,
) -> Result<ThreadSessionState, String> {
@@ -2148,13 +2180,15 @@ async fn thread_session_state_from_thread_start_response(
response.runtime_workspace_roots.clone(),
response.instruction_source_path_uris(),
response.reasoning_effort.clone(),
- config,
+ config.personality,
+ local_settings,
)
.await
}
async fn thread_session_state_from_thread_resume_response(
response: &ThreadResumeResponse,
+ local_settings: &LocalSettings,
config: &Config,
thread_params_mode: ThreadParamsMode,
) -> Result<ThreadSessionState, String> {
@@ -2189,13 +2223,15 @@ async fn thread_session_state_from_thread_resume_response(
response.runtime_workspace_roots.clone(),
response.instruction_source_path_uris(),
response.reasoning_effort.clone(),
- config,
+ config.personality,
+ local_settings,
)
.await
}
async fn thread_session_state_from_thread_fork_response(
response: &ThreadForkResponse,
+ local_settings: &LocalSettings,
config: &Config,
thread_params_mode: ThreadParamsMode,
) -> Result<ThreadSessionState, String> {
@@ -2221,7 +2257,8 @@ async fn thread_session_state_from_thread_fork_response(
response.runtime_workspace_roots.clone(),
response.instruction_source_path_uris(),
response.reasoning_effort.clone(),
- config,
+ config.personality,
+ local_settings,
)
.await
}
@@ -2271,7 +2308,8 @@ async fn thread_session_state_from_thread_response(
runtime_workspace_roots: Vec<AbsolutePathBuf>,
instruction_source_paths: Vec<PathUri>,
reasoning_effort: Option<codex_protocol::openai_models::ReasoningEffort>,
- config: &Config,
+ personality: Option<codex_protocol::config_types::Personality>,
+ local_settings: &LocalSettings,
) -> Result<ThreadSessionState, String> {
let thread_id = ThreadId::from_string(thread_id)
.map_err(|err| format!("thread id `{thread_id}` is invalid: {err}"))?;
@@ -2280,9 +2318,8 @@ async fn thread_session_state_from_thread_response(
.map(ThreadId::from_string)
.transpose()
.map_err(|err| format!("forked_from_id is invalid: {err}"))?;
- let local_settings = LocalSettings::from(config);
let history_config = codex_message_history::HistoryConfig::new(
- local_settings.codex_home,
+ local_settings.codex_home.clone(),
&local_settings.history,
);
let (log_id, entry_count) = codex_message_history::history_metadata(&history_config).await;
@@ -2303,7 +2340,7 @@ async fn thread_session_state_from_thread_response(
instruction_source_paths,
reasoning_effort,
collaboration_mode: None,
- personality: config.personality,
+ personality,
message_history: Some(MessageHistoryMetadata {
log_id,
entry_count,
@@ -2333,6 +2370,10 @@ pub(crate) fn app_server_rate_limit_snapshots(
snapshots
}
+#[cfg(test)]
+#[path = "app_server_session/prompt_history_tests.rs"]
+mod prompt_history_tests;
+
#[cfg(test)]
mod tests {
use super::*;
@@ -3780,6 +3821,7 @@ mod tests {
let started = started_thread_from_resume_response(
response.clone(),
+ &LocalSettings::from(&config),
&config,
ThreadParamsMode::Remote,
)
@@ -3810,6 +3852,7 @@ mod tests {
.expect("config should build");
let started = started_thread_from_resume_response(
response.clone(),
+ &LocalSettings::from(&embedded_config),
&embedded_config,
ThreadParamsMode::Embedded,
)
@@ -3821,6 +3864,7 @@ mod tests {
empty_roots_response.runtime_workspace_roots = Vec::new();
let started = started_thread_from_resume_response(
empty_roots_response,
+ &LocalSettings::from(&config),
&config,
ThreadParamsMode::Remote,
)
@@ -3907,7 +3951,8 @@ mod tests {
Vec::new(),
Vec::new(),
/*reasoning_effort*/ None,
- &config,
+ config.personality,
+ &LocalSettings::from(&config),
)
.await
.expect("session should map");
@@ -3942,7 +3987,8 @@ mod tests {
Vec::new(),
Vec::new(),
/*reasoning_effort*/ None,
- &config,
+ config.personality,
+ &LocalSettings::from(&config),
)
.await
.expect("session should map");
diff --git a/codex-rs/tui/src/app_server_session/prompt_history_tests.rs b/codex-rs/tui/src/app_server_session/prompt_history_tests.rs
new file mode 100644
index 0000000000..e5bc164c72
--- /dev/null
+++ b/codex-rs/tui/src/app_server_session/prompt_history_tests.rs
@@ -0,0 +1,89 @@
+//! Local prompt history stays independent of server settings across thread lifecycle requests.
+
+use super::*;
+use crate::legacy_core::config::ConfigBuilder;
+use app_test_support::create_fake_rollout;
+use codex_config::types::HistoryPersistence;
+use codex_message_history::HistoryConfig;
+use pretty_assertions::assert_eq;
+
+#[tokio::test]
+async fn lifecycle_metadata_uses_local_prompt_history() -> Result<()> {
+ let local_home = tempfile::tempdir()?;
+ let local_config = ConfigBuilder::default()
+ .codex_home(local_home.path().to_path_buf())
+ .build()
+ .await?;
+ let local_settings = LocalSettings::from(&local_config);
+ let history_config =
+ HistoryConfig::new(local_settings.codex_home.clone(), &local_settings.history);
+ codex_message_history::append_entry("local prompt", ThreadId::new(), &history_config).await?;
+ let (log_id, entry_count) = codex_message_history::history_metadata(&history_config).await;
+ let expected = Some(MessageHistoryMetadata {
+ log_id,
+ entry_count,
+ });
+ assert_eq!(entry_count, 1);
+
+ for mode in [ThreadParamsMode::Embedded, ThreadParamsMode::Remote] {
+ let server_home = tempfile::tempdir()?;
+ let mut config = ConfigBuilder::default()
+ .codex_home(server_home.path().to_path_buf())
+ .build()
+ .await?;
+ config.history.persistence = HistoryPersistence::None;
+ config.history.max_bytes = Some(1);
+ let thread_id = ThreadId::from_string(
+ &create_fake_rollout(
+ server_home.path(),
+ "2025-01-05T12-00-00",
+ "2025-01-05T12:00:00Z",
+ "Saved user message",
+ Some(config.model_provider_id.as_str()),
+ /*git_info*/ None,
+ )
+ .expect("create source rollout"),
+ )?;
+ let mut app_server = crate::start_embedded_app_server_for_picker(&config).await?;
+ app_server.thread_params_mode = mode;
+
+ let started = app_server
+ .start_thread_with_session_start_source(
+ &local_settings,
+ &config,
+ /*session_start_source*/ None,
+ /*remote_cwd_override*/ None,
+ )
+ .await?;
+ assert_eq!(started.session.message_history, expected);
+ let startup = start_thread_with_request_handle(
+ app_server.request_handle(),
+ &local_settings,
+ config.clone(),
+ mode,
+ /*remote_cwd_override*/ None,
+ app_server.thread_tool_transport(),
+ )
+ .await?;
+ assert_eq!(startup.session.message_history, expected);
+ let resumed = app_server
+ .resume_thread(
+ &local_settings,
+ config.clone(),
+ thread_id,
+ ResumeModelSettings::RestoreFromThread,
+ )
+ .await?;
+ assert_eq!(resumed.session.message_history, expected);
+ assert_eq!(resumed.session.thread_id, thread_id);
+ assert!(!resumed.turns.is_empty());
+ let forked = app_server
+ .fork_thread(&local_settings, config, thread_id)
+ .await?;
+ assert_eq!(forked.session.message_history, expected);
+ assert_eq!(forked.session.forked_from_id, Some(thread_id));
+ assert!(!forked.turns.is_empty());
+ app_server.shutdown().await?;
+ }
+ Ok(())
+}
diff --git a/codex-rs/tui/src/app_server_session/rollout_history.rs b/codex-rs/tui/src/app_server_session/rollout_history.rs
index 719c7ce4e6..c172d57989 100644
--- a/codex-rs/tui/src/app_server_session/rollout_history.rs
+++ b/codex-rs/tui/src/app_server_session/rollout_history.rs
@@ -146,9 +146,13 @@ impl AppServerSession {
let fork_parent_title = self
.fork_parent_title_from_app_server(response.thread.forked_from_id.as_deref())
.await;
- let mut started =
- started_thread_from_resume_response(response, &config, self.thread_params_mode())
- .await?;
+ let mut started = started_thread_from_resume_response(
+ response,
+ local_settings,
+ &config,
+ self.thread_params_mode(),
+ )
+ .await?;
started.session.fork_parent_title = fork_parent_title;
if self.task_tools_available(thread_id) {
self.remember_task_tool_thread(thread_id);