Lightweight coding agent that runs in your terminal
Rust
Refresh the TUI model picker from the app server (#41467)
Benjamin Carlsson5fc7840cf6d0
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rsindex 84c22011bf..84840b0332 100644--- a/codex-rs/tui/src/app/event_dispatch.rs+++ b/codex-rs/tui/src/app/event_dispatch.rs@@ -1518,6 +1518,18 @@ impl App {}}}+ AppEvent::FetchModels { request_id } => {+ if self.chat_widget.model_popup_request_is_current(request_id) {+ app_server.fetch_models(request_id, self.app_event_tx.clone());+ }+ }+ AppEvent::ModelsLoaded { request_id, result } => {+ if self.chat_widget.on_models_loaded(request_id, result) {+ self.model_catalog = self.chat_widget.model_catalog();+ app_server.set_available_models(self.model_catalog.try_list_models()?);+ self.sync_active_thread_service_tier_to_cached_session().await;+ }+ }AppEvent::OpenReasoningPopup { model } => {self.chat_widget.open_reasoning_popup(model);}@@ -1571,8 +1583,8 @@ impl App {self.chat_widget.open_plan_reasoning_scope_prompt(model, effort);}- AppEvent::OpenAllModelsPopup { models } => {- self.chat_widget.open_all_models_popup(models);+ AppEvent::OpenAllModelsPopup => {+ self.chat_widget.open_all_models_popup();}AppEvent::OpenFullAccessConfirmation {preset,diff --git a/codex-rs/tui/src/app/tests/model_catalog.rs b/codex-rs/tui/src/app/tests/model_catalog.rsindex b0eff0056c..88e1c125f4 100644--- a/codex-rs/tui/src/app/tests/model_catalog.rs+++ b/codex-rs/tui/src/app/tests/model_catalog.rs@@ -1,6 +1,7 @@use super::*;use assert_matches::assert_matches;use codex_config::types::ModelAvailabilityNuxConfig;+use codex_protocol::config_types::ServiceTier;use codex_protocol::openai_models::ModelAvailabilityNux;use pretty_assertions::assert_eq;use tokio::sync::mpsc::unbounded_channel;@@ -9,6 +10,116 @@ fn all_model_presets() -> Vec<ModelPreset> {crate::test_support::TEST_MODEL_PRESETS.clone()}+#[tokio::test]+async fn model_picker_refresh_updates_app_catalog_from_app_server() -> Result<()> {+ let (mut app, mut rx, _op_rx) = make_test_app_with_channels().await;+ let mut app_server = start_config_write_test_app_server(&app).await?;+ let mut tui = crate::tui::test_support::make_test_tui()?;+ let fast = Some(ServiceTier::Fast.request_value());+ let thread_id = ThreadId::new();+ let mut session = test_thread_session(thread_id, test_path_buf("/tmp/project"));+ session.model = "gpt-5.4".to_string();+ app.primary_thread_id = Some(thread_id);+ app.active_thread_id = Some(thread_id);+ app.primary_session_configured = Some(session.clone());+ app.thread_event_channels.insert(+ thread_id,+ ThreadEventChannel::new_with_session(/*capacity*/ 4, session.clone(), Vec::new()),+ );+ app.chat_widget.handle_thread_session(session.clone());+ app.chat_widget+ .set_feature_enabled(Feature::FastMode, /*enabled*/ true);+ app.chat_widget.open_model_popup();+ let request_id = std::iter::from_fn(|| rx.try_recv().ok())+ .find_map(|event| match event {+ AppEvent::FetchModels { request_id } => Some(request_id),+ _ => None,+ })+ .expect("initial model request");+ let mut hidden = all_model_presets();+ for preset in &mut hidden {+ preset.show_in_picker = false;+ }+ Box::pin(app.handle_event(+ &mut tui,+ &mut app_server,+ AppEvent::ModelsLoaded {+ request_id,+ result: Ok(hidden),+ },+ ))+ .await?;+ app.chat_widget.open_model_popup();+ assert!(app.chat_widget.no_modal_or_popup_active());+ let request = std::iter::from_fn(|| rx.try_recv().ok())+ .find(|event| matches!(event, AppEvent::FetchModels { .. }))+ .expect("catalog request");++ Box::pin(app.handle_event(&mut tui, &mut app_server, request)).await?;+ let mut loaded = tokio::time::timeout(Duration::from_secs(/*secs*/ 10), async {+ loop {+ if let Some(event @ AppEvent::ModelsLoaded { .. }) = rx.recv().await {+ break event;+ }+ }+ })+ .await?;+ let AppEvent::ModelsLoaded {+ result: Ok(models), ..+ } = &mut loaded+ else {+ panic!("model/list should return models");+ };+ assert!(!models.is_empty());+ for model in models.iter_mut() {+ model.is_default = model.model == "gpt-5.4";+ model.default_service_tier = model+ .is_default+ .then(|| ServiceTier::Fast.request_value().to_string());+ }+ let expected = models.clone();+ Box::pin(app.handle_event(&mut tui, &mut app_server, loaded)).await?;+ assert!(app.chat_widget.no_modal_or_popup_active());+ app.chat_widget.open_model_popup();+ assert!(!app.chat_widget.no_modal_or_popup_active());++ session.service_tier = fast.map(str::to_string);+ let channel = &app.thread_event_channels[&thread_id];+ let cached = channel.store.lock().await.session.clone();+ assert_eq!(+ (&app.primary_session_configured, &cached),+ (&Some(session.clone()), &Some(session.clone()))+ );+ app.chat_widget.handle_thread_session(test_thread_session(+ ThreadId::new(),+ test_path_buf("/tmp/other"),+ ));+ app.chat_widget.handle_thread_session(cached.unwrap());+ assert_eq!(app.chat_widget.current_service_tier(), fast);+ let stale = AppEvent::ModelsLoaded {+ request_id: uuid::Uuid::new_v4(),+ result: Ok(all_model_presets()),+ };+ Box::pin(app.handle_event(&mut tui, &mut app_server, stale)).await?;+ assert_eq!(+ (+ app.model_catalog.try_list_models().unwrap(),+ app.chat_widget.model_catalog().try_list_models().unwrap(),+ ),+ (expected.clone(), expected)+ );+ let mut config = app.config.clone();+ config.service_tier = None;+ config.features.enable(Feature::FastMode)?;+ for (model, expected_tier) in [(None, fast), (Some("gpt-5.2"), Some("default"))] {+ config.model = model.map(str::to_string);+ let started = app_server.start_thread(&config).await?;+ assert_eq!(started.session.service_tier.as_deref(), expected_tier);+ }+ app_server.shutdown().await?;+ Ok(())+}+fn model_presets_with_test_upgrades() -> Vec<ModelPreset> {let mut presets = all_model_presets();for model in ["gpt-5.2", "gpt-5.4"] {diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rsindex a8126066d9..23d7928cfe 100644--- a/codex-rs/tui/src/app_event.rs+++ b/codex-rs/tui/src/app_event.rs@@ -982,6 +982,15 @@ pub(crate) enum AppEvent {service_tier: Option<String>,},+ /// Fetch the current catalog even when cached models produce no picker.+ FetchModels {+ request_id: uuid::Uuid,+ },+ ModelsLoaded {+ request_id: uuid::Uuid,+ result: Result<Vec<ModelPreset>, String>,+ },+/// Open the reasoning selection popup after picking a model.OpenReasoningPopup {model: ModelPreset,@@ -1005,9 +1014,7 @@ pub(crate) enum AppEvent {},/// Open the full model picker (non-auto models).- OpenAllModelsPopup {- models: Vec<ModelPreset>,- },+ OpenAllModelsPopup,/// Open the confirmation prompt before enabling full access mode.OpenFullAccessConfirmation {diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rsindex 551ed157c2..c7908ca637 100644--- a/codex-rs/tui/src/app_server_session.rs+++ b/codex-rs/tui/src/app_server_session.rs@@ -5,6 +5,7 @@mod fs;mod history;+mod models;mod rollout_history;pub(crate) use history::HISTORY_ITEM_PAGE_LIMIT;diff --git a/codex-rs/tui/src/app_server_session/models.rs b/codex-rs/tui/src/app_server_session/models.rsnew file mode 100644index 0000000000..ca945f854f--- /dev/null+++ b/codex-rs/tui/src/app_server_session/models.rs@@ -0,0 +1,50 @@+//! Fetch picker models without blocking the event loop and keep new-thread defaults in sync.++use super::AppServerSession;+use super::model_preset_from_api_model;+use crate::app_event::AppEvent;+use crate::app_event_sender::AppEventSender;+use codex_app_server_protocol::ClientRequest;+use codex_app_server_protocol::ModelListParams;+use codex_app_server_protocol::ModelListResponse;+use codex_app_server_protocol::RequestId;+use codex_protocol::openai_models::ModelPreset;+use uuid::Uuid;++impl AppServerSession {+ pub(crate) fn set_available_models(&mut self, models: Vec<ModelPreset>) {+ if let Some(default) = models+ .iter()+ .find(|model| model.is_default)+ .or(models.first())+ {+ self.default_model = Some(default.model.clone());+ }+ self.available_models = models;+ }++ pub(crate) fn fetch_models(&self, request_id: Uuid, app_event_tx: AppEventSender) {+ let request_handle = self.request_handle();+ tokio::spawn(async move {+ let result = request_handle+ .request_typed::<ModelListResponse>(ClientRequest::ModelList {+ request_id: RequestId::String(format!("model-list-{request_id}")),+ params: ModelListParams {+ cursor: None,+ limit: None,+ include_hidden: Some(true),+ },+ })+ .await+ .map(|response| {+ response+ .data+ .into_iter()+ .map(model_preset_from_api_model)+ .collect()+ })+ .map_err(|err| err.to_string());+ app_event_tx.send(AppEvent::ModelsLoaded { request_id, result });+ });+ }+}diff --git a/codex-rs/tui/src/bottom_pane/list_selection_view.rs b/codex-rs/tui/src/bottom_pane/list_selection_view.rsindex 7c01406612..7895bfd73b 100644--- a/codex-rs/tui/src/bottom_pane/list_selection_view.rs+++ b/codex-rs/tui/src/bottom_pane/list_selection_view.rs@@ -262,7 +262,7 @@ pub(crate) struct ListSelectionView {active_tab_idx: Option<usize>,state: ScrollState,completion: Option<ViewCompletion>,- dismiss_after_child_accept: bool,+ pub(super) dismiss_after_child_accept: bool,app_event_tx: AppEventSender,is_searchable: bool,search_query: String,diff --git a/codex-rs/tui/src/bottom_pane/mod.rs b/codex-rs/tui/src/bottom_pane/mod.rsindex 592c835e20..67cdb0a23d 100644--- a/codex-rs/tui/src/bottom_pane/mod.rs+++ b/codex-rs/tui/src/bottom_pane/mod.rs@@ -1198,6 +1198,7 @@ impl BottomPane {}/// Replace the newest matching selection view without disturbing views stacked above it.+ /// Preserve pending parent cleanup when an already-open child is accepted.pub(crate) fn replace_selection_view_if_present(&mut self,view_id: &'static str,@@ -1213,11 +1214,13 @@ impl BottomPane {let replaces_active_view = index + 1 == self.view_stack.len();self.apply_standard_popup_hint(&mut params);- self.view_stack[index] = Box::new(list_selection_view::ListSelectionView::new(+ let mut view = list_selection_view::ListSelectionView::new(params,self.app_event_tx.clone(),self.keymap.list.clone(),- ));+ );+ view.dismiss_after_child_accept = self.view_stack[index].dismiss_after_child_accept();+ self.view_stack[index] = Box::new(view);if replaces_active_view {self.schedule_active_view_frame();}diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rsindex b5215116e6..ab529a0fd6 100644--- a/codex-rs/tui/src/chatwidget.rs+++ b/codex-rs/tui/src/chatwidget.rs@@ -384,6 +384,7 @@ use self::plugins::PluginListFetchState;use self::plugins::PluginsCacheState;mod plan_implementation;use self::plan_implementation::PLAN_IMPLEMENTATION_TITLE;+mod model_popup_state;mod model_popups;mod notifications;use self::notifications::Notification;@@ -565,6 +566,8 @@ pub(crate) struct ChatWidget {has_chatgpt_account: bool,has_codex_backend_auth: bool,model_catalog: Arc<ModelCatalog>,+ model_popup_request_id: Option<uuid::Uuid>,+ model_popup_model_ids: Vec<String>,session_telemetry: SessionTelemetry,session_header: SessionHeader,initial_user_message: Option<UserMessage>,diff --git a/codex-rs/tui/src/chatwidget/constructor.rs b/codex-rs/tui/src/chatwidget/constructor.rsindex c4fa4c9c77..7c3dec2ae6 100644--- a/codex-rs/tui/src/chatwidget/constructor.rs+++ b/codex-rs/tui/src/chatwidget/constructor.rs@@ -119,6 +119,8 @@ impl ChatWidget {has_chatgpt_account,has_codex_backend_auth,model_catalog,+ model_popup_request_id: None,+ model_popup_model_ids: Vec::new(),session_telemetry,session_header: SessionHeader::new(header_model),initial_user_message,diff --git a/codex-rs/tui/src/chatwidget/model_popup_state.rs b/codex-rs/tui/src/chatwidget/model_popup_state.rsnew file mode 100644index 0000000000..ebc6a4111e--- /dev/null+++ b/codex-rs/tui/src/chatwidget/model_popup_state.rs@@ -0,0 +1,68 @@+//! Accept current account-scoped model replies and refresh present pickers without reopening them.++use super::model_popups::ALL_MODELS_SELECTION_VIEW_ID;+use super::model_popups::MODEL_SELECTION_VIEW_ID;+use super::*;++impl ChatWidget {+ fn model_popup_view_id(&self) -> Option<&'static str> {+ [MODEL_SELECTION_VIEW_ID, ALL_MODELS_SELECTION_VIEW_ID]+ .into_iter()+ .find(|view_id| {+ self.bottom_pane+ .selected_index_for_present_view(view_id)+ .is_some()+ })+ }++ pub(crate) fn model_popup_request_is_current(&self, request_id: uuid::Uuid) -> bool {+ self.model_popup_request_id == Some(request_id)+ }++ pub(crate) fn on_models_loaded(+ &mut self,+ request_id: uuid::Uuid,+ result: Result<Vec<ModelPreset>, String>,+ ) -> bool {+ if !self.model_popup_request_is_current(request_id) {+ return false;+ }+ self.model_popup_request_id = None;+ let Ok(presets) = result else {+ return false;+ };+ if presets.is_empty()+ || self.model_catalog.try_list_models().ok().as_ref() == Some(&presets)+ {+ return false;+ }+ self.model_catalog = Arc::new(ModelCatalog::new(presets.clone()));+ self.refresh_effective_service_tier();+ self.refresh_model_dependent_surfaces();+ // Refresh an existing parent without reopening it or interrupting its reasoning child.+ match self.model_popup_view_id() {+ Some(MODEL_SELECTION_VIEW_ID) => self.open_model_popup_with_presets(presets),+ Some(ALL_MODELS_SELECTION_VIEW_ID) => self.open_all_models_popup(),+ _ => {}+ }+ true+ }++ pub(super) fn show_model_selection_view(&mut self, mut params: SelectionViewParams) {+ let selected_index = params+ .view_id+ .and_then(|view_id| self.bottom_pane.selected_index_for_present_view(view_id));+ let selected_model = selected_index.and_then(|index| self.model_popup_model_ids.get(index));+ params.initial_selected_idx = params+ .items+ .iter()+ .position(|item| Some(&item.name) == selected_model);+ self.model_popup_model_ids = params.items.iter().map(|item| item.name.clone()).collect();+ if let Some(view_id) = params.view_id.filter(|_| selected_index.is_some()) {+ self.bottom_pane+ .replace_selection_view_if_present(view_id, params);+ } else {+ self.bottom_pane.show_selection_view(params);+ }+ }+}diff --git a/codex-rs/tui/src/chatwidget/model_popups.rs b/codex-rs/tui/src/chatwidget/model_popups.rsindex 0fb20b5e7c..0210428f4f 100644--- a/codex-rs/tui/src/chatwidget/model_popups.rs+++ b/codex-rs/tui/src/chatwidget/model_popups.rs@@ -6,6 +6,8 @@use super::*;const ULTRA_REASONING_CONCURRENCY_WARNING_THRESHOLD: usize = 8;+pub(super) const MODEL_SELECTION_VIEW_ID: &str = "model-selection";+pub(super) const ALL_MODELS_SELECTION_VIEW_ID: &str = "all-models-selection";impl ChatWidget {/// Open a popup to choose a quick auto model. Selecting "All models"@@ -29,7 +31,11 @@ impl ChatWidget {return;}};+ let request_id = uuid::Uuid::new_v4();+ self.model_popup_request_id = Some(request_id);self.open_model_popup_with_presets(presets);+ // Show cached choices immediately and update any still-present picker when the reply arrives.+ self.app_event_tx.send(AppEvent::FetchModels { request_id });}fn model_menu_header(&self, title: &str, subtitle: &str) -> Box<dyn Renderable> {@@ -89,7 +95,7 @@ impl ChatWidget {.partition(|preset| Self::is_auto_model(&preset.model));if auto_presets.is_empty() {- self.open_all_models_popup(other_presets);+ self.open_all_models_popup_with_view_id(other_presets, MODEL_SELECTION_VIEW_ID);return;}@@ -139,11 +145,8 @@ impl ChatWidget {.collect();if !other_presets.is_empty() {- let all_models = other_presets;- let actions: Vec<SelectionAction> = vec![Box::new(move |tx| {- tx.send(AppEvent::OpenAllModelsPopup {- models: all_models.clone(),- });+ let actions: Vec<SelectionAction> = vec![Box::new(|tx| {+ tx.send(AppEvent::OpenAllModelsPopup);})];let is_current = !items.iter().any(|item| item.is_current);@@ -165,7 +168,8 @@ impl ChatWidget {"Select Model","Pick a quick auto mode or browse all models.",);- self.bottom_pane.show_selection_view(SelectionViewParams {+ self.show_model_selection_view(SelectionViewParams {+ view_id: Some(MODEL_SELECTION_VIEW_ID),footer_hint: Some(standard_popup_hint_line()),items,header,@@ -173,7 +177,7 @@ impl ChatWidget {});}- fn is_auto_model(model: &str) -> bool {+ pub(super) fn is_auto_model(model: &str) -> bool {model.starts_with("codex-auto-")}@@ -186,8 +190,24 @@ impl ChatWidget {}}- pub(crate) fn open_all_models_popup(&mut self, presets: Vec<ModelPreset>) {+ pub(crate) fn open_all_models_popup(&mut self) {+ let presets = self+ .model_catalog+ .try_list_models()+ .unwrap_or_default()+ .into_iter()+ .filter(|preset| preset.show_in_picker && !Self::is_auto_model(&preset.model))+ .collect();+ self.open_all_models_popup_with_view_id(presets, ALL_MODELS_SELECTION_VIEW_ID);+ }++ fn open_all_models_popup_with_view_id(+ &mut self,+ presets: Vec<ModelPreset>,+ view_id: &'static str,+ ) {if presets.is_empty() {+ self.bottom_pane.dismiss_view_by_id(view_id);self.add_info_message("No additional models are available right now.".to_string(),/*hint*/ None,@@ -224,7 +244,8 @@ impl ChatWidget {"Select Model and Effort","Access legacy models by running codex -m <model_name> or in your config.toml",);- self.bottom_pane.show_selection_view(SelectionViewParams {+ self.show_model_selection_view(SelectionViewParams {+ view_id: Some(view_id),footer_hint: Some(self.bottom_pane.standard_popup_hint_line()),items,header,diff --git a/codex-rs/tui/src/chatwidget/settings.rs b/codex-rs/tui/src/chatwidget/settings.rsindex d11445895b..75f3e8fba4 100644--- a/codex-rs/tui/src/chatwidget/settings.rs+++ b/codex-rs/tui/src/chatwidget/settings.rs@@ -216,6 +216,7 @@ impl ChatWidget {) {// Account-update notifications are the identity boundary. The visible account fields can// be identical across two accounts, so always invalidate account-scoped requests and data.+ self.model_popup_request_id = None;self.invalidate_connector_scope();self.clear_pending_token_activity_refreshes();self.clear_pending_rate_limit_reset_requests();diff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refresh_preserves_highlight.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refresh_preserves_highlight.snapnew file mode 100644index 0000000000..f838568bed--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refresh_preserves_highlight.snap@@ -0,0 +1,13 @@+---+source: tui/src/chatwidget/tests/popups_and_settings.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Select Model and Effort+ Access legacy models by running codex -m <model_name> or in your config.toml++› 1. gpt-5.5 Frontier model for complex coding, research, and real-+ world work.+ 2. gpt-5.2 (current) Optimized for professional work and long-running+ agents.++ Press enter to confirm or esc to go backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snapnew file mode 100644index 0000000000..de697ffd62--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_auto_models.snap@@ -0,0 +1,12 @@+---+source: tui/src/chatwidget/tests/popups_and_settings.rs+expression: "render_bottom_popup(&chat, 80)"+---+ Select Model+ Pick a quick auto mode or browse all models.++ 1. codex-auto-test Auto model+› 2. All models (current) Choose a specific model and reasoning level+ (current: gpt-5.2)++ Press enter to confirm or esc to go backdiff --git a/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_service_tier_controls.snap b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_service_tier_controls.snapnew file mode 100644index 0000000000..d6477eeace--- /dev/null+++ b/codex-rs/tui/src/chatwidget/snapshots/codex_tui__chatwidget__tests__model_picker_refreshes_service_tier_controls.snap@@ -0,0 +1,7 @@+---+source: tui/src/chatwidget/tests/popups_and_settings.rs+expression: "render_bottom_popup(&chat, 80)"+---+› /fast++ gpt-5.4 default · /tmp/projectdiff --git a/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs b/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rsindex 17a52f8c07..f0cb0be02a 100644--- a/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs+++ b/codex-rs/tui/src/chatwidget/tests/popups_and_settings.rs@@ -3236,6 +3236,286 @@ async fn model_selection_popup_snapshot() {assert_chatwidget_snapshot!("model_selection_popup", popup);}+fn apply_model_list_response(chat: &mut ChatWidget, presets: Vec<ModelPreset>) {+ let request_id = chat.model_popup_request_id.expect("pending model request");+ assert!(chat.on_models_loaded(request_id, Ok(presets)));+}++#[tokio::test]+async fn model_picker_refresh_rejects_obsolete_and_unusable_replies() {+ let (mut chat, _rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.2")).await;+ chat.thread_id = Some(ThreadId::new());+ let initial = chat.model_catalog.try_list_models().unwrap();+ let mut refreshed = initial.clone();+ refreshed[0].description = "Updated model details".to_string();+ chat.open_model_popup();+ let old_request = chat.model_popup_request_id.unwrap();+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ chat.open_model_popup();+ let current_request = chat.model_popup_request_id.unwrap();+ assert!(!chat.on_models_loaded(old_request, Ok(refreshed.clone())));+ assert!(chat.model_popup_request_is_current(current_request));+ // Identical visible account fields still mark an account boundary.+ chat.update_account_state(+ chat.status_account_display.clone(),+ chat.plan_type,+ chat.has_chatgpt_account,+ chat.has_codex_backend_auth,+ );+ assert!(!chat.on_models_loaded(current_request, Ok(refreshed.clone())));+ assert_eq!(chat.model_catalog.try_list_models().unwrap(), initial);++ for result in [+ Err("unavailable".to_string()),+ Ok(Vec::new()),+ Ok(initial.clone()),+ ] {+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ chat.open_model_popup();+ let request_id = chat.model_popup_request_id.unwrap();+ let before = render_bottom_popup(&chat, /*width*/ 80);+ assert!(!chat.on_models_loaded(request_id, result));+ assert!(!chat.model_popup_request_is_current(request_id));+ assert_eq!(chat.model_catalog.try_list_models().unwrap(), initial);+ assert_eq!(render_bottom_popup(&chat, /*width*/ 80), before);+ }+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ chat.open_model_popup();+ apply_model_list_response(&mut chat, refreshed.clone());+ assert_eq!(chat.model_catalog.try_list_models().unwrap(), refreshed);+}++#[tokio::test]+async fn model_picker_refreshes_startup_catalog() {+ for (explicit_all_models, hidden_startup) in [(false, false), (true, false), (false, true)] {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.2")).await;+ chat.thread_id = Some(ThreadId::new());+ let mut startup = vec![get_available_model(&chat, "gpt-5.2")];+ let mut refreshed = chat.model_catalog.try_list_models().unwrap();+ let mut auto = startup[0].clone();+ auto.model = "codex-auto-test".to_string();+ auto.id = auto.model.clone();+ auto.description = "Auto model".to_string();+ refreshed.push(auto);+ startup[0].show_in_picker = !hidden_startup;+ chat.model_catalog = Arc::new(ModelCatalog::new(startup.clone()));+ chat.open_model_popup();+ assert!(+ std::iter::from_fn(|| rx.try_recv().ok())+ .any(|event| matches!(event, AppEvent::FetchModels { .. }))+ );+ if explicit_all_models {+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ chat.open_all_models_popup();+ }++ apply_model_list_response(&mut chat, refreshed.clone());+ if hidden_startup {+ assert!(chat.no_modal_or_popup_active());+ chat.open_model_popup();+ }++ assert_eq!(chat.model_catalog.try_list_models().unwrap(), refreshed);+ insta::allow_duplicates! {+ assert_chatwidget_snapshot!(+ if explicit_all_models {+ "model_selection_popup"+ } else {+ "model_picker_refreshes_auto_models"+ },+ render_bottom_popup(&chat, /*width*/ 80)+ );+ }+ }+}++#[tokio::test]+async fn model_picker_queued_all_models_uses_refreshed_catalog() {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.2")).await;+ chat.thread_id = Some(ThreadId::new());+ let refreshed = chat.model_catalog.try_list_models().unwrap();+ let preset = get_available_model(&chat, "gpt-5.2");+ let mut auto = preset.clone();+ auto.model = "codex-auto-test".to_string();+ auto.id = auto.model.clone();+ chat.model_catalog = Arc::new(ModelCatalog::new(vec![auto, preset]));+ chat.open_model_popup();+ assert_matches!(rx.try_recv(), Ok(AppEvent::FetchModels { .. }));+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));+ assert_eq!(chat.bottom_pane.active_view_id(), None);+ // Apply the model/list reply before the queued All models intent is handled.+ apply_model_list_response(&mut chat, refreshed);+ assert_matches!(rx.try_recv(), Ok(AppEvent::OpenAllModelsPopup));+ chat.open_all_models_popup();+ assert_chatwidget_snapshot!(+ "model_selection_popup",+ render_bottom_popup(&chat, /*width*/ 80)+ );+}++#[tokio::test]+async fn model_picker_refresh_preserves_highlight() {+ for (remove_selected, reasoning_submenu, expected) in [+ (false, false, "gpt-5.5"),+ (true, false, "gpt-5.2"),+ (false, true, "gpt-5.5"),+ (true, true, "gpt-5.2"),+ ] {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.2")).await;+ chat.thread_id = Some(ThreadId::new());+ let mut presets = vec![+ get_available_model(&chat, "gpt-5.2"),+ get_available_model(&chat, "gpt-5.5"),+ ];+ chat.model_catalog = Arc::new(ModelCatalog::new(presets.clone()));+ chat.open_model_popup();+ chat.handle_key_event(KeyEvent::from(KeyCode::Down));+ if reasoning_submenu {+ chat.open_reasoning_popup(presets[1].clone());+ }+ let before = render_bottom_popup(&chat, /*width*/ 80);+ presets.reverse();+ if remove_selected {+ presets.remove(/*index*/ 0);+ }+ apply_model_list_response(&mut chat, presets);+ if reasoning_submenu {+ assert_eq!(render_bottom_popup(&chat, /*width*/ 80), before);+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ }+ if !remove_selected {+ insta::allow_duplicates! {+ assert_chatwidget_snapshot!(+ "model_picker_refresh_preserves_highlight",+ render_bottom_popup(&chat, /*width*/ 80)+ );+ }+ }+ while rx.try_recv().is_ok() {}+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));+ let selected = assert_matches!(rx.try_recv(), Ok(AppEvent::OpenReasoningPopup { model }) => model.model);+ assert_eq!(selected, expected);+ }+}++#[tokio::test]+async fn model_picker_refreshes_service_tier_controls() {+ let (mut chat, _rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.4")).await;+ chat.thread_id = Some(ThreadId::new());+ set_fast_mode_test_catalog(&mut chat);+ chat.set_feature_enabled(Feature::FastMode, /*enabled*/ true);+ chat.set_service_tier(Some(ServiceTier::Fast.request_value().to_string()));+ let mut refreshed = chat.model_catalog.try_list_models().unwrap();+ refreshed+ .iter_mut()+ .for_each(|model| model.service_tiers.clear());+ chat.open_model_popup();+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));++ apply_model_list_response(&mut chat, refreshed);++ assert_eq!(chat.current_service_tier(), None);+ chat.bottom_pane+ .set_composer_text("/fast".to_string(), Vec::new(), Vec::new());+ assert_chatwidget_snapshot!(+ "model_picker_refreshes_service_tier_controls",+ normalize_snapshot_paths(render_bottom_popup(&chat, /*width*/ 80))+ );+}++#[tokio::test]+async fn model_picker_refresh_preserves_dismissal_and_reasoning_submenu() {+ for (dismiss, explicit_all_models, accept_reasoning) in [+ (true, false, false),+ (false, false, false),+ (false, true, false),+ (false, false, true),+ (false, true, true),+ ] {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.2")).await;+ chat.thread_id = Some(ThreadId::new());+ let preset = get_available_model(&chat, "gpt-5.2");+ let refreshed = chat.model_catalog.try_list_models().unwrap();+ chat.model_catalog = Arc::new(ModelCatalog::new(vec![preset.clone()]));+ chat.open_model_popup();+ assert_matches!(rx.try_recv(), Ok(AppEvent::FetchModels { .. }));+ if explicit_all_models {+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ chat.open_all_models_popup();+ }+ if dismiss {+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ } else {+ chat.handle_key_event(KeyEvent::from(KeyCode::Enter));+ let model =+ assert_matches!(rx.try_recv(), Ok(AppEvent::OpenReasoningPopup { model }) => model);+ chat.open_reasoning_popup(model);+ }+ let before = render_bottom_popup(&chat, /*width*/ 80);++ apply_model_list_response(&mut chat, refreshed.clone());++ assert_eq!(chat.model_catalog.try_list_models().unwrap(), refreshed);+ assert_eq!(render_bottom_popup(&chat, /*width*/ 80), before);+ if !dismiss {+ chat.handle_key_event(KeyEvent::from(if accept_reasoning {+ KeyCode::Enter+ } else {+ KeyCode::Esc+ }));+ }+ if dismiss || accept_reasoning {+ assert!(chat.no_modal_or_popup_active());+ } else {+ insta::allow_duplicates! {+ assert_chatwidget_snapshot!(+ "model_selection_popup",+ render_bottom_popup(&chat, /*width*/ 80)+ );+ }+ }+ }+}++#[tokio::test]+async fn model_picker_refresh_dismisses_empty_choices() {+ for (explicit_all_models, reasoning_submenu) in+ [(false, false), (true, false), (false, true), (true, true)]+ {+ let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.2")).await;+ chat.thread_id = Some(ThreadId::new());+ let mut preset = get_available_model(&chat, "gpt-5.2");+ chat.open_model_popup();+ if explicit_all_models {+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ chat.open_all_models_popup();+ }+ if reasoning_submenu {+ chat.open_reasoning_popup(preset.clone());+ }+ let before = render_bottom_popup(&chat, /*width*/ 80);+ if explicit_all_models {+ preset.model = "codex-auto-test".to_string();+ } else {+ preset.show_in_picker = false;+ }+ while rx.try_recv().is_ok() {}+ apply_model_list_response(&mut chat, vec![preset]);+ if reasoning_submenu {+ assert_eq!(render_bottom_popup(&chat, /*width*/ 80), before);+ chat.handle_key_event(KeyEvent::from(KeyCode::Esc));+ }+ assert_eq!(chat.bottom_pane.active_view_id(), None);+ let cell = assert_matches!(rx.try_recv(), Ok(AppEvent::InsertHistoryCell(cell)) => cell);+ insta::allow_duplicates! {+ insta::assert_snapshot!(+ lines_to_single_string(&cell.display_lines(/*width*/ 80)),+ @"• No additional models are available right now."+ );+ }+ }+}+#[tokio::test]async fn personality_selection_popup_snapshot() {let (mut chat, _rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.4")).await;