Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Reconnect TUI app-server sessions automatically (#41916)

Eric Traut907c34e86722
diff --git a/codex-rs/tui/src/app/agent_navigation.rs b/codex-rs/tui/src/app/agent_navigation.rs
index 3444ab4ee9..91964c688b 100644
--- a/codex-rs/tui/src/app/agent_navigation.rs
+++ b/codex-rs/tui/src/app/agent_navigation.rs
@@ -50,7 +50,7 @@ pub(crate) struct AgentNavigationState {
/// Spawned child threads whose instructions are owned by their parent agent.
parent_owned_threads: HashSet<ThreadId>,
/// Coalesces root refreshes while rejecting replies from a previous session.
- picker_refresh: Option<(ThreadId, Uuid)>,
+ pub(super) picker_refresh: Option<(ThreadId, Uuid)>,
}
/// Direction of keyboard traversal through the stable picker order.
diff --git a/codex-rs/tui/src/app/input.rs b/codex-rs/tui/src/app/input.rs
index 814f8be3d5..4675d78f2b 100644
--- a/codex-rs/tui/src/app/input.rs
+++ b/codex-rs/tui/src/app/input.rs
@@ -370,6 +370,17 @@ impl App {
return;
}
+ if !self.chat_widget.has_active_view()
+ && self
+ .current_displayed_thread_id()
+ .is_some_and(|id| self.thread_unavailable(id))
+ && !(key_event.modifiers.contains(KeyModifiers::CONTROL)
+ && matches!(key_event.code, KeyCode::Char('c' | 'd')))
+ {
+ self.chat_widget.handle_disconnected_key(key_event);
+ return;
+ }
+
if matches!(key_event.code, KeyCode::Esc)
&& matches!(key_event.kind, KeyEventKind::Press | KeyEventKind::Repeat)
{
diff --git a/codex-rs/tui/src/app/reconnect.rs b/codex-rs/tui/src/app/reconnect.rs
index 1054de0a02..3f6cf928ef 100644
--- a/codex-rs/tui/src/app/reconnect.rs
+++ b/codex-rs/tui/src/app/reconnect.rs
@@ -1,7 +1,11 @@
-//! Preserve local work after an external connection is lost. Offline input and stale
-//! async completions are quarantined; recovery requires relaunching the TUI.
+//! TUI-only out-of-process reconnection. Each attempt initializes a fresh client and rejoins existing
+//! threads using ordinary resume/history semantics; no user operation is retried.
+//! Offline input and old async completions are quarantined. Cached conversations stay read-only
+//! until they can be reattached; command-center recovery is handled separately.
use super::*;
+use crate::app_server_session::ResumeModelSettings;
+use crate::dynamic_tools_mcp::ThreadToolTransport;
#[derive(Clone, Copy, Default, PartialEq, Eq)]
pub(super) enum ReconnectPresentation {
@@ -13,10 +17,110 @@ pub(super) enum ReconnectPresentation {
#[derive(Default)]
pub(super) struct ReconnectState {
pub(super) offline: bool,
+ pub(super) failed: bool,
pub(super) presentation: ReconnectPresentation,
}
+pub(super) struct Reconnected {
+ session: AppServerSession,
+ bootstrap: AppServerBootstrap,
+ thread: Option<AppServerStartedThread>,
+}
+
+pub(super) async fn reconnect(
+ target: AppServerTarget,
+ config: Config,
+ thread_id: Option<ThreadId>,
+ remote_cwd: Option<PathBuf>,
+ task_tools: ThreadToolTransport,
+ presentation: ReconnectPresentation,
+) -> Result<Reconnected> {
+ let mode = target.thread_params_mode();
+ let endpoint = match target {
+ AppServerTarget::Remote { endpoint } | AppServerTarget::LocalDaemon { endpoint } => {
+ endpoint
+ }
+ AppServerTarget::Embedded => {
+ color_eyre::eyre::bail!("in-process sessions have no connection to restore")
+ }
+ };
+ if let ThreadToolTransport::Mcp(server) = &task_tools {
+ server.suspend();
+ }
+ if presentation == ReconnectPresentation::Conversation && thread_id.is_none() {
+ color_eyre::eyre::bail!(
+ "The initial thread may have been created, but its ID was not received. Nothing was retried. Your prompt is editable; inspect your tasks before relaunching."
+ );
+ }
+ // Connecting already has transport deadlines. Give healthy history/inventory hydration one
+ // shared budget instead of repeatedly discarding its progress on a short per-attempt timer.
+ let deadline = tokio::time::Instant::now() + Duration::from_secs(/*secs*/ 120);
+ for delay in [0, 1, 2, 4, 8] {
+ let attempt = async {
+ tokio::time::sleep(Duration::from_secs(delay)).await;
+ let client = crate::connect_remote_app_server(endpoint.clone()).await?;
+ let mut session = AppServerSession::new(client, mode)
+ .with_startup_config(&config)
+ .with_remote_cwd_override(remote_cwd.clone())
+ .with_thread_tool_transport(task_tools.clone());
+ let bootstrap = session.bootstrap(&config).await?;
+ let thread = if let Some(thread_id) = thread_id {
+ match session
+ .resume_thread(
+ config.clone(),
+ thread_id,
+ ResumeModelSettings::PreserveExistingThread,
+ )
+ .await
+ {
+ Ok(thread) => Some(thread),
+ Err(error)
+ if matches!(
+ error.downcast_ref::<TypedRequestError>(),
+ Some(TypedRequestError::Transport { .. })
+ ) =>
+ {
+ return Err(error);
+ }
+ Err(error)
+ if matches!(
+ error.downcast_ref::<TypedRequestError>(),
+ Some(TypedRequestError::Server { source, .. }) if source.code == -32600
+ ) || presentation == ReconnectPresentation::Overview =>
+ {
+ None
+ }
+ Err(error) => return Err(error),
+ }
+ } else {
+ None
+ };
+ Ok::<_, color_eyre::Report>(Reconnected {
+ session,
+ bootstrap,
+ thread,
+ })
+ };
+ let result = tokio::time::timeout_at(deadline, attempt).await;
+ match result {
+ Ok(Ok(connected)) => return Ok(connected),
+ Ok(Err(_)) => {}
+ Err(_) => break,
+ }
+ // Transport errors can contain endpoint credentials. Do not render or log them.
+ }
+ color_eyre::eyre::bail!("app-server session could not be restored")
+}
+
impl App {
+ pub(super) fn thread_unavailable(&self, id: ThreadId) -> bool {
+ !matches!(self.app_server_target, AppServerTarget::Embedded)
+ && self
+ .thread_event_channels
+ .get(&id)
+ .is_some_and(|channel| channel.attachment() == ThreadEventAttachment::ReplayOnly)
+ }
+
pub(super) fn recover_transport_error(&mut self, error: &color_eyre::Report) -> bool {
let disconnected = matches!(
error.downcast_ref::<TypedRequestError>(),
@@ -31,6 +135,7 @@ impl App {
}
if !self.reconnect.offline {
self.reconnect.offline = true;
+ self.reconnect.failed = false;
self.cancel_pending_key_chord();
self.overlay = None;
self.commit_animation = None;
@@ -63,4 +168,182 @@ impl App {
}
true
}
+
+ pub(super) async fn finish_reconnect(
+ &mut self,
+ tui: &mut tui::Tui,
+ app_server: &mut AppServerSession,
+ app_event_rx: &mut mpsc::UnboundedReceiver<AppEvent>,
+ connected: Reconnected,
+ ) -> Result<()> {
+ let Reconnected {
+ mut session,
+ bootstrap,
+ thread,
+ } = connected;
+ let displayed = self.current_displayed_thread_id();
+ let mut input = self.chat_widget.capture_thread_input_state();
+ if let Some(input) = input.as_mut() {
+ input.recovered_queue = true;
+ }
+ self.store_active_thread_receiver().await;
+ // Old request handles stay attached to the dead connection. Rotating the event channel
+ // prevents their late completions from submitting follow-up operations on the new one.
+ let (tx, rx) = mpsc::unbounded_channel();
+ self.app_event_tx = AppEventSender::new(tx);
+ *app_event_rx = rx;
+ self.agent_navigation.picker_refresh = None;
+ self.last_subagent_backfill_attempt = None;
+ self.rate_limit_refresh_state.invalidate_recovery();
+ session.inherit_task_tool_capabilities(app_server);
+ *app_server = session;
+ self.chat_widget.remote_connection =
+ crate::status::remote_connection::remote_connection_status_value(
+ &self.app_server_target,
+ app_server.server_version(),
+ );
+ self.workspace_command_runner = Some(Arc::new(AppServerWorkspaceCommandRunner::new(
+ app_server.request_handle(),
+ )));
+ self.file_search =
+ FileSearchManager::new(self.config.cwd.to_path_buf(), self.app_event_tx.clone());
+ self.model_catalog = Arc::new(ModelCatalog::new(bootstrap.available_models));
+ self.pending_app_server_requests.clear();
+ self.pending_primary_events.clear();
+ self.pending_plugin_enabled_writes.clear();
+ self.pending_hook_enabled_writes.clear();
+ self.temporary_structured_requests.clear();
+ self.agents_overview.dispatched_requests.clear();
+ self.agents_overview.request_id = None;
+ self.agents_overview.refresh_pending = false;
+ for input in self.agents_overview.input_states.values_mut() {
+ input.recovered_queue = true;
+ }
+ self.pending_startup_thread_start = false;
+ // Move cached UI state into fresh channels. Old producers retain the old sender/store,
+ // so their late requests cannot leak into recovery. Background threads attach on selection.
+ for channel in self.thread_event_channels.values_mut() {
+ let mut replacement = ThreadEventChannel::new(THREAD_EVENT_CHANNEL_CAPACITY);
+ replacement.mark_replay_only();
+ let mut store = std::mem::replace(
+ &mut *channel.store.lock().await,
+ ThreadEventStore::new(THREAD_EVENT_CHANNEL_CAPACITY),
+ );
+ store.pending_interactive_replay = Default::default();
+ store.pending_interrupt_turn_id = None;
+ store.active = false;
+ store
+ .buffer
+ .retain(|event| matches!(event, ThreadBufferedEvent::Notification(_)));
+ if let Some(input) = store.input_state.as_mut() {
+ input.recovered_queue = true;
+ }
+ *replacement.store.lock().await = store;
+ *channel = replacement;
+ }
+ if let Some(id) = self.current_displayed_thread_id()
+ && let Some(mut input) = input.clone()
+ {
+ input.recovered_queue = true;
+ self.agents_overview.input_states.insert(id, input);
+ }
+ if let Some(mut started) = thread {
+ let id = started.session.thread_id;
+ // A lost settings response can leave the server snapshot behind the user's choice.
+ // Side conversations can replace the app-wide overrides, so only restore choices
+ // that still match this conversation's own cached settings.
+ if (self.current_displayed_thread_id() == Some(id)
+ || self.primary_thread_id == Some(id))
+ && let Some(channel) = self.thread_event_channels.get(&id)
+ && let Some(cached) = channel.store.lock().await.session.as_ref()
+ {
+ if let Some(policy) = self.runtime_approval_policy_override
+ && policy == cached.approval_policy
+ {
+ started.session.approval_policy = policy;
+ }
+ if let Some(profile) = &self.runtime_permission_profile_override
+ && profile.permission_profile == cached.permission_profile
+ && profile.active_permission_profile == cached.active_permission_profile
+ && self.config.approvals_reviewer == cached.approvals_reviewer
+ {
+ started.session.permission_profile = profile.permission_profile.clone();
+ started.session.active_permission_profile =
+ profile.active_permission_profile.clone();
+ started.session.approvals_reviewer = self.config.approvals_reviewer;
+ }
+ }
+ self.agents_overview.input_states.remove(&id);
+ if started
+ .turns
+ .iter()
+ .any(|turn| turn.status == TurnStatus::InProgress)
+ {
+ self.agent_navigation.mark_running(id);
+ } else {
+ self.agent_navigation.mark_stopped(id);
+ }
+ if self.primary_thread_id == Some(id) {
+ self.primary_session_configured = Some(started.session.clone());
+ }
+ if started.blocks_direct_input {
+ self.agent_navigation.mark_parent_owned(id);
+ }
+ let channel = ThreadEventChannel::new(THREAD_EVENT_CHANNEL_CAPACITY);
+ {
+ let mut store = channel.store.lock().await;
+ store.set_session(started.session, started.turns);
+ store.input_state = input.clone();
+ }
+ self.thread_event_channels.insert(id, channel);
+ }
+ if let Some(id) = displayed
+ && let Some((receiver, snapshot)) = self.activate_thread_for_replay(id).await
+ {
+ self.active_thread_id = Some(id);
+ self.active_thread_rx = Some(receiver);
+ self.recap.seed_from_turns(&snapshot.turns, Instant::now());
+ self.render_thread_snapshot(
+ tui, app_server, id, snapshot, /*resume_restored_queue*/ false,
+ )?;
+ self.config = self.chat_widget.config_ref().clone();
+ self.refresh_pending_thread_approvals().await;
+ if self.thread_unavailable(id) {
+ self.agent_navigation.mark_stopped(id);
+ self.chat_widget.pause_unavailable_thread();
+ self.chat_widget.add_info_message("This conversation is unavailable. Its cached transcript and draft remain here; input is paused. Open the agent picker or return to the parent to continue.".into(), /*hint*/ None);
+ } else {
+ self.recap
+ .schedule_check(id, self.app_event_tx.clone(), Instant::now());
+ }
+ } else {
+ self.active_thread_id = None;
+ self.active_thread_rx = None;
+ self.primary_thread_id = None;
+ self.primary_session_configured = None;
+ let init = self.chatwidget_init_for_forked_or_resumed_thread(
+ tui,
+ self.config.clone(),
+ /*initial_user_message*/ None,
+ );
+ self.replace_chat_widget(ChatWidget::new_with_app_event(init));
+ self.chat_widget.restore_reconnected_input(input);
+ }
+ // Only accept fresh task-tool calls once this connection and its event queue are adopted.
+ if let ThreadToolTransport::Mcp(server) = app_server.thread_tool_transport() {
+ server.reconnect(app_server.request_handle(), self.app_event_tx.clone());
+ }
+ self.reconnect.offline = false;
+ self.chat_widget.update_account_state(
+ bootstrap.status_account_display,
+ bootstrap.plan_type,
+ bootstrap.has_chatgpt_account,
+ matches!(bootstrap.auth_mode, Some(TelemetryAuthMode::Chatgpt)),
+ );
+ self.feedback_audience = bootstrap.feedback_audience;
+ self.chat_widget.add_info_message(
+ "Reconnected. No input was resent. Review uncertain submissions before retrying; recovered queues remain paused.".into(), /*hint*/ None,
+ );
+ Ok(())
+ }
}
diff --git a/codex-rs/tui/src/app/session_lifecycle.rs b/codex-rs/tui/src/app/session_lifecycle.rs
index 96001c7f00..4a6a21f5a5 100644
--- a/codex-rs/tui/src/app/session_lifecycle.rs
+++ b/codex-rs/tui/src/app/session_lifecycle.rs
@@ -487,6 +487,7 @@ impl App {
.agent_navigation
.get(&thread_id)
.is_some_and(|entry| entry.is_closed);
+ is_replay_only |= self.thread_unavailable(thread_id);
let mut attached_replay_only = false;
if self.should_attach_live_thread_for_selection(thread_id) {
match self
@@ -495,9 +496,7 @@ impl App {
{
Ok(live_attached) => {
attached_replay_only = !live_attached;
- if attached_replay_only {
- is_replay_only = true;
- }
+ is_replay_only |= attached_replay_only;
}
Err(err) => {
self.chat_widget.add_error_message(format!(
@@ -542,7 +541,6 @@ impl App {
if snapshot.input_state.is_none() {
snapshot.input_state = self.agents_overview.input_states.remove(&thread_id);
}
- let blocks_direct_input = self.agent_navigation.is_parent_owned(thread_id);
self.active_thread_id = Some(thread_id);
self.active_thread_rx = Some(receiver);
@@ -558,6 +556,31 @@ impl App {
self.recap
.schedule_check(thread_id, self.app_event_tx.clone(), now);
+ self.render_thread_snapshot(tui, app_server, thread_id, snapshot, !is_replay_only)?;
+ if is_replay_only {
+ self.chat_widget.pause_unavailable_thread();
+ let message = if attached_replay_only {
+ format!(
+ "Agent thread {thread_id} could not be resumed live. Replaying saved transcript."
+ )
+ } else {
+ format!("Agent thread {thread_id} is closed. Replaying saved transcript.")
+ };
+ self.chat_widget.add_info_message(message, /*hint*/ None);
+ }
+ self.refresh_pending_thread_approvals().await;
+
+ Ok(())
+ }
+
+ pub(super) fn render_thread_snapshot(
+ &mut self,
+ tui: &mut tui::Tui,
+ app_server: &AppServerSession,
+ thread_id: ThreadId,
+ snapshot: ThreadEventSnapshot,
+ resume_restored_queue: bool,
+ ) -> Result<()> {
let init = self.chatwidget_init_for_forked_or_resumed_thread(
tui,
self.config.clone(),
@@ -568,24 +591,11 @@ impl App {
.set_task_mentions_enabled(app_server.task_tools_available(thread_id));
self.chat_widget
.note_rendered_width(tui.terminal.last_known_screen_size.width);
- if blocks_direct_input {
+ if self.agent_navigation.is_parent_owned(thread_id) {
self.chat_widget.set_parent_owned_thread();
}
-
self.reset_for_thread_switch(tui)?;
- self.replay_thread_snapshot(snapshot, !is_replay_only);
- if is_replay_only {
- let message = if attached_replay_only {
- format!(
- "Agent thread {thread_id} could not be resumed live. Replaying saved transcript."
- )
- } else {
- format!("Agent thread {thread_id} is closed. Replaying saved transcript.")
- };
- self.chat_widget.add_info_message(message, /*hint*/ None);
- }
- self.refresh_pending_thread_approvals().await;
-
+ self.replay_thread_snapshot(snapshot, resume_restored_queue);
Ok(())
}
diff --git a/codex-rs/tui/src/app/startup.rs b/codex-rs/tui/src/app/startup.rs
index 1858c1e5fb..0316a0dffd 100644
--- a/codex-rs/tui/src/app/startup.rs
+++ b/codex-rs/tui/src/app/startup.rs
@@ -683,6 +683,7 @@ See the Codex keymap documentation for supported actions and examples."
}
let mut listen_for_app_server_events = true;
+ let mut reconnect = None;
let mut waiting_for_initial_session_configured = wait_for_initial_session_configured;
let mut waiting_for_initial_session_header = true;
@@ -711,6 +712,20 @@ See the Codex keymap documentation for supported actions and examples."
Ok(exit_reason)
} else {
loop {
+ if app.reconnect.offline
+ && !app.reconnect.failed
+ && reconnect.is_none()
+ && app.reconnect.presentation == reconnect::ReconnectPresentation::Conversation
+ {
+ reconnect = Some(Box::pin(reconnect::reconnect(
+ app.app_server_target.clone(),
+ app.config.clone(),
+ app.current_displayed_thread_id(),
+ app_server.remote_cwd_override().map(Path::to_path_buf),
+ app_server.thread_tool_transport(),
+ app.reconnect.presentation,
+ )));
+ }
// Replay queues history and operations. A buffered closure must not switch
// widgets before those app events have been applied.
let has_pending_app_events = !app_event_rx.is_empty();
@@ -815,6 +830,25 @@ See the Codex keymap documentation for supported actions and examples."
}
AppRunControl::Continue
}
+ result = async { match reconnect.as_mut() { Some(future) => future.await, None => std::future::pending().await } }, if reconnect.is_some() && !has_pending_app_events => {
+ reconnect = None;
+ match result {
+ Ok(connected) => {
+ app.finish_reconnect(tui, &mut app_server, &mut app_event_rx, connected).await?;
+ listen_for_app_server_events = true;
+ waiting_for_initial_session_configured = false;
+ }
+ Err(error) => {
+ app.reconnect.failed = true;
+ app.chat_widget.reconnect_failed();
+ app.chat_widget.add_error_message(error.to_string());
+ if let Ok(mut state) = app.agents_overview.view_state.lock() {
+ state.connection_notice = Some("Reconnect failed — agent list is stale; relaunch to retry");
+ }
+ }
+ }
+ AppRunControl::Continue
+ }
() = async {
match app.chat_widget.terminal_title_next_refresh {
Some(deadline) => {
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index 51b70a98bd..0f6d031a3a 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -8633,3 +8633,6 @@ async fn side_backtrack_rejection_reports_unavailable_message_snapshot() {
async fn start_config_write_test_app_server(app: &App) -> Result<AppServerSession> {
Box::pin(crate::start_embedded_app_server_for_picker(&app.config)).await
}
+
+#[path = "tests/active_reconnect_tests.rs"]
+mod active_reconnect;
diff --git a/codex-rs/tui/src/app/tests/active_reconnect_tests.rs b/codex-rs/tui/src/app/tests/active_reconnect_tests.rs
new file mode 100644
index 0000000000..56efddf8c7
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/active_reconnect_tests.rs
@@ -0,0 +1,462 @@
+//! Active recovery keeps local input and policy while reusing ordinary thread resume.
+
+use super::*;
+use crate::app::reconnect::ReconnectPresentation;
+use crate::app::reconnect::reconnect;
+use pretty_assertions::assert_eq;
+use serde_json::json;
+use tokio::net::TcpListener;
+
+use super::disconnect::serve_reconnect_requests;
+
+#[tokio::test]
+async fn reconnect_restores_history_permissions_and_keeps_old_input_paused() -> Result<()> {
+ for (recovered_queue, edit_offline) in [(true, false), (false, false), (true, true)] {
+ let (mut app, mut events, mut ops) = make_test_app_with_channels().await;
+ let id = ThreadId::new();
+ let cwd = app.config.cwd.clone();
+ app.config.model = Some("gpt-test".into());
+ // Avoid platform-specific path widths in the mode-preservation snapshot.
+ app.config.tui_status_line = Some(vec!["model-with-reasoning".into()]);
+ app.config
+ .permissions
+ .set_permission_profile(PermissionProfile::read_only())?;
+ app.runtime_approval_policy_override = Some(AskForApproval::OnRequest);
+ app.runtime_permission_profile_override =
+ Some(RuntimePermissionProfileOverride::from_config(&app.config));
+ app.active_thread_id = Some(id);
+ app.primary_thread_id = Some(id);
+ let mut thread_session = test_thread_session(id, cwd.to_path_buf());
+ thread_session.approval_policy = AskForApproval::OnRequest;
+ thread_session.permission_profile = PermissionProfile::read_only();
+ app.ensure_thread_channel(id)
+ .store
+ .lock()
+ .await
+ .set_session(thread_session.clone(), Vec::new());
+ app.chat_widget.handle_thread_session(thread_session);
+ app.chat_widget.set_collaboration_mask(
+ crate::collaboration_modes::plan_mask(app.model_catalog.as_ref()).unwrap(),
+ );
+ let expected_mode = app.chat_widget.effective_collaboration_mode().with_updates(
+ Some("gpt-test".into()),
+ Some(None),
+ /*developer_instructions*/ None,
+ );
+ let expected_submitted_mode = expected_mode.clone();
+ if edit_offline {
+ app.chat_widget
+ .restore_user_message_to_composer("unacknowledged prompt".into());
+ app.chat_widget
+ .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+ next_user_turn_op(&mut ops);
+ }
+ if recovered_queue {
+ app.chat_widget
+ .set_queue_autosend_suppressed(/*suppressed*/ true);
+ app.chat_widget
+ .restore_user_message_to_composer("old queued input".into());
+ app.chat_widget
+ .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+ }
+ app.chat_widget
+ .restore_user_message_to_composer("kept draft".into());
+ let listener = TcpListener::bind("127.0.0.1:0").await?;
+ let endpoint = crate::resolve_remote_addr(&format!("ws://{}", listener.local_addr()?))?;
+ app.app_server_target = AppServerTarget::Remote { endpoint };
+ let thread = json!({
+ "id": id, "sessionId": id, "preview": "only once", "ephemeral": false,
+ "modelProvider": "test-provider", "createdAt": 1, "updatedAt": 2,
+ "status": {"type": "idle"}, "cwd": cwd, "cliVersion": "0.0.0", "source": "cli",
+ "turns": [test_turn("accepted", TurnStatus::Completed, vec![ThreadItem::UserMessage {
+ id: "input-1".into(), client_id: None, content: vec![UserInput::Text { text: "only once".into(), text_elements: Vec::new() }],
+ }])]
+ });
+ let server = tokio::spawn(async move {
+ let mut methods = Vec::new();
+ for attempt in 0..2 {
+ let (stream, _) = listener.accept().await?;
+ methods.extend(serve_reconnect_requests(tokio_tungstenite::accept_async(stream).await?, |request| std::future::ready(match request.method.as_str() {
+ "thread/resume" if attempt == 0 => Some(json!({"error": {"code": -32603, "message": "temporarily unavailable"}})),
+ "thread/resume" => {
+ let params = request.params.as_ref().unwrap();
+ assert_eq!(params["threadId"], id.to_string());
+ assert!(params["model"].is_null());
+ Some(json!({"result": {"thread": thread, "model": "gpt-test", "modelProvider": "test-provider", "cwd": cwd,
+ "approvalPolicy": "never", "approvalsReviewer": "user", "sandbox": {"type": "dangerFullAccess"}, "reasoningEffort": null}}))
+ }
+ "thread/read" => Some(json!({"result": {"thread": thread}})),
+ "thread/list" | "thread/loaded/list" => Some(json!({"result": {"data": [], "nextCursor": null}})),
+ "thread/goal/get" => Some(json!({"result": {"goal": null}})),
+ "turn/start" => {
+ assert!(!recovered_queue);
+ let params = request.params.as_ref().unwrap();
+ assert_eq!(params["input"][0]["text"], "fresh follow-up");
+ assert_eq!(params["approvalPolicy"], "on-request");
+ assert_eq!(params["sandboxPolicy"]["type"], "readOnly");
+ assert_eq!(params["collaborationMode"], json!(expected_submitted_mode));
+ Some(json!({"result": {"turn": {"id": "fresh", "items": [], "status": "inProgress"}}}))
+ }
+ method => panic!("unexpected reconnect request: {method}"),
+ })).await?);
+ }
+ Ok::<_, color_eyre::Report>(methods)
+ });
+ let mut session = crate::start_embedded_app_server_for_picker(&app.config).await?;
+ std::fs::write(
+ app.config
+ .codex_home
+ .join("tui-thread-reference-capabilities"),
+ "not a directory",
+ )?;
+ session.remember_task_tool_thread(id);
+ let transport = crate::dynamic_tools_mcp::ThreadToolTransport::Mcp(Arc::new(
+ crate::dynamic_tools_mcp::DynamicToolMcpServer::start(
+ session.request_handle(),
+ codex_app_server_protocol::ThreadStartParams::default(),
+ app.app_event_tx.clone(),
+ app.dynamic_tool_status_updates.clone(),
+ /*managed_requirement*/ None,
+ )
+ .await?,
+ ));
+ let mut overrides = None;
+ transport.configure_mcp(&mut overrides);
+ let mcp = overrides.unwrap().remove("mcp_servers.codex_tui").unwrap();
+ let client = codex_http_client::HttpClientBuilder::new().build_direct()?;
+ let call_mcp = || {
+ client
+ .post(mcp["url"].as_str().unwrap())
+ .header(
+ "Authorization",
+ mcp["http_headers"]["Authorization"].as_str().unwrap(),
+ )
+ .header("Accept", "application/json, text/event-stream")
+ .header("MCP-Protocol-Version", "2026-07-28")
+ .header("MCP-Method", "tools/call")
+ .header("MCP-Name", "list_threads")
+ .json(
+ &json!({"jsonrpc": "2.0", "id": 1, "method": "tools/call", "params": {
+ "name": "list_threads", "arguments": {}, "_meta": {"threadId": id,
+ "io.modelcontextprotocol/protocolVersion": "2026-07-28",
+ "io.modelcontextprotocol/clientCapabilities": {}}
+ }}),
+ )
+ };
+
+ app.chat_widget.remote_connection =
+ crate::status::remote_connection::remote_connection_status_value(
+ &app.app_server_target,
+ Some("1.0.0"),
+ );
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ app.begin_reconnect();
+ if edit_offline {
+ app.handle_tui_event(
+ &mut tui,
+ &mut session,
+ TuiEvent::Key(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT)),
+ )
+ .await?;
+ assert!(!app.chat_widget.has_queued_follow_up_messages());
+ assert!(
+ !app.chat_widget
+ .capture_thread_input_state()
+ .unwrap()
+ .recovered_queue
+ );
+ }
+ let stale_picker_refresh = app.agent_navigation.begin_picker_refresh(id).unwrap();
+ app.last_subagent_backfill_attempt = Some(id);
+ app.rate_limit_refresh_state
+ .start(
+ RateLimitRefreshOrigin::Recovery,
+ &mut app.rate_limit_hard_stop_generation,
+ )
+ .unwrap();
+ let before_disconnect = Instant::now() - Duration::from_secs(/*secs*/ 300);
+ app.recap.note_focus_lost(before_disconnect);
+ for _ in 0..3 {
+ app.recap
+ .note_turn_finished(&TurnStatus::Completed, before_disconnect);
+ }
+ app.recap
+ .schedule_check(id, app.app_event_tx.clone(), Instant::now());
+ let old_sender = app.app_event_tx.clone();
+ let connected = reconnect(
+ app.app_server_target.clone(),
+ app.config.clone(),
+ Some(id),
+ /*remote_cwd*/ None,
+ transport,
+ ReconnectPresentation::Conversation,
+ )
+ .await?;
+ let paused = call_mcp().send().await?.text().await?;
+ assert!(
+ paused.contains("TUI is reconnecting; tool was not sent"),
+ "{paused}"
+ );
+ app.finish_reconnect(&mut tui, &mut session, &mut events, connected)
+ .await?;
+ assert!(!app.reconnect.offline);
+ assert_eq!(app.last_subagent_backfill_attempt, None);
+ assert!(
+ app.rate_limit_refresh_state
+ .start(
+ RateLimitRefreshOrigin::Recovery,
+ &mut app.rate_limit_hard_stop_generation
+ )
+ .is_some()
+ );
+ assert!(app.agent_navigation.begin_picker_refresh(id).is_some());
+ assert!(
+ !app.agent_navigation
+ .finish_picker_refresh(id, stale_picker_refresh)
+ );
+ let mut deferred = Vec::new();
+ tokio::time::timeout(Duration::from_secs(/*secs*/ 5), async {
+ loop {
+ let event = events.recv().await.expect("rebound recap event");
+ if matches!(event, AppEvent::CheckRecap { thread_id } if thread_id == id) {
+ break;
+ }
+ deferred.push(event);
+ }
+ })
+ .await?;
+ for event in deferred {
+ app.app_event_tx.send(event);
+ }
+ let ready = call_mcp().send().await?.text().await?;
+ assert!(ready.contains("threads"), "{ready}");
+ assert_eq!(
+ app.chat_widget.remote_connection,
+ crate::status::remote_connection::remote_connection_status_value(
+ &app.app_server_target,
+ Some("2.0.0")
+ )
+ );
+ assert!(old_sender.app_event_tx.is_closed());
+ assert!(session.task_tools_available(id));
+ assert_eq!(app.current_displayed_thread_id(), Some(id));
+ assert_eq!(
+ app.chat_widget.effective_collaboration_mode(),
+ expected_mode
+ );
+ assert_eq!(
+ app.chat_widget.composer_text_with_pending(),
+ if edit_offline {
+ "old queued input"
+ } else {
+ "kept draft"
+ }
+ );
+ let history = drain_history(&mut app, &mut tui, &mut session, &mut events).await?;
+ assert_eq!(history.matches("only once").count(), 1);
+ if recovered_queue {
+ assert!(app.chat_widget.has_queued_follow_up_messages());
+ assert!(!app.chat_widget.maybe_send_next_queued_input());
+ if edit_offline {
+ app.handle_tui_event(
+ &mut tui,
+ &mut session,
+ TuiEvent::Key(KeyEvent::new(KeyCode::Up, KeyModifiers::ALT)),
+ )
+ .await?;
+ assert_eq!(
+ app.chat_widget.composer_text_with_pending(),
+ "unacknowledged prompt"
+ );
+ assert!(ops.try_recv().is_err());
+ } else {
+ assert_snapshot!(
+ "restored_conversation",
+ render_bottom_popup(&app.chat_widget, /*width*/ 80)
+ );
+ }
+ } else {
+ app.chat_widget
+ .handle_key_event(KeyEvent::new(KeyCode::Char('u'), KeyModifiers::CONTROL));
+ app.chat_widget
+ .restore_user_message_to_composer("fresh follow-up".into());
+ app.chat_widget
+ .handle_key_event(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE));
+ while let Ok(event) = events.try_recv() {
+ app.handle_event(&mut tui, &mut session, event).await?;
+ }
+ }
+ session.shutdown().await?;
+ let methods = server.await??;
+ assert_eq!(
+ methods
+ .iter()
+ .filter(|method| *method == "turn/start")
+ .count(),
+ usize::from(!recovered_queue)
+ );
+ }
+ Ok(())
+}
+
+#[tokio::test]
+async fn reconnect_exhaustion_and_unknown_initial_thread_stay_offline() -> Result<()> {
+ let (mut app, _, _) = make_test_app_with_channels().await;
+ let listener = TcpListener::bind("127.0.0.1:0").await?;
+ app.app_server_target = AppServerTarget::Remote {
+ endpoint: crate::resolve_remote_addr(&format!("ws://{}", listener.local_addr()?))?,
+ };
+ drop(listener);
+ tokio::time::pause();
+ let start = tokio::time::Instant::now();
+ for id in [Some(ThreadId::new()), None] {
+ assert!(
+ reconnect(
+ app.app_server_target.clone(),
+ app.config.clone(),
+ id,
+ /*remote_cwd*/ None,
+ crate::dynamic_tools_mcp::ThreadToolTransport::Dynamic,
+ ReconnectPresentation::Conversation
+ )
+ .await
+ .is_err()
+ );
+ }
+ assert!((15..=65).contains(&start.elapsed().as_secs()));
+ app.begin_reconnect();
+ app.chat_widget.reconnect_failed();
+ assert_snapshot!(
+ "reconnect_failed",
+ render_bottom_popup(&app.chat_widget, /*width*/ 80)
+ );
+ tokio::time::resume();
+ Ok(())
+}
+
+#[tokio::test]
+async fn reconnect_allows_slow_hydration_but_bounds_a_stalled_server() -> Result<()> {
+ for delay in [15, 150] {
+ let (mut app, mut events, _) = make_test_app_with_channels().await;
+ app.config.model = Some("gpt-test".into());
+ let listener = TcpListener::bind("127.0.0.1:0").await?;
+ let endpoint = crate::RemoteAppServerEndpoint::WebSocket {
+ websocket_url: format!("ws://{}", listener.local_addr()?),
+ auth_token: None,
+ };
+ let id = ThreadId::new();
+ let server = tokio::spawn(async move {
+ let (stream, _) = listener.accept().await?;
+ serve_reconnect_requests(
+ tokio_tungstenite::accept_async(stream).await?,
+ move |request| async move {
+ assert_eq!(request.method, "thread/resume");
+ tokio::time::pause();
+ tokio::time::sleep(Duration::from_secs(delay)).await;
+ tokio::time::resume();
+ Some(json!({"error": {"code": -32600, "message": "thread no longer exists"}}))
+ },
+ )
+ .await
+ });
+ let start = tokio::time::Instant::now();
+ let result = reconnect(
+ AppServerTarget::Remote {
+ endpoint: endpoint.clone(),
+ },
+ app.config.clone(),
+ Some(id),
+ /*remote_cwd*/ None,
+ crate::dynamic_tools_mcp::ThreadToolTransport::Dynamic,
+ ReconnectPresentation::Conversation,
+ )
+ .await;
+ let elapsed = start.elapsed().as_secs();
+ if delay == 15 {
+ app.app_server_target = AppServerTarget::Remote { endpoint };
+ app.active_thread_id = Some(id);
+ app.primary_thread_id = Some(id);
+ let cached = test_thread_session(id, app.config.cwd.to_path_buf());
+ app.ensure_thread_channel(id)
+ .store
+ .lock()
+ .await
+ .set_session(cached, Vec::new());
+ app.chat_widget
+ .restore_user_message_to_composer("unavailable draft".into());
+ app.begin_reconnect();
+ let mut session = crate::start_embedded_app_server_for_picker(&app.config).await?;
+ let mut tui = crate::tui::test_support::make_test_tui()?;
+ app.finish_reconnect(&mut tui, &mut session, &mut events, result?)
+ .await?;
+ assert!(app.thread_unavailable(id));
+ app.handle_tui_event(
+ &mut tui,
+ &mut session,
+ TuiEvent::Key(KeyEvent::new(KeyCode::Enter, KeyModifiers::NONE)),
+ )
+ .await?;
+ assert_eq!(
+ app.chat_widget.composer_text_with_pending(),
+ "unavailable draft"
+ );
+ let history = drain_history(&mut app, &mut tui, &mut session, &mut events).await?;
+ let history = &history[history.find("• This conversation is unavailable").unwrap()..];
+ assert_snapshot!(
+ "unavailable_conversation",
+ format!(
+ "{history}\n{}",
+ render_bottom_popup(&app.chat_widget, /*width*/ 80)
+ )
+ .replace(
+ &test_path_buf("/tmp/project").display().to_string(),
+ "/tmp/project"
+ )
+ );
+ session.shutdown().await?;
+ assert!((15..120).contains(&elapsed), "{elapsed}");
+ let methods = server.await??;
+ assert_eq!(
+ methods
+ .iter()
+ .filter(|method| *method == "initialize")
+ .count(),
+ 1
+ );
+ } else {
+ tokio::time::resume();
+ assert!(result.is_err());
+ assert_eq!(elapsed, 120);
+ server.abort();
+ }
+ }
+ Ok(())
+}
+
+pub(super) async fn drain_history(
+ app: &mut App,
+ tui: &mut tui::Tui,
+ session: &mut AppServerSession,
+ events: &mut mpsc::UnboundedReceiver<AppEvent>,
+) -> Result<String> {
+ while let Ok(event) = events.try_recv() {
+ assert!(!matches!(
+ event,
+ AppEvent::CodexOp(AppCommand::UserTurn { .. })
+ ));
+ if matches!(
+ event,
+ AppEvent::InsertHistoryCell(_)
+ | AppEvent::BeginThreadSwitchHistoryReplayBuffer
+ | AppEvent::EndInitialHistoryReplayBuffer
+ ) {
+ app.handle_event(tui, session, event).await?;
+ }
+ }
+ Ok(lines_to_single_string(
+ &app.transcript_cells
+ .iter()
+ .flat_map(|cell| cell.display_lines(/*width*/ 80))
+ .collect::<Vec<_>>(),
+ ))
+}
diff --git a/codex-rs/tui/src/app/tests/disconnect_tests.rs b/codex-rs/tui/src/app/tests/disconnect_tests.rs
index e30acddd92..07c64bb8cd 100644
--- a/codex-rs/tui/src/app/tests/disconnect_tests.rs
+++ b/codex-rs/tui/src/app/tests/disconnect_tests.rs
@@ -264,7 +264,7 @@ where
methods.push(request.method.clone());
let request_id = request.id.clone();
let response = match request.method.as_str() {
- "initialize" => Some(json!({"result": {"userAgent": "reconnect-test"}})),
+ "initialize" => Some(json!({"result": {"userAgent": "reconnect-test/2.0.0"}})),
"account/read" => {
Some(json!({"result": {"account": null, "requiresOpenaiAuth": false}}))
}
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 285b21c8aa..dfdb77af32 100644
--- a/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
+++ b/codex-rs/tui/src/app/tests/session_lifecycle_requests.rs
@@ -601,7 +601,7 @@ async fn archive_current_thread_reports_success_only_after_archiving() -> Result
#[tokio::test]
async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths() -> Result<()> {
- let (mut app, mut events, _ops) = make_test_app_with_channels().await;
+ let (mut app, events, _ops) = make_test_app_with_channels().await;
let codex_home = tempdir()?;
app.config.codex_home = codex_home.path().to_path_buf().abs();
app.config.sqlite = SqliteConfig::new_for_testing(codex_home.path().abs());
@@ -612,7 +612,7 @@ async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths()
codex_home.path().join("config.toml"),
"web_search = \"disabled\"\n",
)?;
- let (mut app_server, requests, proxy) = start_recording_app_server(
+ let (mut app_server, mut requests, mut proxy) = start_recording_app_server(
&app.config,
/*blocked_thread_list*/ None,
/*failed_thread_name*/ None,
@@ -776,6 +776,41 @@ async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths()
}
}))
};
+ let transport = app_server.thread_tool_transport();
+ let crate::dynamic_tools_mcp::ThreadToolTransport::Mcp(tool_server) = &transport else {
+ panic!("expected the daemon task-tool bridge");
+ };
+ tool_server.suspend();
+ let paused = call_tool(0, "list_threads", serde_json::json!({}))
+ .send()
+ .await?
+ .text()
+ .await?;
+ assert!(
+ paused.contains("TUI is reconnecting; tool was not sent"),
+ "{paused}"
+ );
+ let (replacement, replacement_requests, replacement_proxy) = start_recording_app_server(
+ &app.config,
+ /*blocked_thread_list*/ None,
+ /*failed_thread_name*/ None,
+ )
+ .await?;
+ let (new_tx, new_rx) = mpsc::unbounded_channel();
+ let new_sender = AppEventSender::new(new_tx);
+ drop(events);
+ let mut events = new_rx;
+ assert!(app.app_event_tx.app_event_tx.is_closed());
+ tool_server.reconnect(replacement.request_handle(), new_sender);
+ let previous = std::mem::replace(
+ &mut app_server,
+ replacement.with_thread_tool_transport(transport),
+ );
+ previous.shutdown().await?;
+ proxy.await??;
+ requests = replacement_requests;
+ proxy = replacement_proxy;
+ // The same MCP URL and credentials now use the new connection and event receiver.
let response = call_tool(1, "list_threads", serde_json::json!({}))
.send()
.await?;
@@ -824,9 +859,13 @@ async fn local_daemon_registers_approval_gated_mcp_tools_for_both_start_paths()
child["config"]["mcp_servers.codex_tui"],
starts[0]["config"]["mcp_servers.codex_tui"]
);
- let forked = call_tool(3, "fork_thread", serde_json::json!({"threadId": thread_id}))
- .send()
- .await?;
+ let forked = call_tool(
+ 3,
+ "fork_thread",
+ serde_json::json!({"threadId": delegation_source}),
+ )
+ .send()
+ .await?;
assert!(forked.status().is_success());
let forked = recorded_params(&requests, "thread/fork")
.pop()
diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__reconnect_failed.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__reconnect_failed.snap
new file mode 100644
index 0000000000..86c54bfc86
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__reconnect_failed.snap
@@ -0,0 +1,10 @@
+---
+source: tui/src/app/tests/active_reconnect_tests.rs
+expression: "render_bottom_popup(&app.chat_widget, 80)"
+---
+• Reconnect failed — check the endpoint, then relaunch (0s)
+
+
+› Ask Codex to do anything
+
+ ctrl+c quit
diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__restored_conversation.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__restored_conversation.snap
new file mode 100644
index 0000000000..e6a6142008
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__restored_conversation.snap
@@ -0,0 +1,11 @@
+---
+source: tui/src/app/tests/active_reconnect_tests.rs
+expression: "render_bottom_popup(&app.chat_widget, 80)"
+---
+• Queued follow-up inputs
+ ↳ old queued input
+ ⌥ + ↑ edit last queued message
+
+› kept draft
+
+ gpt-test default Plan mode (shift+tab to cycle)
diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__unavailable_conversation.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__unavailable_conversation.snap
new file mode 100644
index 0000000000..6ac1df3527
--- /dev/null
+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__active_reconnect__unavailable_conversation.snap
@@ -0,0 +1,9 @@
+---
+source: tui/src/app/tests/active_reconnect_tests.rs
+expression: "format!(\"{history}\\n{}\", render_bottom_popup(&app.chat_widget, 80))"
+---
+• This conversation is unavailable. Its cached transcript and draft remain here; input is paused. Open the agent picker or return to the parent to continue.
+• Reconnected. No input was resent. Review uncertain submissions before retrying; recovered queues remain paused.
+› unavailable draft
+
+ gpt-test default · /tmp/project
diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__disconnect__offline_draft.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__disconnect__offline_draft.snap
index 8e61fa4832..4722388cf8 100644
--- a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__disconnect__offline_draft.snap
+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__disconnect__offline_draft.snap
@@ -2,8 +2,8 @@
source: tui/src/app/tests/disconnect_tests.rs
expression: "format!(\"{}\\n{}\",\nlines_to_single_string(&app.transcript_cells.last().unwrap().display_lines(80)),\nrender_bottom_popup(&app.chat_widget, 80))"
---
-■ Connection lost.
-• Connection lost — copy your draft, then relaunch (0s)
+■ Connection lost. Attempting to reconnect…
+• Reconnecting to app-server… (0s)
• Queued follow-up inputs
↳ queued before disconnect
diff --git a/codex-rs/tui/src/app/thread_routing.rs b/codex-rs/tui/src/app/thread_routing.rs
index 4124c62914..7a6fccadf1 100644
--- a/codex-rs/tui/src/app/thread_routing.rs
+++ b/codex-rs/tui/src/app/thread_routing.rs
@@ -443,6 +443,12 @@ impl App {
thread_id: ThreadId,
op: AppCommand,
) -> Result<()> {
+ if self.thread_unavailable(thread_id) {
+ self.chat_widget.add_error_message(
+ "This conversation is unavailable; no operation was sent.".into(),
+ );
+ return Ok(());
+ }
if self.chat_widget.rejects_misalignment_policy_op(&op) {
return Ok(());
}
@@ -1546,7 +1552,7 @@ impl App {
pub(super) fn replay_thread_snapshot(
&mut self,
- snapshot: ThreadEventSnapshot,
+ mut snapshot: ThreadEventSnapshot,
resume_restored_queue: bool,
) {
let request_changes = snapshot
@@ -1591,6 +1597,12 @@ impl App {
self.chat_widget.handle_thread_session(session);
}
}
+ let recovered_input = snapshot
+ .input_state
+ .as_ref()
+ .is_some_and(|input| input.recovered_queue)
+ .then(|| snapshot.input_state.take())
+ .flatten();
self.chat_widget.restore_thread_input_state(
snapshot.input_state,
ThreadInputStateRestoreMode {
@@ -1616,6 +1628,9 @@ impl App {
self.app_event_tx
.send(AppEvent::EndInitialHistoryReplayBuffer);
}
+ if recovered_input.is_some() {
+ self.chat_widget.restore_reconnected_input(recovered_input);
+ }
self.chat_widget
.set_queue_autosend_suppressed(/*suppressed*/ false);
self.chat_widget
diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs
index 231d4a4916..f316082656 100644
--- a/codex-rs/tui/src/app_server_session.rs
+++ b/codex-rs/tui/src/app_server_session.rs
@@ -464,6 +464,13 @@ impl AppServerSession {
}
}
+ pub(crate) fn with_thread_tool_transport(mut self, transport: ThreadToolTransport) -> Self {
+ if let ThreadToolTransport::Mcp(server) = transport {
+ self.dynamic_tool_mcp = Some(server);
+ }
+ self
+ }
+
pub(crate) fn with_remote_cwd_override(mut self, remote_cwd_override: Option<PathBuf>) -> Self {
self.remote_cwd_override = remote_cwd_override;
self
@@ -481,6 +488,11 @@ impl AppServerSession {
matches!(&self.client, AppServerClient::InProcess(_))
}
+ /// Carry capabilities that may exist only in memory when the optional cache is unwritable.
+ pub(crate) fn inherit_task_tool_capabilities(&mut self, previous: &Self) {
+ self.task_tool_threads.extend(&previous.task_tool_threads);
+ }
+
pub(crate) fn task_tools_available(&self, thread_id: ThreadId) -> bool {
self.task_tool_threads.contains(&thread_id)
|| self
diff --git a/codex-rs/tui/src/chatwidget/reconnect.rs b/codex-rs/tui/src/chatwidget/reconnect.rs
index 7c99c199eb..4c328018ea 100644
--- a/codex-rs/tui/src/chatwidget/reconnect.rs
+++ b/codex-rs/tui/src/chatwidget/reconnect.rs
@@ -13,9 +13,47 @@ impl ChatWidget {
self.bottom_pane.ensure_status_indicator();
self.bottom_pane
.set_interrupt_hint_visible(/*visible*/ false);
- self.set_status_header("Connection lost — copy your draft, then relaunch".to_string());
+ self.set_status_header("Reconnecting to app-server…".to_string());
self.set_footer_hint_override(Some(vec![("ctrl+c".into(), "quit".into())]));
- self.add_error_message("Connection lost.".into());
+ self.add_error_message("Connection lost. Attempting to reconnect…".into());
+ }
+
+ /// Restore local input only after replay, which can otherwise move interrupted queues into the draft.
+ pub(crate) fn restore_reconnected_input(&mut self, input: Option<ThreadInputState>) {
+ let running = self.turn_lifecycle.agent_turn_running;
+ if let Some(mut input) = input {
+ // Its acceptance is unknown. Keep a local copy for manual recovery without
+ // comparing against partial history or automatically submitting it again.
+ if input.user_turn_pending_start
+ && let Some(prompt) = input.safety_buffering_prompt.take()
+ {
+ input.queued_user_messages.push_front(prompt.into());
+ input
+ .queued_user_message_history_records
+ .push_front(UserMessageHistoryRecord::UserMessageText);
+ input.recovered_queue = true;
+ }
+ input.current_collaboration_mode = self.current_collaboration_mode.clone();
+ // Resume supplies model/effort, but not the user's selected collaboration mode.
+ if let Some(mask) = input.active_collaboration_mask.as_mut() {
+ mask.model = Some(self.current_model().to_string());
+ mask.reasoning_effort = Some(self.effective_reasoning_effort());
+ }
+ self.restore_thread_input_state(
+ Some(input),
+ ThreadInputStateRestoreMode {
+ preserve_in_flight_turn: false,
+ },
+ );
+ }
+ self.turn_lifecycle.restore_running(running, Instant::now());
+ self.update_task_running_state();
+ }
+
+ pub(crate) fn pause_unavailable_thread(&mut self) {
+ self.turn_lifecycle
+ .restore_running(/*running*/ false, Instant::now());
+ self.update_task_running_state();
}
pub(crate) fn handle_disconnected_view_key(&mut self, key: KeyEvent) {
@@ -41,4 +79,11 @@ impl ChatWidget {
self.bottom_pane.handle_disconnected_key(key);
}
}
+
+ pub(crate) fn reconnect_failed(&mut self) {
+ self.set_status_header("Reconnect failed — check the endpoint, then relaunch".into());
+ self.add_error_message(
+ "Automatic reconnect could not restore this session. Your draft is still editable. Copy it before quitting with Ctrl+C, then reconnect with the same command.".into(),
+ );
+ }
}
diff --git a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs b/codex-rs/tui/src/chatwidget/tests/composer_submission.rs
index 2edcda24df..c6c0fd0b63 100644
--- a/codex-rs/tui/src/chatwidget/tests/composer_submission.rs
+++ b/codex-rs/tui/src/chatwidget/tests/composer_submission.rs
@@ -2413,3 +2413,40 @@ async fn interrupt_prepends_queued_messages_before_existing_composer_text() {
let _ = drain_insert_history(&mut rx);
}
+
+#[tokio::test]
+async fn reconnect_holds_only_recovered_input_until_manually_edited() {
+ for (recovered, pending_start) in [
+ (None, false),
+ (Some("review this old input"), false),
+ (Some("unacknowledged prompt"), true),
+ ] {
+ let (mut chat, _rx, _ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ if let Some(text) = recovered {
+ if pending_start {
+ chat.input_queue.user_turn_pending_start = true;
+ chat.safety_buffering_prompt = Some(UserMessage::from(text));
+ } else {
+ chat.input_queue
+ .queued_user_messages
+ .push_back(UserMessage::from(text).into());
+ }
+ }
+ chat.pause_for_disconnect();
+ let input = chat.capture_thread_input_state();
+ let (mut chat, _rx, mut ops) = make_chatwidget_manual(/*model_override*/ None).await;
+ chat.thread_id = Some(ThreadId::new());
+ chat.restore_reconnected_input(input);
+ chat.set_queue_autosend_suppressed(/*suppressed*/ false);
+ if let Some(text) = recovered {
+ assert!(!chat.maybe_send_next_queued_input());
+ assert_eq!(chat.pop_latest_queued_composer_state().unwrap().text, text);
+ assert_no_submit_op(&mut ops);
+ }
+ chat.input_queue
+ .queued_user_messages
+ .push_back(UserMessage::from("new follow-up").into());
+ assert!(chat.maybe_send_next_queued_input());
+ assert_matches!(next_submit_op(&mut ops), Op::UserTurn { .. });
+ }
+}
diff --git a/codex-rs/tui/src/dynamic_tools.rs b/codex-rs/tui/src/dynamic_tools.rs
index 114481290c..f50c0d5d25 100644
--- a/codex-rs/tui/src/dynamic_tools.rs
+++ b/codex-rs/tui/src/dynamic_tools.rs
@@ -616,6 +616,7 @@ async fn execute_inner(
thread_start_params.sandbox = None;
None
} else {
+ thread_start_params.permissions = None;
thread_start_params.sandbox = Some(match &source.sandbox {
SandboxPolicy::DangerFullAccess => SandboxMode::DangerFullAccess,
SandboxPolicy::ReadOnly { .. } => SandboxMode::ReadOnly,
diff --git a/codex-rs/tui/src/dynamic_tools_mcp.rs b/codex-rs/tui/src/dynamic_tools_mcp.rs
index 37aa350fec..92d701f8d6 100644
--- a/codex-rs/tui/src/dynamic_tools_mcp.rs
+++ b/codex-rs/tui/src/dynamic_tools_mcp.rs
@@ -43,6 +43,8 @@ use serde_json::json;
use std::borrow::Cow;
use std::collections::HashMap;
use std::sync::Arc;
+use std::sync::PoisonError;
+use std::sync::RwLock;
use tokio::net::TcpListener;
use tokio::sync::broadcast;
use tokio::task::JoinHandle;
@@ -79,12 +81,29 @@ impl ThreadToolTransport {
}
}
+type ToolConnection = Arc<RwLock<Option<(AppServerRequestHandle, AppEventSender)>>>;
+
pub(crate) struct DynamicToolMcpServer {
+ connection: ToolConnection,
config: Value,
task: JoinHandle<()>,
}
impl DynamicToolMcpServer {
+ pub(crate) fn suspend(&self) {
+ *self
+ .connection
+ .write()
+ .unwrap_or_else(PoisonError::into_inner) = None;
+ }
+
+ pub(crate) fn reconnect(&self, handle: AppServerRequestHandle, events: AppEventSender) {
+ *self
+ .connection
+ .write()
+ .unwrap_or_else(PoisonError::into_inner) = Some((handle, events));
+ }
+
pub(crate) async fn start(
request_handle: AppServerRequestHandle,
mut thread_start_params: ThreadStartParams,
@@ -122,10 +141,10 @@ impl DynamicToolMcpServer {
if let Some(overrides) = thread_start_params.config.as_mut() {
overrides.remove("web_search");
}
+ let connection = Arc::new(RwLock::new(Some((request_handle, app_event_tx))));
let handler = DynamicToolMcpHandler {
- request_handle,
+ connection: Arc::clone(&connection),
thread_start_params,
- app_event_tx,
status_updates,
server_config: server_config.clone(),
};
@@ -147,6 +166,7 @@ impl DynamicToolMcpServer {
}
});
Ok(Self {
+ connection,
config: server_config,
task,
})
@@ -177,9 +197,8 @@ async fn require_authorization(
#[derive(Clone)]
struct DynamicToolMcpHandler {
- request_handle: AppServerRequestHandle,
+ connection: ToolConnection,
thread_start_params: ThreadStartParams,
- app_event_tx: AppEventSender,
status_updates: broadcast::Sender<ThreadStatusChangedNotification>,
server_config: Value,
}
@@ -265,12 +284,21 @@ impl ServerHandler for DynamicToolMcpHandler {
format!("mcp_servers.{}", dynamic_tools::NAMESPACE),
self.server_config.clone(),
);
+ // Snapshot once: an in-flight call must never switch connections or replay a mutation.
+ let (request_handle, app_event_tx) = self
+ .connection
+ .read()
+ .unwrap_or_else(PoisonError::into_inner)
+ .clone()
+ .ok_or_else(|| {
+ McpError::internal_error("TUI is reconnecting; tool was not sent", None)
+ })?;
let response = dynamic_tools::execute(
- self.request_handle.clone(),
+ request_handle,
params,
thread_start_params,
self.status_updates.subscribe(),
- Some(&self.app_event_tx),
+ Some(&app_event_tx),
)
.await;
let content = response
diff --git a/codex-rs/tui/tests/suite/reconnect.rs b/codex-rs/tui/tests/suite/reconnect.rs
index 22e1b057c4..fe2cc52cfd 100644
--- a/codex-rs/tui/tests/suite/reconnect.rs
+++ b/codex-rs/tui/tests/suite/reconnect.rs
@@ -1,4 +1,4 @@
-//! Drives disconnect handling through the real binary and terminal event loop.
+//! Drives automatic reconnect through the real binary and terminal event loop.
use super::focus_palette::PtyCodex;
use super::focus_palette::write_test_config;
@@ -15,7 +15,7 @@ use tokio::net::UnixListener;
use tokio_tungstenite::tungstenite::Message;
#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
+async fn automatic_reconnect_restores_draft_and_routes_new_notifications() -> Result<()> {
let repo_root = codex_utils_cargo_bin::repo_root()?;
// macOS's default temporary directory leaves too little room for the control socket path.
let codex_home = tempfile::tempdir_in("/tmp")?;
@@ -24,9 +24,11 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
std::fs::create_dir_all(socket.parent().unwrap())?;
let listener = UnixListener::bind(socket.as_path())?;
let (disconnect_tx, mut disconnect_rx) = tokio::sync::oneshot::channel();
+ let (restore_tx, restore_rx) = tokio::sync::oneshot::channel();
let server_cwd = repo_root.clone();
let server = tokio::spawn(async move {
let mut methods = Vec::new();
+ let mut restore_rx = Some(restore_rx);
let id = "00000000-0000-0000-0000-000000000001";
let thread = json!({
"id": id, "sessionId": id, "preview": "", "ephemeral": false,
@@ -34,7 +36,7 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
"status": {"type": "active", "activeFlags": []}, "cwd": server_cwd,
"cliVersion": "0.0.0", "source": "cli", "turns": [{"id": "running", "items": [], "status": "inProgress", "error": null}]
});
- for connection in 0..1 {
+ for connection in 0..2 {
let mut socket = loop {
let (stream, _) = listener.accept().await?;
// Startup probes the default daemon socket before opening its WebSocket.
@@ -57,6 +59,9 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
continue;
};
methods.push(request.method.clone());
+ if connection == 1 && request.method == "initialize" {
+ restore_rx.take().unwrap().await?;
+ }
let result = match request.method.as_str() {
"initialize" => json!({"userAgent": "reconnect-pty"}),
"account/read" => {
@@ -92,6 +97,22 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
.into(),
))
.await?;
+ if connection == 1 && request.method == "thread/resume" {
+ // Keep the recovered turn running: its output must appear without waiting
+ // for turn/completed or rebuilding the transcript.
+ socket
+ .send(Message::Text(
+ json!({
+ "method": "item/agentMessage/delta", "params": {
+ "threadId": id, "turnId": "running", "itemId": "live-item",
+ "delta": "fresh-notification-after-reconnect\n"
+ }
+ })
+ .to_string()
+ .into(),
+ ))
+ .await?;
+ }
}
}
Ok::<_, anyhow::Error>(methods)
@@ -99,11 +120,13 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
let mut terminal = PtyCodex::start(&repo_root, codex_home)?;
terminal.wait_for_startup()?;
let mut disconnect_tx = Some(disconnect_tx);
+ let mut restore_tx = Some(restore_tx);
for expected in [
"gpt-5.6-terra",
"preserved-draft",
- "Connection lost",
+ "Reconnecting",
"preserved-draft!",
+ "fresh-notification-after-reconnect",
] {
let deadline = Instant::now() + Duration::from_secs(/*secs*/ 30);
while !terminal.screen_contains(expected) && Instant::now() < deadline {
@@ -119,7 +142,10 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
"preserved-draft" => {
disconnect_tx.take().unwrap().send(()).unwrap();
}
- "Connection lost" => terminal.write_input(b"!")?,
+ "Reconnecting" => terminal.write_input(b"!")?,
+ "preserved-draft!" => {
+ restore_tx.take().unwrap().send(()).unwrap();
+ }
_ => {}
}
}
@@ -134,7 +160,7 @@ async fn disconnect_preserves_editable_draft_in_terminal() -> Result<()> {
.iter()
.filter(|method| *method == "thread/resume")
.count(),
- 0
+ 1
);
assert!(!methods.iter().any(|method| method == "turn/start"));
Ok(())