Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust
13.5 KB
Raw Blame
use crate::config;

use super::request::ServiceTier;

pub const ALLOWED_MODELS: &[&str] = &[
    "gpt-5.2",
    "gpt-5.3-codex",
    "gpt-5.3-codex-spark",
    "gpt-5.4",
    "gpt-5.4-mini",
    "gpt-5.5",
    "gpt-5.6-luna",
    "gpt-5.6-sol",
    "gpt-5.6-terra",
    "gpt-6-astra",
    "gpt-6-luna",
    "gpt-6-sol",
    "gpt-6.1-sol",
];

pub const MODEL_ALIASES: &[(&str, &str)] = &[
    ("haiku", "gpt-6-luna"),
    ("claude-haiku-4-5", "gpt-6-luna"),
    ("claude-haiku-4-5-20251001", "gpt-6-luna"),
    ("sonnet", "gpt-5.6-terra"),
    ("claude-sonnet-4-6", "gpt-5.6-terra"),
    ("claude-sonnet-5", "gpt-5.6-terra"),
    ("opus", "gpt-6-sol"),
    ("claude-opus-4-7", "gpt-6-sol"),
    ("claude-opus-4-8", "gpt-6-sol"),
    ("claude-opus-5", "gpt-6-sol"),
    ("claude-opus-5-5", "gpt-6-sol"),
    ("fable", "gpt-6-sol"),
    ("claude-fable-5", "gpt-6-sol"),
];

#[derive(Debug, Clone)]
pub struct ResolvedModel {
    pub model: String,
    pub service_tier: Option<ServiceTier>,
}

/// 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", "gpt-6.1-sol"];

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_tier_model_alias(model: &str) -> ResolvedModel {
    match split_tier_suffix(model) {
        Some((base, tier)) => ResolvedModel {
            model: base.to_string(),
            service_tier: Some(tier),
        },
        None => ResolvedModel {
            model: model.to_string(),
            service_tier: None,
        },
    }
}

pub fn resolve_model_request(model: &str) -> ResolvedModel {
    resolve_model_request_with_config_override(model, true)
}

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_tier_model_alias(alias);

    let resolved = match override_model {
        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,
    }
}

pub fn resolve_model(model: &str) -> String {
    resolve_model_request(model).model
}

#[derive(Debug, Clone)]
pub struct ModelNotAllowedError {
    pub model: String,
}

impl std::fmt::Display for ModelNotAllowedError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Model not allowed: {}", self.model)
    }
}

pub fn assert_allowed_model(model: &str) -> Result<(), ModelNotAllowedError> {
    if ALLOWED_MODELS.contains(&model) {
        Ok(())
    } else {
        Err(ModelNotAllowedError {
            model: model.to_string(),
        })
    }
}

pub fn uses_responses_lite(model: &str) -> bool {
    matches!(
        model,
        "gpt-5.6-luna"
            | "gpt-5.6-sol"
            | "gpt-5.6-terra"
            | "gpt-6-astra"
            | "gpt-6-luna"
            | "gpt-6-sol"
            | "gpt-6.1-sol"
    )
}

/// Luna models exist only behind the Responses Lite lane; the full
/// Responses API resolves them to a `-free` variant and returns 404 (Model not
/// found gpt-5.6-luna-free-...). Hosted web_search requests must run on the
/// full lane, so luna is upgraded to its nearest full-lane sibling.
pub fn full_lane_web_search_model(model: &str) -> &str {
    match model {
        "gpt-5.6-luna" => "gpt-5.6-sol",
        "gpt-6-luna" => "gpt-6-sol",
        _ => model,
    }
}

pub fn is_valid_model_for_codex(model: &str) -> bool {
    if ALLOWED_MODELS.contains(&model) {
        return true;
    }
    if split_tier_suffix(model).is_some() {
        return true;
    }
    MODEL_ALIASES.iter().any(|(alias, _)| *alias == model)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn haiku_resolves_to_luna() {
        let r = resolve_model_request("haiku");
        assert_eq!(r.model, "gpt-6-luna");
    }

    #[test]
    fn web_search_upgrades_luna_to_full_lane_sibling() {
        assert_eq!(full_lane_web_search_model("gpt-5.6-luna"), "gpt-5.6-sol");
        assert_eq!(full_lane_web_search_model("gpt-5.6-sol"), "gpt-5.6-sol");
        assert_eq!(full_lane_web_search_model("gpt-5.6-terra"), "gpt-5.6-terra");
        assert_eq!(full_lane_web_search_model("gpt-5.4"), "gpt-5.4");
        assert_eq!(full_lane_web_search_model("gpt-6-luna"), "gpt-6-sol");
        assert_eq!(full_lane_web_search_model("gpt-6-sol"), "gpt-6-sol");
    }

    #[test]
    fn sonnet_resolves_to_terra() {
        let r = resolve_model_request("sonnet");
        assert_eq!(r.model, "gpt-5.6-terra");
    }

    #[test]
    fn sonnet_5_resolves_to_terra() {
        let r = resolve_model_request("claude-sonnet-5");
        assert_eq!(r.model, "gpt-5.6-terra");
    }

    #[test]
    fn opus_resolves_to_sol() {
        let r = resolve_model_request("opus");
        assert_eq!(r.model, "gpt-6-sol");
    }

    #[test]
    fn opus_aliases_resolve_to_sol() {
        for model in ["claude-opus-4-8", "claude-opus-5", "claude-opus-5-5"] {
            let r = resolve_model_request(model);
            assert_eq!(r.model, "gpt-6-sol");
        }
    }

    #[test]
    fn fable_5_resolves_to_sol() {
        for model in ["fable", "claude-fable-5"] {
            let r = resolve_model_request(model);
            assert_eq!(r.model, "gpt-6-sol");
        }
    }

    #[test]
    fn gpt_6_sol_fast_adds_priority() {
        for model in ["gpt-6-sol", "gpt-6.1-sol"] {
            let r = resolve_model_request(&format!("{model}-fast"));
            assert_eq!(r.model, model);
            assert_eq!(r.service_tier, Some(ServiceTier::Priority));
        }
    }

    #[test]
    fn gpt_6_models_use_responses_lite() {
        assert!(uses_responses_lite("gpt-6-sol"));
        assert!(uses_responses_lite("gpt-6-luna"));
        assert!(uses_responses_lite("gpt-6.1-sol"));
    }

    #[test]
    fn fast_suffix_adds_priority() {
        let r = resolve_model_request("gpt-5.6-sol-fast");
        assert_eq!(r.model, "gpt-5.6-sol");
        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_with_model_override(&name, None);
            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_with_model_override(&name, None);
            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.1-sol",
                ServiceTier::Ultrafast,
                ServiceTier::Ultrafast,
            ),
            ("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",
                None,
                "gpt-6-sol",
                Some(ServiceTier::Priority),
            ),
            (
                "gpt-6-sol",
                Some("gpt-6-astra-fast"),
                "gpt-6-astra",
                Some(ServiceTier::Priority),
            ),
            (
                "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());
        assert!(assert_allowed_model("gpt-5.6-sol").is_ok());
        assert!(assert_allowed_model("gpt-5.6-terra").is_ok());
        assert!(assert_allowed_model("gpt-6-astra").is_ok());
        assert!(assert_allowed_model("gpt-5.6-luna").is_ok());
        assert!(assert_allowed_model("gpt-6.1-sol").is_ok());
    }

    #[test]
    fn not_allowed_rejected() {
        assert!(assert_allowed_model("gpt-7").is_err());
    }
}