Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
codex: let requests select the ultrafast service tier
Koichi Shiraishi2ae753562172
diff --git a/src/providers/codex/chat_completions/request.rs b/src/providers/codex/chat_completions/request.rsindex eeb2062..a507197 100644--- a/src/providers/codex/chat_completions/request.rs+++ b/src/providers/codex/chat_completions/request.rs@@ -457,6 +457,37 @@ mod tests {assert_eq!(translated.upstream["reasoning"]["context"], "all_turns");}+ #[test]+ fn tier_suffix_sets_service_tier() {+ for (model, upstream_model, tier) in [+ ("gpt-6-astra", "gpt-6-astra", None),+ ("gpt-6-astra-fast", "gpt-6-astra", Some("priority")),+ ("gpt-6-astra-ultrafast", "gpt-6-astra", Some("ultrafast")),+ (+ "gpt-6-astra-ultrafast[1m]",+ "gpt-6-astra",+ Some("ultrafast"),+ ),+ ] {+ let mut body = base();+ body["model"] = json!(model);+ let translated = translate_request(body).unwrap();+ assert_eq!(translated.upstream["model"], upstream_model, "{model}");+ assert_eq!(+ translated+ .upstream+ .get("service_tier")+ .and_then(Value::as_str),+ tier,+ "{model}"+ );+ }++ let mut body = base();+ body["model"] = json!("gpt-6-sol-ultrafast");+ assert!(translate_request(body).is_err());+ }+#[test]fn none_effort_retains_context() {let mut body = base();diff --git a/src/providers/codex/mod.rs b/src/providers/codex/mod.rsindex 0165e51..52bb657 100644--- a/src/providers/codex/mod.rs+++ b/src/providers/codex/mod.rs@@ -51,7 +51,7 @@ use self::translate::accumulate::accumulate_response_with_traffic;use self::translate::live_stream::LiveStreamTranslator;use self::translate::model_allowlist::{assert_allowed_model, full_lane_web_search_model, resolve_model_request_with_config_override,- uses_responses_lite,+ tier_model_variants, uses_responses_lite,};use self::translate::reducer::finish_metadata_from_upstream;use self::translate::request::{@@ -532,7 +532,7 @@ impl Provider for CodexProvider {.map(|m| m.to_string()).collect();for m in registry::CODEX_MODELS {- models.push(format!("{m}-fast"));+ models.extend(tier_model_variants(m));}models.sort_unstable();models.dedup();@@ -2077,6 +2077,9 @@ mod tests {assert!(models.contains(&"gpt-6.1-sol-fast".to_string()));assert!(models.contains(&"gpt-5.4".to_string()));assert!(models.contains(&"gpt-5.4-mini".to_string()));+ assert!(models.contains(&"gpt-6-astra-fast".to_string()));+ assert!(models.contains(&"gpt-6-astra-ultrafast".to_string()));+ assert!(!models.contains(&"gpt-6-sol-ultrafast".to_string()));}#[test]diff --git a/src/providers/codex/native.rs b/src/providers/codex/native.rsindex 23fb6c4..aa67806 100644--- a/src/providers/codex/native.rs+++ b/src/providers/codex/native.rs@@ -20,8 +20,9 @@ use crate::traffic::{use super::client::{CodexError, CodexHttpClient};use super::translate::model_allowlist::{ALLOWED_MODELS, MODEL_ALIASES, assert_allowed_model, full_lane_web_search_model,- uses_responses_lite,+ split_tier_suffix, uses_responses_lite,};+use super::translate::request::ServiceTier;pub struct CodexNativeBackend {client: Arc<CodexHttpClient>,@@ -118,15 +119,17 @@ fn shape_native_request(body: &mut Value) -> Result<NativeResolved, Response> {.as_object_mut().expect("validated native Responses body must be an object");- let (mut model, priority) = resolve_native_model(&requested);+ let (mut model, service_tier) = resolve_native_model(&requested);let hosted_web_search = has_native_hosted_web_search(object);if hosted_web_search {model = full_lane_web_search_model(&model).to_string();}object.insert("model".to_string(), Value::String(model.clone()));- if priority && !object.contains_key("service_tier") {- object.insert("service_tier".to_string(), json!("priority"));+ if let Some(tier) = service_tier+ && !object.contains_key("service_tier")+ {+ object.insert("service_tier".to_string(), json!(tier));}Ok(NativeResolved {@@ -139,17 +142,17 @@ fn shape_native_request(body: &mut Value) -> Result<NativeResolved, Response> {})}-fn resolve_native_model(requested: &str) -> (String, bool) {- let (requested, priority) = match requested.strip_suffix("-fast") {- Some(base) if ALLOWED_MODELS.contains(&base) => (base, true),- _ => (requested, false),+fn resolve_native_model(requested: &str) -> (String, Option<ServiceTier>) {+ let (requested, service_tier) = match split_tier_suffix(requested) {+ Some((base, tier)) => (base, Some(tier)),+ None => (requested, None),};let model = MODEL_ALIASES.iter().find(|(alias, _)| *alias == requested).map(|(_, target)| *target).unwrap_or(requested);- (model.to_string(), priority)+ (model.to_string(), service_tier)}fn has_native_hosted_web_search(object: &Map<String, Value>) -> bool {@@ -716,6 +719,30 @@ mod tests {}}+ #[test]+ fn native_request_resolves_ultrafast_tier() {+ let mut body = request(json!({"model":"gpt-6-astra-ultrafast","input":[]}));+ let resolved = shape_native_request(&mut body).unwrap();+ assert_eq!(resolved.model, "gpt-6-astra");+ assert_eq!(body["model"], "gpt-6-astra");+ assert_eq!(body["service_tier"], "ultrafast");++ let mut explicit = request(json!({+ "model":"gpt-6-astra-ultrafast",+ "service_tier":"priority",+ "input":[]+ }));+ shape_native_request(&mut explicit).unwrap();+ assert_eq!(explicit["service_tier"], "priority");+ }++ #[test]+ fn native_request_rejects_ultrafast_suffix_without_the_tier() {+ let mut body = request(json!({"model":"gpt-6-sol-ultrafast","input":[]}));+ let response = shape_native_request(&mut body).err().unwrap();+ assert_eq!(response.status(), StatusCode::BAD_REQUEST);+ }+#[test]fn explicit_service_tier_is_preserved() {let mut body = request(json!({diff --git a/src/providers/codex/translate/model_allowlist.rs b/src/providers/codex/translate/model_allowlist.rsindex 2f90d81..bdfa9d6 100644--- a/src/providers/codex/translate/model_allowlist.rs+++ b/src/providers/codex/translate/model_allowlist.rs@@ -1,5 +1,3 @@-use std::collections::HashSet;-use crate::config;use super::request::ServiceTier;@@ -42,23 +40,56 @@ pub struct ResolvedModel {pub service_tier: Option<ServiceTier>,}-fn fast_model_aliases() -> HashSet<String> {- ALLOWED_MODELS.iter().map(|m| format!("{m}-fast")).collect()+/// Models whose Codex catalog entry offers the `ultrafast` service tier.+/// Every other model offers `priority` at most, so it gets no `-ultrafast` form.+pub const ULTRAFAST_MODELS: &[&str] = &["gpt-6-astra"];++const FAST_SUFFIX: &str = "-fast";+const ULTRAFAST_SUFFIX: &str = "-ultrafast";++/// Splits a local service-tier suffix off a registered model: `-fast` on any+/// registered model, `-ultrafast` only on [`ULTRAFAST_MODELS`].+pub fn split_tier_suffix(model: &str) -> Option<(&str, ServiceTier)> {+ if let Some(base) = model.strip_suffix(ULTRAFAST_SUFFIX) {+ return ULTRAFAST_MODELS+ .contains(&base)+ .then_some((base, ServiceTier::Ultrafast));+ }+ let base = model.strip_suffix(FAST_SUFFIX)?;+ ALLOWED_MODELS+ .contains(&base)+ .then_some((base, ServiceTier::Priority))+}++/// Local tier-suffixed names advertised next to a registered model.+pub fn tier_model_variants(model: &str) -> Vec<String> {+ let mut variants = vec![format!("{model}{FAST_SUFFIX}")];+ if ULTRAFAST_MODELS.contains(&model) {+ variants.push(format!("{model}{ULTRAFAST_SUFFIX}"));+ }+ variants+}++/// Narrows a requested tier to one `model` offers. The backend serves an+/// unlisted tier at standard speed without an error, so ultrafast on a model+/// outside [`ULTRAFAST_MODELS`] falls back to priority, the fastest tier there.+pub fn service_tier_for_model(model: &str, tier: ServiceTier) -> ServiceTier {+ match tier {+ ServiceTier::Ultrafast if !ULTRAFAST_MODELS.contains(&model) => ServiceTier::Priority,+ tier => tier,+ }}-fn resolve_fast_model_alias(model: &str) -> ResolvedModel {- let fast_set = fast_model_aliases();- if fast_set.contains(model) {- let base = model.trim_end_matches("-fast");- ResolvedModel {+fn resolve_tier_model_alias(model: &str) -> ResolvedModel {+ match split_tier_suffix(model) {+ Some((base, tier)) => ResolvedModel {model: base.to_string(),- service_tier: Some(ServiceTier::Priority),- }- } else {- ResolvedModel {+ service_tier: Some(tier),+ },+ None => ResolvedModel {model: model.to_string(),service_tier: None,- }+ },}}@@ -70,29 +101,34 @@ pub fn resolve_model_request_with_config_override(model: &str,apply_config_override: bool,) -> ResolvedModel {+ let override_model = apply_config_override.then(config::codex_model).flatten();+ resolve_with_model_override(model, override_model.as_deref())+}++fn resolve_with_model_override(model: &str, override_model: Option<&str>) -> ResolvedModel {let alias = MODEL_ALIASES.iter().find(|(alias, _)| *alias == model).map(|(_, target)| *target).unwrap_or(model);- let requested = resolve_fast_model_alias(alias);+ let requested = resolve_tier_model_alias(alias);- let override_model = apply_config_override.then(config::codex_model).flatten();let resolved = match override_model {- Some(ref val) if !val.is_empty() => resolve_fast_model_alias(val),+ Some(val) if !val.is_empty() => resolve_tier_model_alias(val),_ => requested.clone(),};+ // A tier suffix on the override wins; otherwise the requested suffix+ // carries over to the override model, which may not offer that tier.+ let service_tier = resolved+ .service_tier+ .or(requested.service_tier)+ .map(|tier| service_tier_for_model(&resolved.model, tier));+ResolvedModel {model: resolved.model,- service_tier: if requested.service_tier == Some(ServiceTier::Priority)- || resolved.service_tier == Some(ServiceTier::Priority)- {- Some(ServiceTier::Priority)- } else {- resolved.service_tier- },+ service_tier,}}@@ -150,8 +186,7 @@ pub fn is_valid_model_for_codex(model: &str) -> bool {if ALLOWED_MODELS.contains(&model) {return true;}- let fast_set = fast_model_aliases();- if fast_set.contains(model) {+ if split_tier_suffix(model).is_some() {return true;}MODEL_ALIASES.iter().any(|(alias, _)| *alias == model)@@ -234,6 +269,134 @@ mod tests {assert_eq!(r.service_tier, Some(ServiceTier::Priority));}+ #[test]+ fn ultrafast_suffix_adds_ultrafast_tier() {+ for model in ULTRAFAST_MODELS {+ let name = format!("{model}-ultrafast");+ assert!(is_valid_model_for_codex(&name), "{name}");+ let r = resolve_model_request(&name);+ assert_eq!(r.model, *model);+ assert_eq!(r.service_tier, Some(ServiceTier::Ultrafast));+ assert!(assert_allowed_model(&r.model).is_ok());+ }+ }++ #[test]+ fn ultrafast_suffix_is_rejected_for_models_without_the_tier() {+ for model in ALLOWED_MODELS {+ if ULTRAFAST_MODELS.contains(model) {+ continue;+ }+ let name = format!("{model}-ultrafast");+ assert!(!is_valid_model_for_codex(&name), "{name}");+ assert_eq!(split_tier_suffix(&name), None, "{name}");+ let r = resolve_model_request(&name);+ assert_eq!(r.service_tier, None, "{name}");+ assert!(assert_allowed_model(&r.model).is_err(), "{name}");+ }+ }++ #[test]+ fn ultrafast_models_are_registered() {+ for model in ULTRAFAST_MODELS {+ assert!(ALLOWED_MODELS.contains(model), "{model}");+ }+ }++ #[test]+ fn service_tier_narrows_to_what_the_model_offers() {+ for (model, tier, expected) in [+ (+ "gpt-6-astra",+ ServiceTier::Ultrafast,+ ServiceTier::Ultrafast,+ ),+ ("gpt-6-astra", ServiceTier::Priority, ServiceTier::Priority),+ ("gpt-6-astra", ServiceTier::Flex, ServiceTier::Flex),+ ("gpt-6-sol", ServiceTier::Ultrafast, ServiceTier::Priority),+ ("gpt-6-luna", ServiceTier::Ultrafast, ServiceTier::Priority),+ ("gpt-6-sol", ServiceTier::Priority, ServiceTier::Priority),+ ("gpt-6-sol", ServiceTier::Flex, ServiceTier::Flex),+ ] {+ assert_eq!(+ service_tier_for_model(model, tier.clone()),+ expected,+ "{model} {tier:?}"+ );+ }+ }++ #[test]+ fn tier_suffix_is_stripped_once() {+ assert_eq!(+ split_tier_suffix("gpt-6-astra-fast"),+ Some(("gpt-6-astra", ServiceTier::Priority))+ );+ assert_eq!(split_tier_suffix("gpt-6-astra-fast-fast"), None);+ assert_eq!(split_tier_suffix("gpt-6-astra-ultrafast-fast"), None);+ assert_eq!(split_tier_suffix("gpt-6-astra"), None);+ assert_eq!(split_tier_suffix("-fast"), None);+ }++ #[test]+ fn tier_model_variants_lists_supported_suffixes() {+ assert_eq!(+ tier_model_variants("gpt-6-astra"),+ ["gpt-6-astra-fast", "gpt-6-astra-ultrafast"]+ );+ assert_eq!(tier_model_variants("gpt-6-sol"), ["gpt-6-sol-fast"]);+ }++ #[test]+ fn model_override_merges_tier_suffixes() {+ let cases: &[(&str, Option<&str>, &str, Option<ServiceTier>)] = &[+ ("gpt-6-sol", None, "gpt-6-sol", None),+ ("gpt-6-sol", Some(""), "gpt-6-sol", None),+ (+ "gpt-6-sol-fast",+ Some("gpt-6-astra"),+ "gpt-6-astra",+ Some(ServiceTier::Priority),+ ),+ (+ "gpt-6-sol",+ Some("gpt-6-astra-ultrafast"),+ "gpt-6-astra",+ Some(ServiceTier::Ultrafast),+ ),+ (+ "gpt-6-sol-fast",+ Some("gpt-6-astra-ultrafast"),+ "gpt-6-astra",+ Some(ServiceTier::Ultrafast),+ ),+ (+ "gpt-6-astra-ultrafast",+ Some("gpt-6-astra-fast"),+ "gpt-6-astra",+ Some(ServiceTier::Priority),+ ),+ (+ "gpt-6-astra-ultrafast",+ Some("gpt-6-astra"),+ "gpt-6-astra",+ Some(ServiceTier::Ultrafast),+ ),+ (+ "gpt-6-astra-ultrafast",+ Some("gpt-6-sol"),+ "gpt-6-sol",+ Some(ServiceTier::Priority),+ ),+ ("opus", Some("gpt-6-astra"), "gpt-6-astra", None),+ ];+ for (requested, override_model, model, tier) in cases {+ let r = resolve_with_model_override(requested, *override_model);+ assert_eq!(r.model, *model, "{requested} + {override_model:?}");+ assert_eq!(&r.service_tier, tier, "{requested} + {override_model:?}");+ }+ }+#[test]fn allowed_models_accept_base() {assert!(assert_allowed_model("gpt-5.4").is_ok());diff --git a/src/providers/codex/translate/request.rs b/src/providers/codex/translate/request.rsindex ab6226e..aa563dd 100644--- a/src/providers/codex/translate/request.rs+++ b/src/providers/codex/translate/request.rs@@ -11,6 +11,7 @@ use crate::providers::translate_shared::{read_effort,};+use super::model_allowlist::service_tier_for_model;use super::read_rewrite::{ReadOffsetRewrite, read_offset_rewrite};use super::reasoning_signature::decode_reasoning_signature;@@ -46,6 +47,7 @@ impl std::fmt::Display for Effort {#[serde(rename_all = "snake_case")]pub enum ServiceTier {Priority,+ Ultrafast,Flex,}@@ -387,29 +389,39 @@ fn compact_effort_cap_from(raw: Option<&str>) -> Option<Effort> {}}-const VALID_SERVICE_TIERS: &[&str] = &["fast", "priority", "flex"];+const VALID_SERVICE_TIERS: &[&str] = &["fast", "priority", "ultrafast", "flex"];fn normalize_service_tier(tier: &str) -> Result<ServiceTier, anyhow::Error> {- if !VALID_SERVICE_TIERS.contains(&tier) {- anyhow::bail!(- "Invalid service tier override: \"{tier}\". Must be one of: {}",- VALID_SERVICE_TIERS.join(", ")- );- }match tier {+ "fast" | "priority" => Ok(ServiceTier::Priority),+ "ultrafast" => Ok(ServiceTier::Ultrafast),"flex" => Ok(ServiceTier::Flex),- _ => Ok(ServiceTier::Priority),+ _ => anyhow::bail!(+ "Invalid service tier override: \"{tier}\". Must be one of: {}",+ VALID_SERVICE_TIERS.join(", ")+ ),}}fn resolve_service_tier(model_tier: Option<ServiceTier>,+ model: &str,) -> Result<Option<ServiceTier>, anyhow::Error> {- let tier = config::codex_service_tier();- match tier {- Some(ref val) => Ok(Some(normalize_service_tier(val)?)),- None => Ok(model_tier),- }+ pick_service_tier(config::codex_service_tier().as_deref(), model_tier, model)+}++/// The configured override wins over the tier implied by the model name. Either+/// one is narrowed to a tier the upstream `model` offers.+fn pick_service_tier(+ override_tier: Option<&str>,+ model_tier: Option<ServiceTier>,+ model: &str,+) -> Result<Option<ServiceTier>, anyhow::Error> {+ let tier = match override_tier {+ Some(value) => Some(normalize_service_tier(value)?),+ None => model_tier,+ };+ Ok(tier.map(|tier| service_tier_for_model(model, tier)))}pub fn normalize_strict_json_schema(schema: &Value) -> Value {@@ -568,7 +580,7 @@ fn translate_request_inner(}if apply_codex_config {- let service_tier = resolve_service_tier(opts.service_tier)?;+ let service_tier = resolve_service_tier(opts.service_tier, &out.model)?;if let Some(ref tier) = service_tier {out.service_tier = Some(tier.clone());}@@ -1212,6 +1224,100 @@ mod tests {}}+ #[test]+ fn service_tier_override_values_normalize_to_wire_tiers() {+ for (value, tier, wire) in [+ ("fast", ServiceTier::Priority, "priority"),+ ("priority", ServiceTier::Priority, "priority"),+ ("ultrafast", ServiceTier::Ultrafast, "ultrafast"),+ ("flex", ServiceTier::Flex, "flex"),+ ] {+ let normalized = normalize_service_tier(value).unwrap();+ assert_eq!(normalized, tier, "{value}");+ assert_eq!(serde_json::to_value(normalized).unwrap(), json!(wire));+ }+ for value in ["", "default", "Ultrafast", "ultra-fast", "turbo"] {+ let error = normalize_service_tier(value).unwrap_err().to_string();+ assert!(error.contains("ultrafast"), "{value}: {error}");+ }+ }++ #[test]+ fn service_tier_override_wins_and_narrows_to_the_model() {+ let cases = [+ (None, None, "gpt-6-astra", None),+ (+ None,+ Some(ServiceTier::Ultrafast),+ "gpt-6-astra",+ Some(ServiceTier::Ultrafast),+ ),+ (+ None,+ Some(ServiceTier::Ultrafast),+ "gpt-6-sol",+ Some(ServiceTier::Priority),+ ),+ (+ Some("ultrafast"),+ None,+ "gpt-6-astra",+ Some(ServiceTier::Ultrafast),+ ),+ (+ Some("ultrafast"),+ Some(ServiceTier::Priority),+ "gpt-6-astra",+ Some(ServiceTier::Ultrafast),+ ),+ (+ Some("ultrafast"),+ None,+ "gpt-6-luna",+ Some(ServiceTier::Priority),+ ),+ (+ Some("fast"),+ Some(ServiceTier::Ultrafast),+ "gpt-6-astra",+ Some(ServiceTier::Priority),+ ),+ (+ Some("flex"),+ Some(ServiceTier::Ultrafast),+ "gpt-6-astra",+ Some(ServiceTier::Flex),+ ),+ ];+ for (override_tier, model_tier, model, expected) in cases {+ let picked = pick_service_tier(override_tier, model_tier.clone(), model).unwrap();+ assert_eq!(picked, expected, "{override_tier:?} {model_tier:?} {model}");+ }+ assert!(pick_service_tier(Some("turbo"), None, "gpt-6-astra").is_err());+ }++ #[test]+ fn ultrafast_model_tier_reaches_the_wire() {+ let req: MessagesRequest = serde_json::from_value(json!({+ "model": "gpt-6-astra-ultrafast",+ "messages": [{"role":"user", "content":"hi"}]+ }))+ .unwrap();+ let out = translate_request(+ &req,+ TranslateOptions {+ session_id: None,+ service_tier: Some(ServiceTier::Ultrafast),+ model: "gpt-6-astra".to_string(),+ use_responses_lite: true,+ },+ )+ .unwrap();+ let wire = serde_json::to_value(out).unwrap();+ assert_eq!(wire["model"], "gpt-6-astra");+ assert_eq!(wire["service_tier"], "ultrafast");+ }+#[test]fn responses_tool_choice_modes_serialize_as_openai_strings() {for (mode, expected) in [diff --git a/src/registry.rs b/src/registry.rsindex 9714804..2a1bc5d 100644--- a/src/registry.rs+++ b/src/registry.rs@@ -2,6 +2,7 @@ use crate::{anthropic::{json_error, schema::MessagesRequest},config::AliasProvider,provider::{CliHandlers, Provider, RequestContext},+ providers::codex::translate::model_allowlist::tier_model_variants,};use anyhow::{Result, anyhow};use async_trait::async_trait;@@ -324,9 +325,10 @@ fn expand_codex_models() -> Vec<String> {if set.insert((*model).to_string()) {out.push((*model).to_string());}- let fast = format!("{model}-fast");- if set.insert(fast.clone()) {- out.push(fast);+ for variant in tier_model_variants(model) {+ if set.insert(variant.clone()) {+ out.push(variant);+ }}}out.sort_unstable();@@ -350,6 +352,27 @@ mod tests {fn normalize_model_trims_hint() {assert_eq!(normalize_incoming_model("gpt-5.4-fast[1m]"), "gpt-5.4-fast");assert_eq!(normalize_incoming_model("gpt-5.4-fast"), "gpt-5.4-fast");+ assert_eq!(+ normalize_incoming_model("gpt-6-astra-ultrafast[1m]"),+ "gpt-6-astra-ultrafast"+ );+ }++ #[test]+ fn ultrafast_variant_routes_to_codex_only_where_offered() {+ let registry = Registry::new(AliasProvider::Codex);+ for model in ["gpt-6-astra-ultrafast", "gpt-6-astra-ultrafast[1m]"] {+ assert_eq!(+ registry.provider_for_model(model, None).unwrap().name(),+ "codex"+ );+ }+ for model in ["gpt-6-sol-ultrafast", "gpt-6-luna-ultrafast"] {+ assert!(+ registry.provider_for_model(model, None).is_none(),+ "{model}"+ );+ }}#[test]diff --git a/tests/server.rs b/tests/server.rsindex 3065df0..eb36c78 100644--- a/tests/server.rs+++ b/tests/server.rs@@ -1529,6 +1529,8 @@ async fn models_endpoint_lists_supported_models() {assert!(ids.contains(&"gpt-5.6-sol"));assert!(ids.contains(&"gpt-6.1-sol"));assert!(ids.contains(&"gpt-6.1-sol-fast"));+ assert!(ids.contains(&"gpt-6-astra-ultrafast"));+ assert!(!ids.contains(&"gpt-6.1-sol-ultrafast"));assert!(ids.contains(&"grok-4.6"));for entry in data {assert_eq!(entry["type"], "model");