Honor client-resolved service tier defaults (#23537)

## Why

Model catalog responses can now advertise a nullable
`default_service_tier` for each model. Codex needs to preserve three
distinct states all the way from config/app-server inputs to inference:

- no explicit service tier, so the client may apply the current model
catalog default when FastMode is enabled
- explicit `default`, meaning the user intentionally wants standard
routing
- explicit catalog tier ids such as `priority`, `flex`, or future tiers

Keeping those states distinct prevents the UI from showing one tier
while core sends another, especially after model switches or app-server
`thread/start` / `turn/start` updates.

## What Changed

- Plumbed `default_service_tier` through model catalog protocol types,
app-server model responses, generated schemas, model cache fixtures, and
provider/model-manager conversions.
- Added the request-only `default` service tier sentinel and normalized
legacy config spelling so `fast` in `config.toml` still materializes as
the runtime/request id `priority`.
- Moved catalog default resolution to the TUI/client side, including
recomputing the effective service tier when model/FastMode-dependent
surfaces change.
- Updated app-server thread lifecycle config construction so
`serviceTier: null` preserves explicit standard-routing intent by
mapping to `default` instead of internal `None`.
- Kept core responsible for validating explicit tiers against the
current model and stripping `default` before `/v1/responses`, without
applying catalog defaults itself.

## Validation

- `CARGO_INCREMENTAL=0 cargo build -p codex-cli`
- `CARGO_INCREMENTAL=0 cargo test -p codex-app-server model_list`
- `cargo test -p codex-tui service_tier`
- `cargo test -p codex-protocol service_tier_for_request`
- `cargo test -p codex-core get_service_tier`
- `RUST_MIN_STACK=8388608 CARGO_INCREMENTAL=0 cargo test -p codex-core
service_tier`
This commit is contained in:
Shijie Rao authored and GitHub committed 2026-05-20 15:57:50 -07:00
1 parent 0e9d222178
commit 370b13afc9
54 files changed
+682 -192

No files matched your search

+2 -3
View File
@@ -767,6 +767,8 @@ impl App {
self.chat_widget.set_model(&model);
self.sync_active_thread_model_setting(app_server, model)
.await;
self.sync_active_thread_service_tier_to_cached_session()
.await;
}
AppEvent::UpdatePersonality(personality) => {
self.on_update_personality(personality);
@@ -1327,9 +1329,6 @@ impl App {
profile,
service_tier.as_deref(),
);
if service_tier.is_none() {
self.config.notices.fast_default_opt_out = Some(true);
}
match crate::config_update::write_config_batch(app_server.request_handle(), edits)
.await
{
@@ -656,7 +656,6 @@ impl App {
pub(super) fn fresh_session_config(&self) -> Config {
let mut config = self.config.clone();
config.service_tier = self.chat_widget.configured_service_tier();
config.notices.fast_default_opt_out = self.chat_widget.fast_default_opt_out();
config
}
pub(super) async fn resume_target_session(
-1
View File
@@ -464,7 +464,6 @@ impl App {
}
fork_config.model_reasoning_effort = self.chat_widget.current_reasoning_effort();
fork_config.service_tier = self.chat_widget.configured_service_tier();
fork_config.notices.fast_default_opt_out = self.chat_widget.fast_default_opt_out();
fork_config.ephemeral = true;
fork_config.developer_instructions = Some(Self::side_developer_instructions(
fork_config.developer_instructions.as_deref(),
+45 -8
View File
@@ -6,6 +6,7 @@
use crate::bottom_pane::FeedbackAudience;
use crate::legacy_core::config::Config;
use crate::permission_compat::legacy_compatible_permission_profile;
use crate::service_tier_resolution;
use crate::session_state::MessageHistoryMetadata;
use crate::session_state::ThreadSessionState;
use crate::status::StatusAccountDisplay;
@@ -107,6 +108,7 @@ use codex_app_server_protocol::UserInput;
use codex_otel::TelemetryAuthMode;
use codex_protocol::ThreadId;
use codex_protocol::approvals::GuardianAssessmentEvent;
use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use codex_protocol::models::ActivePermissionProfile;
use codex_protocol::models::PermissionProfile;
use codex_protocol::models::ResponseItem;
@@ -164,6 +166,8 @@ pub(crate) struct AppServerSession {
remote_cwd_override: Option<PathBuf>,
thread_params_mode: ThreadParamsMode,
thread_settings_update_supported: bool,
default_model: Option<String>,
available_models: Vec<ModelPreset>,
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
@@ -205,6 +209,8 @@ impl AppServerSession {
remote_cwd_override: None,
thread_params_mode,
thread_settings_update_supported: true,
default_model: None,
available_models: Vec::new(),
}
}
@@ -254,6 +260,8 @@ impl AppServerSession {
})
.or_else(|| available_models.first().map(|model| model.model.clone()))
.wrap_err("model/list returned no models for TUI bootstrap")?;
self.default_model = Some(default_model.clone());
self.available_models = available_models.clone();
let (
account_email,
@@ -365,12 +373,13 @@ impl AppServerSession {
session_start_source: Option<ThreadStartSource>,
) -> Result<AppServerStartedThread> {
let request_id = self.next_request_id();
let session_config = self.session_config_with_effective_service_tier(config);
let response: ThreadStartResponse = self
.client
.request_typed(ClientRequest::ThreadStart {
request_id,
params: thread_start_params_from_config(
config,
&session_config,
self.thread_params_mode(),
self.remote_cwd_override.as_deref(),
session_start_source,
@@ -389,12 +398,13 @@ impl AppServerSession {
thread_id: ThreadId,
) -> Result<AppServerStartedThread> {
let request_id = self.next_request_id();
let session_config = self.session_config_with_effective_service_tier(&config);
let response: ThreadResumeResponse = self
.client
.request_typed(ClientRequest::ThreadResume {
request_id,
params: thread_resume_params_from_config(
config.clone(),
session_config,
thread_id,
self.thread_params_mode(),
self.remote_cwd_override.as_deref(),
@@ -420,12 +430,13 @@ impl AppServerSession {
thread_id: ThreadId,
) -> Result<AppServerStartedThread> {
let request_id = self.next_request_id();
let session_config = self.session_config_with_effective_service_tier(&config);
let response: ThreadForkResponse = self
.client
.request_typed(ClientRequest::ThreadFork {
request_id,
params: thread_fork_params_from_config(
config.clone(),
session_config,
thread_id,
self.thread_params_mode(),
self.remote_cwd_override.as_deref(),
@@ -448,6 +459,32 @@ impl AppServerSession {
self.thread_params_mode
}
fn session_config_with_effective_service_tier(&self, config: &Config) -> Config {
let Some(model) = config.model.as_deref().or(self.default_model.as_deref()) else {
return config.clone();
};
let mut session_config = config.clone();
match service_tier_resolution::service_tier_update_for_core(
config,
model,
&self.available_models,
) {
Some(Some(service_tier)) => {
session_config.service_tier = Some(service_tier);
session_config.notices.fast_default_opt_out = None;
}
Some(None) => {
session_config.service_tier = Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string());
session_config.notices.fast_default_opt_out = None;
}
None => {
session_config.service_tier = None;
session_config.notices.fast_default_opt_out = None;
}
}
session_config
}
async fn fork_parent_title_from_app_server(
&mut self,
forked_from_id: Option<&str>,
@@ -1159,6 +1196,7 @@ fn model_preset_from_api_model(model: ApiModel) -> ModelPreset {
description: service_tier.description,
})
.collect(),
default_service_tier: model.default_service_tier,
is_default: model.is_default,
upgrade,
show_in_picker: !model.hidden,
@@ -1219,11 +1257,10 @@ fn config_request_overrides_from_config(
}
fn service_tier_override_from_config(config: &Config) -> Option<Option<String>> {
config
.service_tier
.clone()
.map(Some)
.or_else(|| (config.notices.fast_default_opt_out == Some(true)).then_some(None))
config.service_tier.clone().map(Some).or_else(|| {
(config.notices.fast_default_opt_out == Some(true))
.then(|| Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string()))
})
}
fn sandbox_mode_from_permission_profile(
+5 -1
View File
@@ -64,7 +64,11 @@ impl ChatWidget {
let active_cell = Some(Self::placeholder_session_header_cell(&config));
let current_cwd = Some(config.cwd.to_path_buf());
let effective_service_tier = config.service_tier.clone();
let effective_service_tier = crate::service_tier_resolution::effective_service_tier(
&config,
&header_model,
&model_catalog.try_list_models().unwrap_or_default(),
);
let current_terminal_info = terminal_info();
let runtime_keymap = RuntimeKeymap::from_config(&config.tui_keymap).ok();
let default_keymap = RuntimeKeymap::defaults();
@@ -331,11 +331,7 @@ impl ChatWidget {
.personality
.filter(|_| self.config.features.enabled(Feature::Personality))
.filter(|_| self.current_model_supports_personality());
let service_tier = match self.config.service_tier.clone() {
Some(service_tier) => Some(Some(service_tier)),
None if self.config.notices.fast_default_opt_out == Some(true) => Some(None),
None => None,
};
let service_tier = self.service_tier_update_for_core();
let active_permission_profile = self.config.permissions.active_permission_profile();
let op = AppCommand::user_turn(
items,
+20 -9
View File
@@ -4,14 +4,16 @@ use super::ChatWidget;
use crate::app_command::AppCommand;
use crate::app_event::AppEvent;
use crate::bottom_pane::slash_commands::ServiceTierCommand;
use crate::service_tier_resolution;
use codex_features::Feature;
use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use codex_protocol::config_types::ServiceTier;
use codex_protocol::openai_models::SPEED_TIER_FAST;
impl ChatWidget {
pub(crate) fn set_service_tier(&mut self, service_tier: Option<String>) {
self.config.service_tier = service_tier.clone();
self.effective_service_tier = service_tier;
self.config.service_tier = service_tier;
self.refresh_effective_service_tier();
self.refresh_model_dependent_surfaces();
}
@@ -23,8 +25,12 @@ impl ChatWidget {
self.config.service_tier.clone()
}
pub(crate) fn fast_default_opt_out(&self) -> Option<bool> {
self.config.notices.fast_default_opt_out
pub(crate) fn service_tier_update_for_core(&self) -> Option<Option<String>> {
service_tier_resolution::service_tier_update_for_core(
&self.config,
self.current_model(),
&self.model_catalog.try_list_models().unwrap_or_default(),
)
}
pub(crate) fn should_show_fast_status(&self, model: &str, service_tier: Option<&str>) -> bool {
@@ -50,7 +56,7 @@ impl ChatWidget {
return;
};
let next_tier = if self.current_service_tier() == Some(fast_tier.id.as_str()) {
None
Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string())
} else {
Some(fast_tier.id)
};
@@ -59,7 +65,7 @@ impl ChatWidget {
pub(crate) fn toggle_service_tier_from_ui(&mut self, command: ServiceTierCommand) {
let next_tier = if self.current_service_tier() == Some(command.id.as_str()) {
None
Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string())
} else {
Some(command.id)
};
@@ -98,9 +104,6 @@ impl ChatWidget {
}
fn set_service_tier_selection(&mut self, service_tier: Option<String>) {
if service_tier.is_none() {
self.config.notices.fast_default_opt_out = Some(true);
}
self.set_service_tier(service_tier.clone());
self.app_event_tx
.send(AppEvent::CodexOp(AppCommand::override_turn_context(
@@ -144,4 +147,12 @@ impl ChatWidget {
.into_iter()
.find(|tier| tier.name.eq_ignore_ascii_case(SPEED_TIER_FAST))
}
pub(super) fn refresh_effective_service_tier(&mut self) {
self.effective_service_tier = service_tier_resolution::effective_service_tier(
&self.config,
self.current_model(),
&self.model_catalog.try_list_models().unwrap_or_default(),
);
}
}
+3
View File
@@ -66,6 +66,7 @@ impl ChatWidget {
}
}
if feature == Feature::FastMode {
self.refresh_effective_service_tier();
self.sync_service_tier_commands();
}
if feature == Feature::Personality {
@@ -238,6 +239,7 @@ impl ChatWidget {
{
mask.model = Some(model.to_string());
}
self.refresh_effective_service_tier();
self.refresh_model_dependent_surfaces();
}
@@ -519,6 +521,7 @@ impl ChatWidget {
settings.collaboration_mode.settings.model = settings.model;
settings.collaboration_mode.settings.reasoning_effort = settings.effort;
self.set_effective_collaboration_mode(settings.collaboration_mode);
self.refresh_effective_service_tier();
self.refresh_status_surfaces();
self.sync_service_tier_commands();
self.sync_personality_command_enabled();
+1
View File
@@ -144,6 +144,7 @@ pub(super) use codex_protocol::approvals::GuardianUserAuthorization;
pub(super) use codex_protocol::config_types::CollaborationMode;
pub(super) use codex_protocol::config_types::ModeKind;
pub(super) use codex_protocol::config_types::Personality;
pub(super) use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
pub(super) use codex_protocol::config_types::ServiceTier;
pub(super) use codex_protocol::models::ActivePermissionProfile;
pub(super) use codex_protocol::models::BUILT_IN_PERMISSION_PROFILE_WORKSPACE;
+6 -6
View File
@@ -246,15 +246,14 @@ pub(crate) fn set_chatgpt_auth(chat: &mut ChatWidget) {
}
fn test_model_info(slug: &str, priority: i32, supports_fast_mode: bool) -> ModelInfo {
let service_tiers = if supports_fast_mode {
vec![json!({
let mut service_tiers = Vec::new();
if supports_fast_mode {
service_tiers.push(json!({
"id": ServiceTier::Fast.request_value(),
"name": "fast",
"description": "Fastest inference with increased plan usage"
})]
} else {
Vec::new()
};
}));
}
serde_json::from_value(json!({
"slug": slug,
"display_name": slug,
@@ -267,6 +266,7 @@ fn test_model_info(slug: &str, priority: i32, supports_fast_mode: bool) -> Model
"priority": priority,
"additional_speed_tiers": [],
"service_tiers": service_tiers,
"default_service_tier": null,
"availability_nux": null,
"upgrade": null,
"base_instructions": "base instructions",
@@ -2279,6 +2279,7 @@ async fn model_picker_hides_show_in_picker_false_models_from_cache() {
supports_personality: false,
additional_speed_tiers: Vec::new(),
service_tiers: Vec::new(),
default_service_tier: None,
is_default: false,
upgrade: None,
show_in_picker,
@@ -2500,6 +2501,7 @@ async fn single_reasoning_option_skips_selection() {
supports_personality: false,
additional_speed_tiers: Vec::new(),
service_tiers: Vec::new(),
default_service_tier: None,
is_default: false,
upgrade: None,
show_in_picker: true,
@@ -91,8 +91,19 @@ fn next_add_to_history_event(rx: &mut tokio::sync::mpsc::UnboundedReceiver<AppEv
async fn service_tier_commands_lowercase_catalog_names() {
let (mut chat, _rx, _op_rx) = make_chatwidget_manual(Some("gpt-5.4")).await;
let mut preset = get_available_model(&chat, "gpt-5.4");
let expected_description = preset.service_tiers[0].description.clone();
preset.service_tiers[0].name = "Fast".to_string();
let expected_description = preset
.service_tiers
.iter()
.find(|tier| tier.id == ServiceTier::Fast.request_value())
.expect("fast tier")
.description
.clone();
preset
.service_tiers
.iter_mut()
.find(|tier| tier.id == ServiceTier::Fast.request_value())
.expect("fast tier")
.name = "Fast".to_string();
chat.model_catalog = std::sync::Arc::new(ModelCatalog::new(vec![preset]));
assert_eq!(
@@ -2135,6 +2146,47 @@ async fn user_turn_carries_service_tier_after_fast_toggle() {
}
}
#[tokio::test]
async fn model_switch_recomputes_catalog_default_service_tier() {
let (mut chat, _rx, mut op_rx) = make_chatwidget_manual(Some("gpt-5.3-codex")).await;
chat.thread_id = Some(ThreadId::new());
set_chatgpt_auth(&mut chat);
set_fast_mode_test_catalog(&mut chat);
chat.set_feature_enabled(Feature::FastMode, /*enabled*/ true);
let mut models = chat.model_catalog.try_list_models().expect("test catalog");
let default_model = models
.iter_mut()
.find(|model| model.model == "gpt-5.4")
.expect("gpt-5.4 test model");
default_model.default_service_tier = Some(ServiceTier::Fast.request_value().to_string());
chat.model_catalog = std::sync::Arc::new(ModelCatalog::new(models));
chat.refresh_effective_service_tier();
assert_eq!(chat.current_service_tier(), None);
chat.set_model("gpt-5.4");
assert_eq!(
chat.current_service_tier(),
Some(ServiceTier::Fast.request_value())
);
chat.set_model("gpt-5.3-codex");
assert_eq!(chat.current_service_tier(), None);
chat.bottom_pane
.set_composer_text("hello".to_string(), Vec::new(), Vec::new());
chat.handle_key_event(KeyEvent::from(KeyCode::Enter));
match next_submit_op(&mut op_rx) {
Op::UserTurn {
service_tier: Some(Some(service_tier)),
..
} if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE => {}
other => panic!("expected Op::UserTurn with default service tier override, got {other:?}"),
}
}
#[tokio::test]
async fn queued_fast_slash_applies_before_next_queued_message() {
let (mut chat, mut rx, mut op_rx) = make_chatwidget_manual(Some("gpt-5.4")).await;
@@ -2194,18 +2246,20 @@ async fn user_turn_sends_standard_override_after_fast_is_turned_off() {
events.iter().any(|event| matches!(
event,
AppEvent::CodexOp(Op::OverrideTurnContext {
service_tier: Some(None),
service_tier: Some(Some(service_tier)),
..
})
}) if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE
)),
"expected fast-mode off override app event; events: {events:?}"
"expected fast-mode off default service tier app event; events: {events:?}"
);
assert!(
events.iter().any(|event| matches!(
event,
AppEvent::PersistServiceTierSelection { service_tier: None }
AppEvent::PersistServiceTierSelection {
service_tier: Some(service_tier)
} if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE
)),
"expected fast-mode opt-out persistence app event; events: {events:?}"
"expected default service tier persistence app event; events: {events:?}"
);
chat.bottom_pane
@@ -2214,10 +2268,10 @@ async fn user_turn_sends_standard_override_after_fast_is_turned_off() {
match next_submit_op(&mut op_rx) {
Op::UserTurn {
service_tier: Some(None),
service_tier: Some(Some(service_tier)),
..
} => {}
other => panic!("expected Op::UserTurn with standard service tier override, got {other:?}"),
} if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE => {}
other => panic!("expected Op::UserTurn with default service tier override, got {other:?}"),
}
}
+7 -10
View File
@@ -13,6 +13,7 @@ use codex_app_server_protocol::MergeStrategy;
use codex_app_server_protocol::RequestId;
use codex_app_server_protocol::SkillsConfigWriteParams;
use codex_app_server_protocol::SkillsConfigWriteResponse;
use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use codex_utils_absolute_path::AbsolutePathBuf;
use color_eyre::eyre::Result;
use color_eyre::eyre::WrapErr;
@@ -75,26 +76,22 @@ pub(crate) fn build_service_tier_selection_edits(
let service_tier_edit = service_tier.map_or_else(
|| clear_config_value(profile_scoped_key_path(profile, "service_tier")),
|service_tier| {
let config_value =
let config_value = if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE {
SERVICE_TIER_DEFAULT_REQUEST_VALUE
} else {
match codex_protocol::config_types::ServiceTier::from_request_value(service_tier) {
Some(codex_protocol::config_types::ServiceTier::Fast) => "fast",
Some(codex_protocol::config_types::ServiceTier::Flex) => "flex",
None => service_tier,
};
}
};
replace_config_value(
profile_scoped_key_path(profile, "service_tier"),
serde_json::json!(config_value),
)
},
);
let mut edits = vec![service_tier_edit];
if service_tier.is_none() {
edits.push(replace_config_value(
"notice.fast_default_opt_out",
serde_json::json!(true),
));
}
edits
vec![service_tier_edit]
}
pub(crate) async fn write_config_batch(
+1
View File
@@ -164,6 +164,7 @@ mod render;
mod resize_reflow_cap;
mod resume_picker;
mod selection_list;
mod service_tier_resolution;
mod session_log;
mod session_resume;
mod session_state;
@@ -0,0 +1,64 @@
use crate::legacy_core::config::Config;
use codex_features::Feature;
use codex_protocol::config_types::SERVICE_TIER_DEFAULT_REQUEST_VALUE;
use codex_protocol::openai_models::ModelPreset;
pub(crate) fn configured_service_tier(config: &Config) -> Option<String> {
config.service_tier.clone().or_else(|| {
(config.notices.fast_default_opt_out == Some(true))
.then(|| SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string())
})
}
pub(crate) fn effective_service_tier(
config: &Config,
model: &str,
models: &[ModelPreset],
) -> Option<String> {
if !config.features.enabled(Feature::FastMode) {
return None;
}
let configured = configured_service_tier(config);
let Some(preset) = models.iter().find(|preset| preset.model == model) else {
return configured;
};
match configured.as_deref() {
Some(service_tier) if service_tier == SERVICE_TIER_DEFAULT_REQUEST_VALUE => configured,
Some(service_tier) if model_supports_service_tier(preset, service_tier) => configured,
Some(_) => None,
None => preset
.default_service_tier
.clone()
.filter(|service_tier| model_supports_service_tier(preset, service_tier)),
}
}
pub(crate) fn service_tier_update_for_core(
config: &Config,
model: &str,
models: &[ModelPreset],
) -> Option<Option<String>> {
if !config.features.enabled(Feature::FastMode) {
return None;
}
let effective = effective_service_tier(config, model, models);
if let Some(service_tier) = effective {
return Some(Some(service_tier));
}
if !models.iter().any(|preset| preset.model == model) {
return None;
}
Some(Some(SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string()))
}
pub(crate) fn model_supports_service_tier(model: &ModelPreset, service_tier: &str) -> bool {
model
.service_tiers
.iter()
.any(|tier| tier.id == service_tier)
}