Load legacy MCP inventory off the TUI loop

codex-rs/tui/src/app.rs

@@ -630,23 +630,54 @@ fn spawn_startup_thread_start(
     app_server: &AppServerSession,
     config: Config,
     app_event_tx: AppEventSender,
+    load_legacy_mcp_server_names: bool,
 ) {
     let request_handle = app_server.request_handle();
     let thread_params_mode = app_server.thread_params_mode();
     let remote_cwd_override = app_server.remote_cwd_override().map(Path::to_path_buf);
     tokio::spawn(async move {
         let result = crate::app_server_session::start_thread_with_request_handle(
-            request_handle,
+            request_handle.clone(),
             config,
             thread_params_mode,
             remote_cwd_override,
         )
-        .await
-        .map_err(|err| format!("{err:#}"));
+        .await;
+        let result = match result {
+            Ok(mut started) => {
+                if load_legacy_mcp_server_names && started.mcp_server_names.is_none() {
+                    load_legacy_startup_mcp_server_names(request_handle, &mut started).await;
+                }
+                Ok(started)
+            }
+            Err(err) => Err(format!("{err:#}")),
+        };
         app_event_tx.send(AppEvent::StartupThreadStarted { result });
     });
 }
 
+async fn load_legacy_startup_mcp_server_names(
+    request_handle: AppServerRequestHandle,
+    started: &mut AppServerStartedThread,
+) {
+    let server_names = match background_requests::fetch_all_mcp_server_statuses(
+        request_handle,
+        McpServerStatusDetail::ToolsAndAuthOnly,
+        Some(started.session.thread_id),
+    )
+    .await
+    {
+        Ok(statuses) => statuses.into_iter().map(|status| status.name).collect(),
+        Err(err) => {
+            tracing::warn!(
+                "failed to load startup MCP server names from an older app server: {err}"
+            );
+            Vec::new()
+        }
+    };
+    started.mcp_server_names = Some(server_names);
+}
+
 #[derive(Debug, Clone, PartialEq, Eq)]
 enum ActiveTurnSteerRace {
     Missing,
@@ -893,7 +924,12 @@ impl App {
         );
         let (mut chat_widget, initial_started_thread) = match session_selection {
             SessionSelection::StartFresh | SessionSelection::Exit => {
-                spawn_startup_thread_start(&app_server, config.clone(), app_event_tx.clone());
+                spawn_startup_thread_start(
+                    &app_server,
+                    config.clone(),
+                    app_event_tx.clone(),
+                    /*load_legacy_mcp_server_names*/ allow_startup_text,
+                );
                 // Count a startup tooltip once the initial chat widget can render it.
                 let startup_tooltip_override =
                     prepare_startup_tooltip_override(&mut config, &available_models, is_first_run)

codex-rs/tui/src/app/session_lifecycle.rs

@@ -517,31 +517,8 @@ impl App {
                 turns,
                 mcp_server_names,
             }) => {
-                let mcp_server_names = match mcp_server_names {
-                    Some(mcp_server_names) => mcp_server_names,
-                    None if self.chat_widget.startup_draft_needs_mcp_server_names() => {
-                        match super::background_requests::fetch_all_mcp_server_statuses(
-                            app_server.request_handle(),
-                            McpServerStatusDetail::ToolsAndAuthOnly,
-                            Some(session.thread_id),
-                        )
-                        .await
-                        {
-                            Ok(statuses) => {
-                                statuses.into_iter().map(|status| status.name).collect()
-                            }
-                            Err(err) => {
-                                tracing::warn!(
-                                    "failed to load startup MCP server names from an older app server: {err}"
-                                );
-                                Vec::new()
-                            }
-                        }
-                    }
-                    None => Vec::new(),
-                };
                 self.chat_widget
-                    .set_startup_draft_expected_mcp_servers(mcp_server_names);
+                    .set_startup_draft_expected_mcp_servers(mcp_server_names.unwrap_or_default());
                 self.enqueue_primary_thread_session(session, turns).await?;
                 self.chat_widget.maybe_send_next_queued_input();
             }

codex-rs/tui/src/app/tests/startup.rs

@@ -255,6 +255,8 @@ async fn restored_startup_draft_loads_mcp_names_from_older_app_servers() {
         .await
         .expect("startup thread");
     started.mcp_server_names = None;
+    load_legacy_startup_mcp_server_names(app_server.request_handle(), &mut started).await;
+    assert_eq!(started.mcp_server_names, Some(Vec::new()));
 
     app.handle_startup_thread_started(&mut app_server, Ok(started))
         .await

codex-rs/tui/src/chatwidget/input_flow.rs

@@ -26,10 +26,6 @@ impl ChatWidget {
         self.finish_startup_draft_protection_if_ready();
     }
 
-    pub(crate) fn startup_draft_needs_mcp_server_names(&self) -> bool {
-        self.startup_draft_pending_mcp_servers.is_some()
-    }
-
     pub(super) fn finish_startup_draft_protection_if_ready(&mut self) {
         let startup_ready = self.startup_draft_rendered
             && self.is_session_configured()