Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Preserve background thread requests when forking in the TUI (#49783)

Eric Traut106772e3c68b
diff --git a/codex-rs/tui/src/app/app_server_events.rs b/codex-rs/tui/src/app/app_server_events.rs
index 6ef3ceadff..a40e44ea5f 100644
--- a/codex-rs/tui/src/app/app_server_events.rs
+++ b/codex-rs/tui/src/app/app_server_events.rs
@@ -688,6 +688,7 @@ impl App {
}
if let Some(thread_id) = thread_id
&& self.primary_thread_id != Some(thread_id)
+ && self.active_thread_id != Some(thread_id)
&& !unsupported_request
&& !background_voice
&& let Some(requests) = self.agents_overview.dispatched_requests.get_mut(&thread_id)
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index 05214a85cd..2e2b910a4a 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -578,6 +578,15 @@ impl App {
} else {
None
};
+ if !app_server.uses_embedded_app_server() {
+ // Daemon tasks can start while the fork RPC is pending.
+ for id in self.thread_event_channels.keys().copied()
+ .chain(self.agent_navigation.tracked_thread_ids())
+ .filter(|id| !self.side_threads.contains_key(id))
+ {
+ self.agents_overview.dispatched_requests.entry(id).or_default();
+ }
+ }
self.detach_current_thread_for_navigation(app_server, Some(forked.session.thread_id)).await;
match self
.replace_chat_widget_with_app_server_thread(
diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs
index 7273fe5c7f..4ffd85ed63 100644
--- a/codex-rs/tui/src/app/session_lifecycle.rs
+++ b/codex-rs/tui/src/app/session_lifecycle.rs
@@ -797,6 +797,16 @@ impl App {
pub(super) async fn reset_thread_event_state(&mut self) {
let voice_owner = self.voice_owner_thread_id();
+ // Move retained tasks' approvals to background routing before clearing request bookkeeping.
+ for (thread_id, requests) in &mut self.agents_overview.dispatched_requests {
+ if let Some(channel) = self.thread_event_channels.get(thread_id) {
+ for request in channel.store.lock().await.pending_replay_requests() {
+ if !requests.iter().any(|pending| pending.id() == request.id()) {
+ requests.push(request);
+ }
+ }
+ }
+ }
if voice_owner.is_some() {
for (thread_id, channel) in &self.thread_event_channels {
if Some(*thread_id) != voice_owner {
@@ -808,7 +818,8 @@ impl App {
}
}
self.thread_event_listener_tasks.retain(|id, task| {
- if Some(*id) == voice_owner {
+ if Some(*id) == voice_owner || self.agents_overview.dispatched_requests.contains_key(id)
+ {
true
} else {
task.abort();
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 35aeb41eb3..d335cc7753 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -4241,8 +4241,15 @@ async fn inactive_thread_file_change_approval_recovers_buffered_changes() {
#[tokio::test]
async fn active_thread_file_change_approval_recovers_buffered_changes() {
let (mut app, _app_event_rx, _op_rx) = make_test_app_with_channels().await;
+ let app_server = crate::start_embedded_app_server_for_picker(&app.config)
+ .await
+ .expect("embedded app server");
let thread_id = ThreadId::new();
app.active_thread_id = Some(thread_id);
+ app.primary_thread_id = Some(ThreadId::new());
+ app.agents_overview
+ .dispatched_requests
+ .insert(thread_id, Vec::new());
app.startup_protected_input_boundary = true;
app.enqueue_thread_notification(
thread_id,
@@ -4275,10 +4282,15 @@ async fn active_thread_file_change_approval_recovers_buffered_changes() {
grant_root: None,
},
};
- assert_eq!(
+ app.handle_app_server_event(
+ &app_server,
+ codex_app_server_client::AppServerEvent::ServerRequest(Box::new(request.clone())),
+ )
+ .await;
+ assert!(app.agents_overview.dispatched_requests[&thread_id].is_empty());
+ assert!(
app.pending_app_server_requests
- .note_server_request(&request),
- None
+ .contains_server_request(&request)
);
app.chat_widget.handle_server_notification(
agent_message_delta_notification(thread_id, "turn-active-approval", "agent-1", "streaming"),
@@ -4311,6 +4323,7 @@ async fn active_thread_file_change_approval_recovers_buffered_changes() {
let destination = app.chat_widget.config_ref().cwd.join("visible-target.md");
assert!(rendered.contains("Description: Apply proposed file edits"));
assert!(rendered.contains(&format!("Destination: {}", destination.display())));
+ app_server.shutdown().await.expect("shutdown app server");
}
#[tokio::test]
diff --git a/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs b/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
index f4cb2064f3..11c7e68b8b 100644
--- a/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
+++ b/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
@@ -27,6 +27,7 @@ async fn fork_current_session_preserves_conversation_ultra() -> Result<()> {
reasoning_effort: Some(ReasoningEffortConfig::Ultra),
..test_thread_session(source_thread_id, test_path_buf("/tmp/project"))
});
+ app.ensure_thread_channel(source_thread_id);
let mut tui = crate::tui::test_support::make_test_tui()?;
let mut app_server = crate::start_embedded_app_server_for_picker(&app.config).await?;
@@ -39,6 +40,12 @@ async fn fork_current_session_preserves_conversation_ultra() -> Result<()> {
assert!(matches!(control, AppRunControl::Continue));
assert_ne!(app.chat_widget.thread_id(), Some(source_thread_id));
+ assert!(
+ !app.agents_overview
+ .dispatched_requests
+ .contains_key(&source_thread_id)
+ );
+ assert!(!app.thread_event_channels.contains_key(&source_thread_id));
assert_eq!(app.chat_widget.current_model(), "gpt-5.4");
assert_eq!(
app.chat_widget.current_reasoning_effort(),
diff --git a/codex-rs/tui/src/app/tests/fork_workspace_roots_tests.rs b/codex-rs/tui/src/app/tests/fork_workspace_roots_tests.rs
index b18a99ebae..b6e4a48dbb 100644
--- a/codex-rs/tui/src/app/tests/fork_workspace_roots_tests.rs
+++ b/codex-rs/tui/src/app/tests/fork_workspace_roots_tests.rs
@@ -1,13 +1,25 @@
//! Remote forks must retain server roots after reloading the client's configuration.
use super::session_lifecycle_requests::recorded_params;
+use super::session_lifecycle_requests::start_recording_app_server;
use super::session_lifecycle_requests::start_recording_remote_app_server;
use super::*;
+use crate::app_server_session::ThreadParamsMode;
use app_test_support::create_fake_rollout;
+use codex_app_server_client::AppServerEvent;
use pretty_assertions::assert_eq;
#[tokio::test]
async fn remote_fork_dispatch_preserves_server_workspace_roots() -> Result<()> {
+ check_fork_dispatch(ThreadParamsMode::Remote).await
+}
+
+#[tokio::test]
+async fn local_daemon_fork_dispatch_preserves_idle_source_and_children() -> Result<()> {
+ check_fork_dispatch(ThreadParamsMode::Embedded).await
+}
+
+async fn check_fork_dispatch(mode: ThreadParamsMode) -> Result<()> {
let mut app = Box::pin(make_test_app()).await;
let client_home = tempdir()?;
let server_home = tempdir()?;
@@ -33,8 +45,20 @@ async fn remote_fork_dispatch_preserves_server_workspace_roots() -> Result<()> {
})
.build()
.await?;
- let (server, requests, proxy) =
- Box::pin(start_recording_remote_app_server(&server_config)).await?;
+ let (server, requests, proxy) = match mode {
+ ThreadParamsMode::Remote => {
+ Box::pin(start_recording_remote_app_server(&server_config)).await?
+ }
+ ThreadParamsMode::Embedded => {
+ app.config = server_config.clone();
+ Box::pin(start_recording_app_server(
+ &server_config,
+ /*blocked_thread_list*/ None,
+ /*failed_thread_name*/ None,
+ ))
+ .await?
+ }
+ };
let mut server = server.with_remote_cwd_override(Some(remote_cwd.to_path_buf()));
let source_thread_id = ThreadId::from_string(
&create_fake_rollout(
@@ -59,8 +83,27 @@ async fn remote_fork_dispatch_preserves_server_workspace_roots() -> Result<()> {
assert_eq!(started.session.runtime_workspace_roots, expected_roots);
app.enqueue_primary_thread_session(started.session, started.turns)
.await?;
+ app.thread_event_listener_tasks
+ .insert(source_thread_id, tokio::spawn(std::future::pending::<()>()));
let mut tui = crate::tui::test_support::make_test_tui()?;
-
+ let pending = if mode == ThreadParamsMode::Remote {
+ let approval = exec_approval_request(
+ source_thread_id,
+ "source-turn",
+ "command",
+ /*approval_id*/ None,
+ );
+ app.enqueue_thread_request(source_thread_id, approval.clone())
+ .await?;
+ app.drain_active_thread_events(&mut tui).await?;
+ vec![approval]
+ } else {
+ Vec::new()
+ };
+ let child_id = ThreadId::new();
+ app.upsert_agent_picker_thread(
+ child_id, /*agent_nickname*/ None, /*agent_role*/ None, /*is_closed*/ false,
+ );
Box::pin(app.handle_event(
&mut tui,
&mut server,
@@ -75,6 +118,31 @@ async fn remote_fork_dispatch_preserves_server_workspace_roots() -> Result<()> {
.map(|params| params["runtimeWorkspaceRoots"].clone())
.collect();
assert_eq!(fork_roots, vec![serde_json::json!(expected_roots)]);
+ assert!(recorded_params(&requests, "thread/unsubscribe").is_empty());
+ assert!(!app.thread_event_listener_tasks[&source_thread_id].is_finished());
+ assert_eq!(
+ app.agents_overview.dispatched_requests[&source_thread_id],
+ pending
+ );
+ assert!(app.agents_overview.dispatched_requests[&child_id].is_empty());
+ let question = request_user_input_request(source_thread_id, "source-turn", "question");
+ app.handle_app_server_event(
+ &server,
+ AppServerEvent::ServerRequest(Box::new(question.clone())),
+ )
+ .await;
+ assert_eq!(
+ app.agents_overview.dispatched_requests[&source_thread_id].last(),
+ Some(&question)
+ );
+ assert!(!app.chat_widget.has_active_view());
+ Box::pin(app.select_agents_overview_thread(&mut tui, &mut server, source_thread_id)).await?;
+ app.drain_active_thread_events(&mut tui).await?;
+ assert!(
+ app.pending_app_server_requests
+ .contains_server_request(&question)
+ );
+ app.discard_thread_local_state(source_thread_id).await;
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 4c788dc0f7..9103a17412 100644
--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
@@ -1366,20 +1366,29 @@ async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths()
)
.send(),
);
- let registration = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
- .await?
- .expect("fork registration event");
- let AppEvent::DynamicToolThreadStarted { thread, .. } = &registration else {
- panic!("expected the MCP fork to register")
- };
- let forked_thread_id = ThreadId::from_string(&thread.id)?;
- let expected_thread = thread.clone();
+ let mut registered_ids = Vec::new();
let mut tui = crate::tui::test_support::make_test_tui()?;
- Box::pin(app.handle_event(&mut tui, &mut app_server, registration)).await?;
- assert_eq!(
- app.agents_overview.threads[&forked_thread_id],
- Some(expected_thread)
- );
+ for _ in 0..2 {
+ let registration = tokio::time::timeout(Duration::from_secs(/*secs*/ 5), events.recv())
+ .await?
+ .expect("fork registration event");
+ let AppEvent::DynamicToolThreadStarted { thread, .. } = &registration else {
+ panic!("expected the MCP fork to register")
+ };
+ let forked_thread_id = ThreadId::from_string(&thread.id)?;
+ let expected_thread = thread.clone();
+ if registered_ids.is_empty() {
+ assert!(recorded_params(&requests, "thread/fork").is_empty());
+ }
+ Box::pin(app.handle_event(&mut tui, &mut app_server, registration)).await?;
+ assert_eq!(
+ app.agents_overview.threads[&forked_thread_id],
+ Some(expected_thread)
+ );
+ registered_ids.push(forked_thread_id);
+ }
+ assert_eq!(registered_ids[0], fork_source);
+ let forked_thread_id = registered_ids[1];
let forked = forked.await??;
assert!(forked.status().is_success());
assert!(forked.text().await?.contains(&forked_thread_id.to_string()));
diff --git a/codex-rs/tui/src/dynamic_tools.rs b/codex-rs/tui/src/dynamic_tools.rs
index d9829d5548..10c568e1ec 100644
--- a/codex-rs/tui/src/dynamic_tools.rs
+++ b/codex-rs/tui/src/dynamic_tools.rs
@@ -565,6 +565,13 @@ async fn execute_inner(
.thread_id
.unwrap_or_else(|| params.thread_id.clone());
let thread = read_thread(&handle, &thread_id).await?;
+ // Keep source requests routable while the fork is being created.
+ register_background_thread(
+ app_event_tx,
+ thread.clone(),
+ /*task_tools_available*/ false,
+ )
+ .await?;
let before_turn_id = if same_thread_id(&thread_id, &params.thread_id) {
Some(params.turn_id)
} else if matches!(thread.status, ThreadStatus::Active { .. }) {