Files
codex/codex-rs/tui/src/app/model_defaults.rs
T
Benjamin Carlsson f8580db472 Reflect accepted cloud model selections in TUI status (#61350)
## Why

After a cloud model selection was accepted for future turns, status displays still showed the session's serving model and reasoning effort. A reasoning-only `/model` command also resolved against that model instead of the accepted selection.

## What changed

- Show the accepted model's display name and reasoning effort in the status line, terminal title, and `/status`.
- Resolve reasoning-only `/model` commands against the selected model.
- Share the session-only model change confirmation between cloud and local selections, including reasoning effort and service tier when present.

## Testing

Extend cloud model admission coverage to check accepted selections in status output, reasoning-only commands, and unchanged status before acceptance and after session metadata clears the selection.

GitOrigin-RevId: cc50c2b0a98e884138ad2c2339c79c28ee3d346a
2026-11-13 18:48:50 +00:00

271 lines
11 KiB
Rust

//! Apply complete session model choices after server acceptance, separately from saved defaults.
//!
//! A successful config write can still be overridden. Report that distinction without
//! replacing the active task's explicit selection with launch-time configuration.
use super::App;
use crate::app_server_session::AppServerSession;
use crate::app_server_session::ThreadParamsMode;
use crate::app_server_session::ThreadSettingsOwner;
use crate::service_tier_resolution;
use codex_app_server_client::AppServerRequestHandle;
use codex_app_server_protocol::ConfigEdit;
use codex_app_server_protocol::WriteStatus;
use codex_protocol::config_types::ModeKind;
use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use codex_protocol::config_types::ServiceTier;
use codex_protocol::openai_models::MODEL_SPECIALTY_CYBER;
use codex_protocol::openai_models::ReasoningEffort;
use color_eyre::eyre::Result;
impl App {
pub(super) async fn apply_default_model_selection(
&mut self,
app_server: &mut AppServerSession,
model: String,
effort: Option<ReasoningEffort>,
) {
if self
.active_thread_model_setting_update_params(model.clone())
.is_some_and(|params| params.permissions.is_some())
&& self.reject_pending_permission_change()
{
return;
}
let model_changed = self.chat_widget.current_model() != model
|| self.chat_widget.current_collaboration_mode().model() != model;
if model_changed {
self.chat_widget.set_model(&model);
self.sync_active_thread_model_setting(app_server, model.clone(), /*effort*/ None)
.await;
self.sync_active_thread_service_tier_to_cached_session()
.await;
}
self.on_update_reasoning_effort(effort.clone());
self.sync_active_thread_reasoning_setting(app_server, effort.clone())
.await;
self.persist_default_model_selection(app_server.request_handle(), model, effort)
.await;
}
pub(super) async fn persist_default_model_selection(
&mut self,
request_handle: AppServerRequestHandle,
model: String,
effort: Option<ReasoningEffort>,
) {
self.app_event_tx
.send(crate::app_event::AppEvent::FollowTranscript);
match self
.persist_model_defaults(
request_handle,
crate::config_update::build_model_selection_edits(model.as_str(), effort.as_ref()),
"default model and reasoning effort",
)
.await
{
Ok(()) => {
let effort_label = effort
.as_ref()
.map(std::string::ToString::to_string)
.unwrap_or_else(|| "default".to_string());
tracing::info!("Selected model: {model}, Selected effort: {effort_label}");
let mut message = format!("Model changed to {model}");
if let Some(label) = Self::reasoning_label_for(&model, effort.as_ref()) {
message.push(' ');
message.push_str(&label);
}
self.chat_widget.add_info_message(message, /*hint*/ None);
}
Err(err) => {
let error = crate::config_update::format_config_error(&err);
tracing::error!(error = %error, "failed to persist model selection");
self.chat_widget
.add_error_message(format!("Failed to save default model: {error}"));
}
}
}
pub(super) async fn select_session_model(
&mut self,
app_server: &mut AppServerSession,
model: String,
effort: Option<ReasoningEffort>,
service_tier: Option<String>,
) {
if app_server.thread_params_mode() == ThreadParamsMode::Cloud {
let Some(thread_id) = self
.active_thread_id
.filter(|id| Some(*id) == self.chat_widget.thread_id())
else {
self.chat_widget.add_error_message(
"Open the Cloud conversation before choosing a model.".into(),
);
return;
};
let preset = self.model_catalog.models.iter().find(|preset| {
preset.model == model
&& effort.as_ref().is_none_or(|effort| {
*effort == preset.default_reasoning_effort
|| preset
.supported_reasoning_efforts
.iter()
.any(|preset| &preset.effort == effort)
})
&& preset.model_specialty.as_deref() != Some(MODEL_SPECIALTY_CYBER)
});
let Some(preset) = preset.filter(|_| {
service_tier.is_none() && model != crate::model_catalog::LUNA_RESERVE_MODEL
}) else {
self.chat_widget.add_error_message(
"Choose a supported Cloud model and effort at the current speed.".into(),
);
return;
};
let message =
session_model_confirmation(&model, effort.as_ref(), service_tier.as_deref());
match app_server.stage_cloud_model_selection(thread_id, preset, effort) {
Ok(dropped_tier) => {
self.chat_widget.sync_service_tier_commands();
self.chat_widget.add_info_message(message, /*hint*/ None);
if let Some(tier) = dropped_tier {
let tier = if tier == "priority" { "fast" } else { &tier };
self.chat_widget.add_warning_message(format!(
"{model} does not support {tier} speed. Cleared the pending speed change."
));
}
}
Err(()) => self.chat_widget.add_error_message(
"The Cloud account changed. Reopen the conversation before choosing a model."
.into(),
),
}
return;
}
// Changing effort or speed for the effective model must preserve permissions.
let model_changed = self.chat_widget.current_model() != model;
let params = if model_changed {
self.active_thread_model_setting_update_params(model.clone())
} else {
self.active_thread_reasoning_setting_update_params(effort.clone())
};
if let Some(mut params) = params {
if params.permissions.is_some() && self.reject_pending_permission_change() {
return;
}
params.effort = effort.clone();
params.collaboration_mode = Some(
self.chat_widget
.effective_collaboration_mode()
.with_updates(
Some(model.clone()),
Some(effort.clone()),
/*developer_instructions*/ None,
),
);
params.service_tier = match service_tier.as_ref() {
Some(tier) => Some(Some(tier.clone())),
None => service_tier_resolution::service_tier_update_for_core(
self.chat_widget.config_ref(),
&self.local_settings.notices,
&model,
&self.model_catalog.models,
),
};
if !self.send_model_settings_update(app_server, params).await {
if app_server.thread_settings_update_supported {
return;
}
if app_server.thread_params_mode().settings_owner() == ThreadSettingsOwner::Server {
self.chat_widget.add_error_message(
"This cloud conversation does not support changing its model from the TUI."
.into(),
);
return;
}
if service_tier
.as_deref()
.is_some_and(|tier| tier != SERVICE_TIER_DEFAULT_REQUEST_VALUE)
{
self.chat_widget.add_error_message(
"Model selection requires an app server with thread/settings/update support."
.into(),
);
return;
}
}
}
let in_plan_mode = self.chat_widget.effective_collaboration_mode().mode == ModeKind::Plan;
let ultra = effort == Some(ReasoningEffort::Ultra);
let clear_default_ultra = self
.chat_widget
.current_collaboration_mode()
.reasoning_effort()
== Some(ReasoningEffort::Ultra)
&& self.config.model_reasoning_effort != Some(ReasoningEffort::Ultra);
let clear_plan_ultra = self.chat_widget.config_ref().plan_mode_reasoning_effort
== Some(ReasoningEffort::Ultra)
&& self.config.plan_mode_reasoning_effort != Some(ReasoningEffort::Ultra);
if model_changed {
self.chat_widget.set_model(&model);
}
if !in_plan_mode
|| (self.chat_widget.current_collaboration_mode().model() == model
&& (ultra || clear_default_ultra))
{
self.chat_widget.set_reasoning_effort(effort.clone());
}
if in_plan_mode || ultra || clear_plan_ultra {
self.chat_widget
.set_plan_mode_reasoning_effort(effort.clone());
}
if let Some(service_tier) = service_tier.as_ref() {
self.chat_widget
.set_service_tier(Some(service_tier.clone()));
}
self.sync_active_thread_service_tier_to_cached_session()
.await;
let message = session_model_confirmation(&model, effort.as_ref(), service_tier.as_deref());
self.chat_widget.add_info_message(message, /*hint*/ None);
}
pub(super) async fn persist_model_defaults(
&mut self,
request_handle: AppServerRequestHandle,
edits: Vec<ConfigEdit>,
setting: &str,
) -> Result<()> {
let response = crate::config_update::write_config_batch(request_handle, edits).await?;
if response.status == WriteStatus::OkOverridden {
self.chat_widget.add_warning_message(format!(
"Saved {setting}, but a higher-priority configuration layer overrides the saved value."
));
}
Ok(())
}
}
fn session_model_confirmation(
model: &str,
effort: Option<&ReasoningEffort>,
service_tier: Option<&str>,
) -> String {
let mut message = format!("Model changed to {model}");
if let Some(label) = App::reasoning_label_for(model, effort) {
message.push(' ');
message.push_str(&label);
}
if let Some(service_tier) = service_tier {
message.push(' ');
message.push_str(if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE {
"standard"
} else if service_tier == ServiceTier::Fast.request_value() {
"fast"
} else {
service_tier
});
}
message.push_str(" for this session only");
message
}