Files
codex/codex-rs/tui/src/service_tier_resolution.rs
T
dpatel-oai 7ac954ea24 Enforce Fast and Ultra Fast policies independently (#51253)
## Why

Fast mode previously gated both Fast and Ultra Fast, preventing policies from allowing one while disabling the other.

## What changed

- Add the default-enabled `features.ultrafast_mode` flag and enforce it independently of `features.fast_mode` in service-tier selection, requests, and agent prewarming.
- Filter TUI service-tier commands and selections by the corresponding policy and model catalog support.
- Report `supportsIndependentSpeedModes: true` from `configRequirements/read` and update the protocol schemas and generated bindings. Retain the shared Fast gate when connecting to older servers that omit this capability.
- Preserve legacy cloud speed denials by translating `rbac-fast-mode` fragments with `fast_mode = false` into a denial of both modes, while retaining higher-priority enterprise overrides.

## Testing

Add coverage for all four Fast/Ultra Fast policy combinations in requirements responses and request routing, agent prewarm inheritance, TUI command visibility and saved selections, and legacy cloud denial normalization and override precedence.

GitOrigin-RevId: 147e08524c4b228ea9d46b25a9f8aa64c359e169
2026-10-06 03:35:55 +00:00

105 lines
3.4 KiB
Rust

use crate::legacy_core::config::Config;
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::ModelPreset;
pub(crate) fn constrain_server_service_tiers(
models: &mut [ModelPreset],
requirements: &codex_app_server_protocol::ConfigRequirementsReadResponse,
) {
let Some(features) = requirements
.requirements
.as_ref()
.and_then(|requirements| requirements.feature_requirements.as_ref())
else {
return;
};
let fast_enabled = features.get("fast_mode") != Some(&false);
// Older servers enforce Ultra Fast through their shared Fast mode gate.
let ultrafast_enabled = features.get("ultrafast_mode") != Some(&false)
&& (requirements.supports_independent_speed_modes == Some(true) || fast_enabled);
let tier_enabled = |tier: &str| match tier {
"flex" => true,
"ultrafast" => ultrafast_enabled,
_ => fast_enabled,
};
for model in models {
model.service_tiers.retain(|tier| tier_enabled(&tier.id));
if model
.default_service_tier
.as_deref()
.is_some_and(|tier| !tier_enabled(tier))
{
model.default_service_tier = None;
}
}
}
pub(crate) fn configured_service_tier(
config: &Config,
notices: &codex_config::types::Notice,
) -> Option<String> {
config.service_tier.clone().or_else(|| {
(notices.fast_default_opt_out == Some(true))
.then(|| SERVICE_TIER_DEFAULT_REQUEST_VALUE.to_string())
})
}
pub(crate) fn effective_service_tier(
config: &Config,
notices: &codex_config::types::Notice,
model: &str,
models: &[ModelPreset],
) -> Option<String> {
let configured = configured_service_tier(config, notices);
if configured.as_deref() == Some(ServiceTier::Flex.request_value()) {
return configured;
}
let Some(preset) = models.iter().find(|preset| preset.model == model) else {
return configured.filter(|tier| config.features.service_tier_enabled(tier));
};
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)),
}
.filter(|tier| config.features.service_tier_enabled(tier))
}
pub(crate) fn service_tier_update_for_core(
config: &Config,
notices: &codex_config::types::Notice,
model: &str,
models: &[ModelPreset],
) -> Option<Option<String>> {
let effective = effective_service_tier(config, notices, model, models);
if let Some(service_tier) = effective {
return Some(Some(service_tier));
}
if !config.features.enabled(Feature::FastMode)
&& !config.features.enabled(Feature::UltrafastMode)
{
return None;
}
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)
}