Skip to content

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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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.rs
index 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");