Skip to content

armgit / codex

Public Imported from GitHub
0

Lightweight coding agent that runs in your terminal

Rust

Support inline model, reasoning, and speed selection in `/model` (#54378)

Felipe Coury0884c8047af8
diff --git a/codex-rs/tui/src/app/agents_overview.rs b/codex-rs/tui/src/app/agents_overview.rs
index 8701235d2f..fc6d46921a 100644
--- a/codex-rs/tui/src/app/agents_overview.rs
+++ b/codex-rs/tui/src/app/agents_overview.rs
@@ -947,7 +947,6 @@ impl App {
.as_ref()
.filter(|_| remote)
.map(AbsolutePathBuf::to_path_buf);
- let preserve_service_tier = remote || cwd.is_none();
let local_cwd = if remote {
self.config.cwd.to_path_buf()
} else {
@@ -969,9 +968,6 @@ impl App {
return None;
}
};
- if preserve_service_tier {
- config.service_tier = self.chat_widget.configured_service_tier();
- }
let trust_cwd = config.cwd.to_path_buf();
if self
.confirm_directory_trust(
diff --git a/codex-rs/tui/src/app/event_dispatch.rs b/codex-rs/tui/src/app/event_dispatch.rs
index b7f6a94f51..8efc33bdbc 100644
--- a/codex-rs/tui/src/app/event_dispatch.rs
+++ b/codex-rs/tui/src/app/event_dispatch.rs
@@ -2536,9 +2536,9 @@ impl App {
AppEvent::PersistDaybreakSelection { thread_id, enabled } => {
self.persist_daybreak_selection(app_server, thread_id, enabled).await;
}
- AppEvent::SelectSessionModel { model, effort } => {
+ AppEvent::SelectSessionModel { model, effort, service_tier } => {
self.app_event_tx.send(AppEvent::FollowTranscript);
- self.select_session_model(app_server, model, effort).await;
+ self.select_session_model(app_server, model, effort, service_tier).await;
}
AppEvent::CyberModelAutoReviewNotice => {
self.chat_widget.add_warning_message(
diff --git a/codex-rs/tui/src/app/model_defaults.rs b/codex-rs/tui/src/app/model_defaults.rs
index dca0c9da55..21373a1489 100644
--- a/codex-rs/tui/src/app/model_defaults.rs
+++ b/codex-rs/tui/src/app/model_defaults.rs
@@ -1,14 +1,17 @@
-//! Apply session model choices separately from saved model defaults.
+//! 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::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::ReasoningEffort;
use color_eyre::eyre::Result;
@@ -18,16 +21,50 @@ impl App {
app_server: &mut AppServerSession,
model: String,
effort: Option<ReasoningEffort>,
+ service_tier: Option<String>,
) {
let model_changed = self.chat_widget.current_model() != model
|| self.chat_widget.current_collaboration_mode().model() != model;
- if model_changed
- && self
- .active_thread_model_setting_update_params(model.clone())
- .is_some_and(|params| params.permissions.is_some())
- && self.reject_pending_permission_change()
- {
- return;
+ 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 service_tier.is_some() {
+ 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);
@@ -48,14 +85,9 @@ impl App {
self.chat_widget
.set_plan_mode_reasoning_effort(effort.clone());
}
- if model_changed {
- self.sync_active_thread_model_setting(app_server, model.clone(), effort.clone())
- .await;
- } else if let Some(mut params) =
- self.active_thread_reasoning_setting_update_params(effort.clone())
- {
- params.collaboration_mode = Some(self.chat_widget.effective_collaboration_mode());
- self.send_thread_settings_update(app_server, params).await;
+ 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;
@@ -64,6 +96,16 @@ impl App {
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");
self.chat_widget.add_info_message(message, /*hint*/ None);
}
diff --git a/codex-rs/tui/src/app/new_session.rs b/codex-rs/tui/src/app/new_session.rs
index ffc00b9754..73ce337a25 100644
--- a/codex-rs/tui/src/app/new_session.rs
+++ b/codex-rs/tui/src/app/new_session.rs
@@ -4,6 +4,7 @@
use super::*;
use codex_config::ConfigLayerSource;
+use codex_protocol::config_types::ServiceTier;
pub(crate) fn has_launch_setting(
config: &Config,
@@ -40,6 +41,15 @@ pub(super) fn overlay_new_session_defaults(
if !has_launch_setting(config, cli_kv_overrides, "model_reasoning_effort") {
config.model_reasoning_effort = defaults.model_reasoning_effort.clone();
}
+ if harness_overrides.service_tier.is_none()
+ && !has_launch_setting(config, cli_kv_overrides, "service_tier")
+ {
+ config.service_tier = defaults.service_tier.as_deref().map(|service_tier| {
+ ServiceTier::from_request_value(service_tier)
+ .map(|tier| tier.request_value().to_string())
+ .unwrap_or_else(|| service_tier.to_string())
+ });
+ }
if !has_launch_setting(config, cli_kv_overrides, "daybreak") {
config.daybreak_enabled = defaults
.additional
@@ -87,7 +97,6 @@ impl App {
);
}
self.apply_runtime_policy_overrides(&mut config, RuntimePolicyOverrideScope::ExplicitOnly)?;
- config.service_tier = self.chat_widget.configured_service_tier();
if let Some(defaults) = defaults.as_ref() {
overlay_new_session_defaults(
&mut config,
diff --git a/codex-rs/tui/src/app/tests.rs b/codex-rs/tui/src/app/tests.rs
index ea58190284..5d85e384e5 100644
--- a/codex-rs/tui/src/app/tests.rs
+++ b/codex-rs/tui/src/app/tests.rs
@@ -9729,6 +9729,7 @@ async fn changing_cyber_model_reasoning_preserves_selected_permissions() {
AppEvent::SelectSessionModel {
model: model_name.clone(),
effort: Some(effort.clone()),
+ service_tier: None,
},
)
.await
diff --git a/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs b/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
index 4bdfa6aa81..6b1551c61a 100644
--- a/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
+++ b/codex-rs/tui/src/app/tests/advanced_reasoning_tests.rs
@@ -1,5 +1,6 @@
use super::*;
use app_test_support::create_fake_rollout;
+use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use codex_utils_absolute_path::test_support::PathExt;
use pretty_assertions::assert_eq;
@@ -111,3 +112,50 @@ async fn switching_from_ultra_thread_restores_configured_plan_effort() {
Some(ReasoningEffortConfig::High)
);
}
+
+#[tokio::test]
+async fn switching_threads_restores_session_speed_for_the_next_turn() {
+ let (mut app, _events, mut ops) = make_test_app_with_channels().await;
+ app.config.service_tier = Some("flex".into());
+ app.chat_widget.set_service_tier(Some("flex".into()));
+ let standard_thread = ThreadId::new();
+ let flex_thread = ThreadId::new();
+ let session = |thread_id, service_tier: &str| ThreadSessionState {
+ model: "gpt-5.5".into(),
+ service_tier: Some(service_tier.into()),
+ ..test_thread_session(thread_id, test_path_buf("/tmp/project"))
+ };
+ let snapshot = |session| ThreadEventSnapshot {
+ delegated_turns: Vec::new(),
+ session: Some(session),
+ turns: Vec::new(),
+ events: Vec::new(),
+ active_reasoning_item: None,
+ input_state: None,
+ };
+
+ app.replay_thread_snapshot(
+ snapshot(session(standard_thread, SERVICE_TIER_DEFAULT_REQUEST_VALUE)),
+ /*resume_restored_queue*/ false,
+ );
+ app.replay_thread_snapshot(
+ snapshot(session(flex_thread, "flex")),
+ /*resume_restored_queue*/ false,
+ );
+ assert_eq!(
+ app.chat_widget.configured_service_tier().as_deref(),
+ Some("flex")
+ );
+ app.replay_thread_snapshot(
+ snapshot(session(standard_thread, SERVICE_TIER_DEFAULT_REQUEST_VALUE)),
+ /*resume_restored_queue*/ false,
+ );
+ app.chat_widget
+ .apply_external_edit("Check this task".into());
+ app.chat_widget.handle_key_event(KeyCode::Esc.into());
+ app.chat_widget.handle_key_event(KeyCode::Enter.into());
+
+ assert_matches!(next_user_turn_op(&mut ops), Op::UserTurn { service_tier, .. }
+ if service_tier == Some(Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.into())));
+ assert_eq!(app.config.service_tier.as_deref(), Some("flex"));
+}
diff --git a/codex-rs/tui/src/app/tests/background_task_defaults_tests.rs b/codex-rs/tui/src/app/tests/background_task_defaults_tests.rs
index 72e79e241a..dd727a879f 100644
--- a/codex-rs/tui/src/app/tests/background_task_defaults_tests.rs
+++ b/codex-rs/tui/src/app/tests/background_task_defaults_tests.rs
@@ -245,7 +245,7 @@ async fn command_center_new_reads_server_defaults_for_actual_destination() -> Re
std::fs::write(
server_home.path().join("config.toml"),
format!(
- "{}model_reasoning_effort = \"high\"\n{}",
+ "{}model_reasoning_effort = \"high\"\nservice_tier = \"fast\"\n{}",
if mode == "remote-null-fast" {
""
} else {
@@ -398,11 +398,7 @@ async fn command_center_new_reads_server_defaults_for_actual_destination() -> Re
serde_json::Value::Null
},
&serde_json::json!("high"),
- &serde_json::json!(if mode == "local" && explicit_cwd {
- "flex"
- } else {
- "priority"
- }),
+ &serde_json::json!(if explicit_cwd { "flex" } else { "priority" }),
),
"{mode} {expected_cwd}"
);
diff --git a/codex-rs/tui/src/app/tests/local_command_scroll_tests.rs b/codex-rs/tui/src/app/tests/local_command_scroll_tests.rs
index b4b41fbdd3..504a26b4fd 100644
--- a/codex-rs/tui/src/app/tests/local_command_scroll_tests.rs
+++ b/codex-rs/tui/src/app/tests/local_command_scroll_tests.rs
@@ -233,6 +233,7 @@ async fn settings_confirmations_reveal_their_history_output() -> Result<()> {
AppEvent::SelectSessionModel {
model: "gpt-5.5".into(),
effort: Some(ReasoningEffortConfig::High),
+ service_tier: None,
},
"Failed to update thread settings",
),
diff --git a/codex-rs/tui/src/app/tests/model_defaults_tests.rs b/codex-rs/tui/src/app/tests/model_defaults_tests.rs
index 12a0785507..5841fd45bf 100644
--- a/codex-rs/tui/src/app/tests/model_defaults_tests.rs
+++ b/codex-rs/tui/src/app/tests/model_defaults_tests.rs
@@ -2,6 +2,7 @@ use super::*;
use crate::collaboration_modes;
use codex_app_server_client::AppServerClient;
use codex_config::LoaderOverrides;
+use crossterm::event::KeyCode;
use pretty_assertions::assert_eq;
#[tokio::test]
@@ -32,28 +33,59 @@ async fn session_model_selection_preserves_defaults_and_updates_active_thread()
ReasoningEffortConfig::Max,
] {
while events.try_recv().is_ok() {}
- Box::pin(app.handle_event(
- &mut tui,
- &mut server,
- AppEvent::SelectSessionModel {
- model: "gpt-5.6-terra".into(),
- effort: Some(effort.clone()),
- },
- ))
- .await?;
+ let command = match effort {
+ ReasoningEffortConfig::High => {
+ "/model gpt-5.6-terra --reasoning high --speed=standard".into()
+ }
+ ReasoningEffortConfig::Ultra => "/model --reasoning=ultra".into(),
+ ReasoningEffortConfig::Max => "/model --reasoning max".into(),
+ _ => unreachable!(),
+ };
+ app.chat_widget.apply_external_edit(command);
+ app.chat_widget.handle_key_event(KeyCode::Esc.into());
+ app.chat_widget.handle_key_event(KeyCode::Enter.into());
+ let mut messages = Vec::new();
+ while let Ok(event) = events.try_recv() {
+ if let AppEvent::InsertHistoryCell(cell) = &event {
+ messages.push(lines_to_single_string(&cell.transcript_lines(/*width*/ 80)));
+ }
+ Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
+ }
let settings = next_thread_settings_updated(&mut server, thread_id).await;
assert_eq!(
(
settings.thread_settings.model.as_str(),
- settings.thread_settings.effort.clone()
+ settings.thread_settings.effort.clone(),
+ settings.thread_settings.service_tier.as_deref(),
),
- ("gpt-5.6-terra", Some(effort.clone()))
+ ("gpt-5.6-terra", Some(effort.clone()), Some("default"))
);
if mode == ModeKind::Default && effort == ReasoningEffortConfig::High {
- insta::assert_snapshot!(
- "session_only_model_confirmation",
- next_history_message(&mut events)
- );
+ for command in [
+ "/model gpt-5.6-terra fast",
+ "/model gpt-5.6-terra --speeed=fast",
+ "/model gpt-5.6-terra --reasoning=invalid",
+ "/model --speed",
+ "/model --reasoning=",
+ "/model --reasoning --speed=standard",
+ "/model --speed=fast --speed standard",
+ ] {
+ app.chat_widget.apply_external_edit(command.into());
+ app.chat_widget.handle_key_event(KeyCode::Esc.into());
+ app.chat_widget.handle_key_event(KeyCode::Enter.into());
+ }
+ while let Ok(event) = events.try_recv() {
+ assert!(!matches!(
+ event,
+ AppEvent::SelectSessionModel { .. }
+ | AppEvent::AstraSelectedFromModelPicker { .. }
+ ));
+ if let AppEvent::InsertHistoryCell(cell) = &event {
+ messages.push(lines_to_single_string(&cell.transcript_lines(/*width*/ 80)));
+ }
+ Box::pin(app.handle_event(&mut tui, &mut server, event)).await?;
+ }
+ insta::assert_snapshot!("session_only_model_confirmation", messages.join("\n"));
}
app.enqueue_thread_notification(
thread_id,
diff --git a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__model_defaults__session_only_model_confirmation.snap b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__model_defaults__session_only_model_confirmation.snap
index 297c047e9c..e1960ed79f 100644
--- a/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__model_defaults__session_only_model_confirmation.snap
+++ b/codex-rs/tui/src/app/tests/snapshots/codex_tui__app__tests__model_defaults__session_only_model_confirmation.snap
@@ -1,5 +1,12 @@
---
source: tui/src/app/tests/model_defaults_tests.rs
-expression: next_history_message(&mut events)
+expression: "messages.join(\"\\n\")"
---
-• Model changed to gpt-5.6-terra high for this session only
+• Model changed to gpt-5.6-terra high standard for this session only
+■ Unexpected argument 'fast'. Use '--reasoning=<level>' or '--speed=<tier>'.
+■ Unknown model setting '--speeed'. Expected '--reasoning=<level>' or '--speed=<tier>'.
+■ Reasoning level 'invalid' is unavailable for gpt-5.6-terra. Available: low, medium, high, xhigh, max, ultra.
+■ Model setting '--speed' requires a value.
+■ Model setting '--reasoning' requires a value.
+■ Model setting '--reasoning' requires a value.
+■ Model setting '--speed' was provided more than once.
diff --git a/codex-rs/tui/src/app/thread_settings.rs b/codex-rs/tui/src/app/thread_settings.rs
index 8aee623649..6ad9d672b5 100644
--- a/codex-rs/tui/src/app/thread_settings.rs
+++ b/codex-rs/tui/src/app/thread_settings.rs
@@ -29,6 +29,14 @@ impl App {
return;
};
params.effort = effort;
+ self.send_model_settings_update(app_server, params).await;
+ }
+
+ pub(super) async fn send_model_settings_update(
+ &mut self,
+ app_server: &mut AppServerSession,
+ params: ThreadSettingsUpdateParams,
+ ) -> bool {
let defaulted_to_auto_review = params.approvals_reviewer
== Some(AppServerApprovalsReviewer::AutoReview)
&& (self.chat_widget.config_ref().approvals_reviewer != ApprovalsReviewer::AutoReview
@@ -61,6 +69,7 @@ impl App {
if defaulted_to_auto_review && settings_updated {
self.app_event_tx.send(AppEvent::CyberModelAutoReviewNotice);
}
+ settings_updated
}
pub(super) fn active_thread_model_setting_update_params(
diff --git a/codex-rs/tui/src/app/working_directory.rs b/codex-rs/tui/src/app/working_directory.rs
index db28e72c92..b15fb9af8a 100644
--- a/codex-rs/tui/src/app/working_directory.rs
+++ b/codex-rs/tui/src/app/working_directory.rs
@@ -395,7 +395,9 @@ impl App {
Ok(keymap) => keymap,
Err(error) => return self.chat_widget.add_error_message(error),
};
- config.service_tier = self.chat_widget.configured_service_tier();
+ if !is_new_worktree {
+ config.service_tier = self.chat_widget.configured_service_tier();
+ }
if is_new_worktree {
apply_managed_new_thread_defaults(
&mut config,
diff --git a/codex-rs/tui/src/app_event.rs b/codex-rs/tui/src/app_event.rs
index a20193149e..613178d0c1 100644
--- a/codex-rs/tui/src/app_event.rs
+++ b/codex-rs/tui/src/app_event.rs
@@ -1231,7 +1231,7 @@ pub(crate) enum AppEvent {
/// Update the current model slug in the running app and widget.
UpdateModel(String),
- /// Apply a final Astra picker action and offer the flourish only if it changed the model on
+ /// Apply an explicit Astra selection and offer the flourish only if it changed the model on
/// its original task. Automatic model updates do not use this event.
AstraSelectedFromModelPicker {
thread_id: ThreadId,
@@ -1269,10 +1269,11 @@ pub(crate) enum AppEvent {
effort: Option<ReasoningEffort>,
},
- /// Apply a model and effort only to the active session, preserving saved defaults.
+ /// Apply a model, effort, and optional speed only to the active session, preserving saved defaults.
SelectSessionModel {
model: String,
effort: Option<ReasoningEffort>,
+ service_tier: Option<String>,
},
/// Show the cyber auto-review notice after the model selection confirmation.
diff --git a/codex-rs/tui/src/app_server_session.rs b/codex-rs/tui/src/app_server_session.rs
index ba449c46f4..67e06d5041 100644
--- a/codex-rs/tui/src/app_server_session.rs
+++ b/codex-rs/tui/src/app_server_session.rs
@@ -333,7 +333,7 @@ pub(crate) struct AppServerSession {
/// Explicit CLI provider selection, distinct from resolved configuration defaults.
pub(crate) model_provider_override: Option<String>,
history_support: ThreadHistorySupport,
- thread_settings_update_supported: bool,
+ pub(crate) thread_settings_update_supported: bool,
default_model: Option<String>,
available_models: Vec<ModelPreset>,
daybreak_api_key_compat: Arc<tokio::sync::Semaphore>,
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs b/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs
index 7b3c6e7342..0bd9c4d1cb 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer/slash_input.rs
@@ -751,13 +751,13 @@ mod tests {
#[test]
fn slash_completion_does_not_preserve_existing_draft_tail_for_other_commands() {
let mut composer = composer_with_draft_tail(
- "/mo",
+ "/sta",
"preserve this draft only for opted-in slash commands",
);
assert_eq!(press(&mut composer, KeyCode::Tab), InputResult::None);
- assert_eq!(composer.draft.textarea.text(), "/model ");
- assert_eq!(composer.draft.textarea.cursor(), "/model ".len());
+ assert_eq!(composer.draft.textarea.text(), "/status ");
+ assert_eq!(composer.draft.textarea.cursor(), "/status ".len());
}
#[test]
diff --git a/codex-rs/tui/src/bottom_pane/chat_composer/sparkle_tests.rs b/codex-rs/tui/src/bottom_pane/chat_composer/sparkle_tests.rs
index 4cce5d8c7d..b39da3eda7 100644
--- a/codex-rs/tui/src/bottom_pane/chat_composer/sparkle_tests.rs
+++ b/codex-rs/tui/src/bottom_pane/chat_composer/sparkle_tests.rs
@@ -831,7 +831,7 @@ fn arbitrary_commands_preserve_a_never_used_fresh_opportunity() {
pane.select_sparkle_model("gpt-6-astra", &enabled());
assert!(!dots(&draw(&pane.composer, /*width*/ 80, now).0).is_empty());
}
- for input in ["hello", "/model extra", "/other", "漢", "/tmp/file"] {
+ for input in ["hello", "/status extra", "/other", "漢", "/tmp/file"] {
let mut pane = pane();
pane.mark_fresh_task_for_sparkle("gpt-5.5", &enabled());
type_text(&mut pane, input);
diff --git a/codex-rs/tui/src/chatwidget.rs b/codex-rs/tui/src/chatwidget.rs
index fccd6e2c20..ab13bba827 100644
--- a/codex-rs/tui/src/chatwidget.rs
+++ b/codex-rs/tui/src/chatwidget.rs
@@ -322,6 +322,7 @@ use self::plugins::PluginListFetchState;
use self::plugins::PluginsCacheState;
mod plan_implementation;
use self::plan_implementation::PLAN_IMPLEMENTATION_TITLE;
+mod model_command;
mod model_popup_state;
mod model_popups;
mod notifications;
diff --git a/codex-rs/tui/src/chatwidget/model_command.rs b/codex-rs/tui/src/chatwidget/model_command.rs
new file mode 100644
index 0000000000..9fa29504c0
--- /dev/null
+++ b/codex-rs/tui/src/chatwidget/model_command.rs
@@ -0,0 +1,210 @@
+//! Validate inline model choices before applying them through session-only model selection.
+
+use super::ChatWidget;
+use super::session_model_selection::AstraModelPickerAction;
+use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
+use codex_protocol::openai_models::ModelPreset;
+use codex_protocol::openai_models::ReasoningEffort;
+
+#[derive(Default)]
+struct ModelCommandArgs<'a> {
+ model: Option<&'a str>,
+ effort: Option<&'a str>,
+ speed: Option<&'a str>,
+}
+
+struct ModelCommand {
+ model: String,
+ effort: ReasoningEffort,
+ service_tier: Option<String>,
+}
+
+fn parse_model_command_args(args: &str) -> Result<ModelCommandArgs<'_>, String> {
+ let mut parsed = ModelCommandArgs::default();
+ let mut words = args.split_whitespace().peekable();
+ while let Some(word) = words.next() {
+ let (setting, inline_value) = word
+ .split_once('=')
+ .map_or((word, None), |(setting, value)| (setting, Some(value)));
+ match setting {
+ "--reasoning" => {
+ set_model_setting(&mut parsed.effort, setting, inline_value, &mut words)?;
+ }
+ "--speed" => {
+ set_model_setting(&mut parsed.speed, setting, inline_value, &mut words)?;
+ }
+ _ if word.starts_with("--") => {
+ return Err(format!(
+ "Unknown model setting '{setting}'. Expected '--reasoning=<level>' or '--speed=<tier>'."
+ ));
+ }
+ _ if parsed.model.replace(word).is_some() => {
+ return Err(format!(
+ "Unexpected argument '{word}'. Use '--reasoning=<level>' or '--speed=<tier>'."
+ ));
+ }
+ _ => {}
+ }
+ }
+ Ok(parsed)
+}
+
+fn set_model_setting<'a>(
+ target: &mut Option<&'a str>,
+ setting: &str,
+ inline_value: Option<&'a str>,
+ words: &mut std::iter::Peekable<impl Iterator<Item = &'a str>>,
+) -> Result<(), String> {
+ let value = match inline_value {
+ Some("") => None,
+ Some(value) => Some(value),
+ None => words.next_if(|word| !word.starts_with("--")),
+ }
+ .ok_or_else(|| format!("Model setting '{setting}' requires a value."))?;
+ if target.replace(value).is_some() {
+ return Err(format!(
+ "Model setting '{setting}' was provided more than once."
+ ));
+ }
+ Ok(())
+}
+
+fn resolve_reasoning_effort(
+ chat: &ChatWidget,
+ args: &ModelCommandArgs<'_>,
+ model: &ModelPreset,
+) -> Result<ReasoningEffort, String> {
+ let Some(effort) = args.effort else {
+ return Ok(if args.model.is_none() {
+ chat.current_reasoning_effort()
+ .unwrap_or_else(|| model.default_reasoning_effort.clone())
+ } else {
+ model.default_reasoning_effort.clone()
+ });
+ };
+ let supported = if model.supported_reasoning_efforts.is_empty() {
+ (model.default_reasoning_effort.as_str() == effort)
+ .then_some(&model.default_reasoning_effort)
+ } else {
+ model
+ .supported_reasoning_efforts
+ .iter()
+ .find(|option| option.effort.as_str() == effort)
+ .map(|option| &option.effort)
+ };
+ supported.cloned().ok_or_else(|| {
+ let available = if model.supported_reasoning_efforts.is_empty() {
+ model.default_reasoning_effort.to_string()
+ } else {
+ model
+ .supported_reasoning_efforts
+ .iter()
+ .map(|option| option.effort.to_string())
+ .collect::<Vec<_>>()
+ .join(", ")
+ };
+ format!(
+ "Reasoning level '{effort}' is unavailable for {}. Available: {available}.",
+ model.model
+ )
+ })
+}
+
+fn resolve_service_tier(
+ chat: &ChatWidget,
+ speed: Option<&str>,
+ model: &ModelPreset,
+) -> Result<Option<String>, String> {
+ let Some(speed) = speed else {
+ return Ok(None);
+ };
+ if speed == "standard" {
+ return Ok(Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string()));
+ }
+ if speed == "flex" {
+ return Ok(Some("flex".to_string()));
+ }
+ let tier = model
+ .service_tiers
+ .iter()
+ .find(|tier| tier.id == speed || tier.name.eq_ignore_ascii_case(speed))
+ .filter(|tier| chat.config.features.service_tier_enabled(&tier.id));
+ tier.map(|tier| Some(tier.id.clone())).ok_or_else(|| {
+ let available = std::iter::once("standard".to_string())
+ .chain(std::iter::once("flex".to_string()))
+ .chain(
+ model
+ .service_tiers
+ .iter()
+ .filter(|tier| chat.config.features.service_tier_enabled(&tier.id))
+ .map(|tier| tier.id.clone()),
+ )
+ .collect::<Vec<_>>()
+ .join(", ");
+ format!(
+ "Speed '{speed}' is unavailable for {}. Available: {available}.",
+ model.model
+ )
+ })
+}
+
+fn resolve_model_command(chat: &ChatWidget, args: &str) -> Result<ModelCommand, String> {
+ let args = parse_model_command_args(args)?;
+ if chat.thread_id().is_none() {
+ return Err("Session is still starting; try /model again in a moment.".into());
+ }
+ if chat.restrict_model_picker_to_luna_reserve() {
+ return Err(
+ "Model arguments are unavailable while using Reserve. Use /model to adjust effort."
+ .into(),
+ );
+ }
+ let model_name = args
+ .model
+ .map(str::to_owned)
+ .unwrap_or_else(|| chat.current_model().to_owned());
+ let Some(model) =
+ chat.model_catalog.models.iter().find(|model| {
+ model.model == model_name && (args.model.is_none() || model.show_in_picker)
+ })
+ else {
+ return Err(format!(
+ "Model '{model_name}' is unavailable. Use /model to see available models."
+ ));
+ };
+ Ok(ModelCommand {
+ model: model.model.clone(),
+ effort: resolve_reasoning_effort(chat, &args, model)?,
+ service_tier: resolve_service_tier(chat, args.speed, model)?,
+ })
+}
+
+impl ChatWidget {
+ pub(super) fn handle_model_command_args(&mut self, args: &str) {
+ let command = match resolve_model_command(self, args) {
+ Ok(command) => command,
+ Err(error) => {
+ self.add_error_message(error);
+ return;
+ }
+ };
+ let ModelCommand {
+ model,
+ effort,
+ service_tier,
+ } = command;
+ let warning = self.ultra_reasoning_concurrency_warning(&effort);
+ let thread_id = self.sparkle_thread_for_picker_action(&model);
+ self.set_queue_autosend_suppressed(/*suppressed*/ true);
+ self.app_event_tx.send(
+ AstraModelPickerAction::SelectSessionModel {
+ effort: Some(effort),
+ service_tier,
+ }
+ .into_picker_event(thread_id, model),
+ );
+ if let Some(warning) = warning {
+ self.add_warning_message(warning);
+ }
+ }
+}
diff --git a/codex-rs/tui/src/chatwidget/session_flow.rs b/codex-rs/tui/src/chatwidget/session_flow.rs
index f34f76ebed..15f6a354cd 100644
--- a/codex-rs/tui/src/chatwidget/session_flow.rs
+++ b/codex-rs/tui/src/chatwidget/session_flow.rs
@@ -125,6 +125,7 @@ impl ChatWidget {
self.config
.permissions
.set_workspace_roots(runtime_workspace_roots);
+ self.config.service_tier = session.service_tier.clone();
self.effective_service_tier = session.service_tier.clone();
if let Err(err) = self
.config
diff --git a/codex-rs/tui/src/chatwidget/session_model_selection.rs b/codex-rs/tui/src/chatwidget/session_model_selection.rs
index ac9b5c8e66..3e9e3db760 100644
--- a/codex-rs/tui/src/chatwidget/session_model_selection.rs
+++ b/codex-rs/tui/src/chatwidget/session_model_selection.rs
@@ -1,4 +1,4 @@
-//! Session-only model picker actions leave durable defaults untouched. Astra picker actions retain
+//! Session-only model selections leave durable defaults untouched. Explicit Astra selections retain
//! their originating task and are checked against its effective model when the app applies them.
use super::*;
@@ -15,6 +15,7 @@ pub(crate) enum AstraModelPickerAction {
},
SelectSessionModel {
effort: Option<ReasoningEffortConfig>,
+ service_tier: Option<String>,
},
}
@@ -36,7 +37,14 @@ impl AstraModelPickerAction {
Self::ApplyAdvancedReasoning { effort } => {
AppEvent::ApplyAdvancedReasoning { model, effort }
}
- Self::SelectSessionModel { effort } => AppEvent::SelectSessionModel { model, effort },
+ Self::SelectSessionModel {
+ effort,
+ service_tier,
+ } => AppEvent::SelectSessionModel {
+ model,
+ effort,
+ service_tier,
+ },
}
}
}
@@ -77,6 +85,7 @@ impl ChatWidget {
tx.send(
AstraModelPickerAction::SelectSessionModel {
effort: effort.clone(),
+ service_tier: None,
}
.into_picker_event(sparkle_thread, model.clone()),
);
diff --git a/codex-rs/tui/src/chatwidget/slash_dispatch.rs b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
index 79601b9a28..1664e493eb 100644
--- a/codex-rs/tui/src/chatwidget/slash_dispatch.rs
+++ b/codex-rs/tui/src/chatwidget/slash_dispatch.rs
@@ -804,6 +804,10 @@ impl ChatWidget {
} = prepared;
let trimmed = args.trim();
match cmd {
+ SlashCommand::Model if !trimmed.is_empty() => {
+ self.handle_model_command_args(trimmed);
+ self.app_event_tx.send(AppEvent::SettingsSelectionClosed);
+ }
SlashCommand::Export if trimmed.is_empty() => self.show_transcript_export_popup(),
SlashCommand::Export => {
self.set_queue_autosend_suppressed(/*suppressed*/ true);
diff --git a/codex-rs/tui/src/chatwidget/tests/session_model_selection_tests.rs b/codex-rs/tui/src/chatwidget/tests/session_model_selection_tests.rs
index 23faa7150a..9db819d0ff 100644
--- a/codex-rs/tui/src/chatwidget/tests/session_model_selection_tests.rs
+++ b/codex-rs/tui/src/chatwidget/tests/session_model_selection_tests.rs
@@ -49,7 +49,7 @@ async fn session_model_selection_accepts_final_choices_without_saving() {
while rx.try_recv().is_ok() {}
chat.handle_key_event(KeyEvent::from(KeyCode::Char('s')));
let selected = rx.try_recv().expect("session-only selection");
- assert_matches!(selected, AppEvent::SelectSessionModel { model, effort: selected_effort }
+ assert_matches!(selected, AppEvent::SelectSessionModel { model, effort: selected_effort, service_tier: None }
if model == expected_model && selected_effort.as_ref() == Some(&effort));
assert!(chat.bottom_pane.no_modal_or_popup_active(), "{picker}");
assert!(
@@ -100,7 +100,7 @@ async fn session_model_selection_notifies_the_original_task_after_each_final_ast
assert_matches!(events.try_recv(), Ok(AppEvent::AstraSelectedFromModelPicker {
thread_id: selected_thread,
model,
- action: AstraModelPickerAction::SelectSessionModel { effort: selected_effort },
+ action: AstraModelPickerAction::SelectSessionModel { effort: selected_effort, service_tier: None },
}) if selected_thread == thread_id && model == "gpt-6-astra" && selected_effort == Some(effort));
assert!(
std::iter::from_fn(|| events.try_recv().ok()).all(|event| matches!(
@@ -112,6 +112,33 @@ async fn session_model_selection_notifies_the_original_task_after_each_final_ast
}
}
+#[tokio::test]
+async fn model_settings_only_command_accepts_the_current_hidden_model() {
+ let (mut chat, mut events, _ops) =
+ make_chatwidget_manual(/*model_override*/ Some("gpt-5.5")).await;
+ chat.thread_id = Some(ThreadId::new());
+ let mut preset = get_available_model(&chat, "gpt-5.5");
+ preset.show_in_picker = false;
+ chat.model_catalog = std::sync::Arc::new(ModelCatalog::new(vec![preset]));
+
+ chat.handle_model_command_args("--reasoning high --speed standard");
+
+ assert_matches!(events.try_recv(), Ok(AppEvent::SelectSessionModel {
+ model,
+ effort: Some(ReasoningEffortConfig::High),
+ service_tier: Some(service_tier),
+ }) if model == "gpt-5.5" && service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE);
+
+ while events.try_recv().is_ok() {}
+ chat.handle_model_command_args("gpt-5.5 --reasoning=high");
+ assert!(
+ std::iter::from_fn(|| events.try_recv().ok()).all(|event| !matches!(
+ event,
+ AppEvent::SelectSessionModel { .. } | AppEvent::AstraSelectedFromModelPicker { .. }
+ ))
+ );
+}
+
#[tokio::test]
async fn session_model_selection_hides_conflicting_shortcut() {
let (mut chat, mut rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.5")).await;
diff --git a/codex-rs/tui/src/slash_command.rs b/codex-rs/tui/src/slash_command.rs
index afb372bb7b..65d7965236 100644
--- a/codex-rs/tui/src/slash_command.rs
+++ b/codex-rs/tui/src/slash_command.rs
@@ -171,6 +171,7 @@ impl SlashCommand {
matches!(
self,
SlashCommand::Review
+ | SlashCommand::Model
| SlashCommand::Rename
| SlashCommand::New
| SlashCommand::Clear