everruns-contracts 0.44.0

use super::*;

fn openai_embedding_profile(name: &str, family: &str, input_cost: f64) -> ModelProfile {
    ModelProfile {
        name: name.into(),
        family: family.into(),
        description: None,
        release_date: Some("2024-01-25".into()),
        last_updated: Some("2024-01-25".into()),
        attachment: false,
        reasoning: false,
        temperature: false,
        knowledge: None,
        tool_call: false,
        structured_output: false,
        open_weights: false,
        cost: Some(ModelCost {
            input: input_cost,
            output: 0.0,
            cache_read: None,
            cache_write: None,
            cost_tiers: vec![],
        }),
        limits: Some(ModelLimits {
            context: 8_191,
            input: None,
            output: 0,
            max_media: None,
        }),
        modalities: Some(ModelModalities {
            input: vec![Modality::Text],
            output: vec![],
        }),
        reasoning_effort: None,
        speed: None,
        verbosity: None,
        tool_search: false,
        supported_parameters: Vec::new(),
        supports_phases: false,
        supports_server_compaction: false,
        decisions: None,
    }
}

pub(super) fn openai_profile_data(model_id: &str) -> Option<ModelProfile> {
    match model_id {
        "gpt-6-astra" | "gpt-6-sol" | "gpt-6-luna" | "gpt-6.1-sol" => gpt6::profile_data(model_id),
        "text-embedding-3-small" => Some(openai_embedding_profile(
            "Text Embedding 3 Small",
            "text-embedding-3-small",
            0.02,
        )),
        "text-embedding-3-large" => Some(openai_embedding_profile(
            "Text Embedding 3 Large",
            "text-embedding-3-large",
            0.13,
        )),
        "gpt-realtime-2" | "gpt-realtime-2.1" => realtime::profile_data(model_id),
        "o3" => Some(ModelProfile {
            name: "o3".into(),
            family: "o3".into(),
            description: None,
            release_date: Some("2025-04-16".into()),
            last_updated: Some("2025-04-16".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 2.00,
                output: 8.00,
                cache_read: Some(1.00),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 200_000,
                input: None,
                output: 100_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_standard()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "o3-pro" => Some(ModelProfile {
            name: "o3 Pro".into(),
            family: "o3-pro".into(),
            description: None,
            release_date: Some("2025-06-10".into()),
            last_updated: Some("2025-06-10".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 20.00,
                output: 80.00,
                cache_read: None,
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 200_000,
                input: None,
                output: 100_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_high_only()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "o4-mini" => Some(ModelProfile {
            name: "o4 mini".into(),
            family: "o4-mini".into(),
            description: None,
            release_date: Some("2025-04-16".into()),
            last_updated: Some("2025-04-16".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.10,
                output: 4.40,
                cache_read: Some(0.55),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 200_000,
                input: None,
                output: 100_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_standard()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-4.1 family models
        "gpt-4.1" => Some(ModelProfile {
            name: "GPT-4.1".into(),
            family: "gpt-4.1".into(),
            description: None,
            release_date: Some("2025-04-14".into()),
            last_updated: Some("2025-04-14".into()),
            attachment: true,
            reasoning: false,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 2.00,
                output: 8.00,
                cache_read: Some(1.00),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 16_384,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: None,
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-4.1-mini" => Some(ModelProfile {
            name: "GPT-4.1 mini".into(),
            family: "gpt-4.1-mini".into(),
            description: None,
            release_date: Some("2025-04-14".into()),
            last_updated: Some("2025-04-14".into()),
            attachment: true,
            reasoning: false,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.40,
                output: 1.60,
                cache_read: Some(0.20),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 16_384,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: None,
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-4.1-nano" => Some(ModelProfile {
            name: "GPT-4.1 nano".into(),
            family: "gpt-4.1-nano".into(),
            description: None,
            release_date: Some("2025-04-14".into()),
            last_updated: Some("2025-04-14".into()),
            attachment: true,
            reasoning: false,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.10,
                output: 0.40,
                cache_read: Some(0.05),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 16_384,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: None,
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5 family models
        // Pre-5.1 models: default medium, supports low/medium/high (no none)
        "gpt-5" => Some(ModelProfile {
            name: "GPT-5".into(),
            family: "gpt-5".into(),
            description: None,
            release_date: Some("2025-08-07".into()),
            last_updated: Some("2025-08-07".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-10-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.25,
                output: 10.00,
                cache_read: Some(0.125),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt5_pre51()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5-mini" => Some(ModelProfile {
            name: "GPT-5 mini".into(),
            family: "gpt-5-mini".into(),
            description: None,
            release_date: Some("2025-08-13".into()),
            last_updated: Some("2025-08-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.25,
                output: 2.00,
                cache_read: Some(0.025),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 64_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt5_pre51()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5-nano" => Some(ModelProfile {
            name: "GPT-5 nano".into(),
            family: "gpt-5-nano".into(),
            description: None,
            release_date: Some("2025-08-13".into()),
            last_updated: Some("2025-08-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-05-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.05,
                output: 0.40,
                cache_read: Some(0.005),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 64_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt5_pre51()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5-pro" => Some(ModelProfile {
            name: "GPT-5 Pro".into(),
            family: "gpt-5-pro".into(),
            description: None,
            release_date: Some("2025-08-07".into()),
            last_updated: Some("2025-08-07".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-10-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 15.00,
                output: 60.00,
                cache_read: None,
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_high_only()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5-codex" => Some(ModelProfile {
            name: "GPT-5 Codex".into(),
            family: "gpt-5-codex".into(),
            description: None,
            release_date: Some("2025-08-07".into()),
            last_updated: Some("2025-08-07".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-09-30".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.25,
                output: 10.00,
                cache_read: Some(0.125),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt5_pre51()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.1 models: default none, supports none/low/medium/high
        "gpt-5.1" => Some(ModelProfile {
            name: "GPT-5.1".into(),
            family: "gpt-5.1".into(),
            description: None,
            release_date: Some("2025-11-13".into()),
            last_updated: Some("2025-11-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-09-30".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.50,
                output: 12.00,
                cache_read: Some(0.15),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt51()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.1-codex" => Some(ModelProfile {
            name: "GPT-5.1 Codex".into(),
            family: "gpt-5.1-codex".into(),
            description: None,
            release_date: Some("2025-11-13".into()),
            last_updated: Some("2025-11-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-09-30".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.50,
                output: 12.00,
                cache_read: Some(0.15),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt51()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.1-codex-mini" => Some(ModelProfile {
            name: "GPT-5.1 Codex mini".into(),
            family: "gpt-5.1-codex-mini".into(),
            description: None,
            release_date: Some("2025-11-13".into()),
            last_updated: Some("2025-11-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-09-30".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.30,
                output: 2.40,
                cache_read: Some(0.03),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 100_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt51()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.1-codex-max and after: supports xhigh
        "gpt-5.1-codex-max" => Some(ModelProfile {
            name: "GPT-5.1 Codex max".into(),
            family: "gpt-5.1-codex-max".into(),
            description: None,
            release_date: Some("2025-11-13".into()),
            last_updated: Some("2025-11-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-09-30".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 3.00,
                output: 24.00,
                cache_read: Some(0.30),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.2 models: supports xhigh, 400K context
        "gpt-5.2" => Some(ModelProfile {
            name: "GPT-5.2".into(),
            family: "gpt-5.2".into(),
            description: None,
            release_date: Some("2025-12-11".into()),
            last_updated: Some("2025-12-11".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.75,
                output: 14.00,
                cache_read: Some(0.175),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 400_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.2-pro" => Some(ModelProfile {
            name: "GPT-5.2 Pro".into(),
            family: "gpt-5.2-pro".into(),
            description: None,
            release_date: Some("2025-12-11".into()),
            last_updated: Some("2025-12-11".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 21.00,
                output: 168.00,
                cache_read: None,
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 400_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52_pro()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.2-codex" => Some(ModelProfile {
            name: "GPT-5.2 Codex".into(),
            family: "gpt-5.2-codex".into(),
            description: None,
            release_date: Some("2025-12-11".into()),
            last_updated: Some("2025-12-11".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.75,
                output: 14.00,
                cache_read: Some(0.175),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 400_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.3 Codex: same pricing as 5.2, 25% faster inference
        "gpt-5.3-codex" => Some(ModelProfile {
            name: "GPT-5.3 Codex".into(),
            family: "gpt-5.3-codex".into(),
            description: None,
            release_date: Some("2026-02-05".into()),
            last_updated: Some("2026-02-05".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.75,
                output: 14.00,
                cache_read: Some(0.175),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 400_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: Some(speed_priority_only()),
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.6 series: current flagship family, publicly released 2026-07-09.
        // The version (5.6) names the generation; Sol/Terra/Luna are durable
        // capability tiers (intelligence / balanced / fast-and-cheap) that can
        // advance on their own cadence. All three share a 1.05M context, 128K
        // output, a 2026-02-16 knowledge cutoff, and none/low/medium/high/xhigh
        // reasoning effort (default medium). Pricing is tiered: prompts over
        // 272K input tokens bill at 2x input and 1.5x output for the whole
        // request. Source: developers.openai.com/api/docs/models/gpt-5.6-{sol,
        // terra,luna} and openai.com/index/gpt-5-6/ (models.dev did not yet list
        // these variants at the time of addition; refresh once it catches up).
        "gpt-5.6-sol" => Some(ModelProfile {
            name: "GPT-5.6 Sol".into(),
            family: "gpt-5.6-sol".into(),
            description: Some("Flagship model of the GPT-5.6 series. Deepest reasoning for complex agentic coding, science, and multi-step analysis.".into()),
            release_date: Some("2026-07-09".into()),
            last_updated: Some("2026-07-09".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2026-02-16".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 5.00,
                output: 30.00,
                cache_read: Some(0.50),
                cache_write: Some(6.25),
                cost_tiers: vec![CostTier {
                    above_tokens: 272_000,
                    input: 10.00,
                    output: 45.00,
                    cache_read: Some(1.00),
                    cache_write: Some(12.5),
                }],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt55()),
            speed: Some(speed_flex_priority()),
            verbosity: Some(verbosity_standard()),
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.6-terra" => Some(ModelProfile {
            name: "GPT-5.6 Terra".into(),
            family: "gpt-5.6-terra".into(),
            description: Some("Balanced GPT-5.6 tier for everyday work. Performance competitive with GPT-5.5 at roughly half the cost.".into()),
            release_date: Some("2026-07-09".into()),
            last_updated: Some("2026-07-09".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2026-02-16".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 2.50,
                output: 15.00,
                cache_read: Some(0.25),
                cache_write: Some(3.125),
                cost_tiers: vec![CostTier {
                    above_tokens: 272_000,
                    input: 5.00,
                    output: 22.50,
                    cache_read: Some(0.50),
                    cache_write: Some(6.25),
                }],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt55()),
            speed: Some(speed_flex_priority()),
            verbosity: Some(verbosity_standard()),
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.6-luna" => Some(ModelProfile {
            name: "GPT-5.6 Luna".into(),
            family: "gpt-5.6-luna".into(),
            description: Some("Fastest, most cost-efficient GPT-5.6 tier. Built for high-volume, latency-sensitive work: classification, extraction, routing, and first-pass drafting.".into()),
            release_date: Some("2026-07-09".into()),
            last_updated: Some("2026-07-09".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2026-02-16".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.00,
                output: 6.00,
                cache_read: Some(0.10),
                cache_write: Some(1.25),
                cost_tiers: vec![CostTier {
                    above_tokens: 272_000,
                    input: 2.00,
                    output: 9.00,
                    cache_read: Some(0.20),
                    cache_write: Some(2.5),
                }],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt55()),
            speed: Some(speed_flex_priority()),
            verbosity: Some(verbosity_standard()),
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.5 family: flagship reasoning models. Released 2026-04-23.
        // Flat pricing (no 200K context tiers, unlike 5.4).
        // Source: developers.openai.com/api/docs/models/gpt-5.5 and .../gpt-5.5-pro
        // (models.dev did not yet list these variants at the time of addition;
        // refresh once the models.dev entry appears).
        "gpt-5.5" => Some(ModelProfile {
            name: "GPT-5.5".into(),
            family: "gpt-5.5".into(),
            description: Some("Flagship reasoning model. Best for complex multi-step tasks, code generation, and deep analysis.".into()),
            release_date: Some("2026-04-23".into()),
            last_updated: Some("2026-04-23".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-12-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 5.00,
                output: 30.00,
                cache_read: Some(0.50),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt55()),
            speed: Some(speed_flex_priority()),
            verbosity: Some(verbosity_standard()),
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.5-pro" => Some(ModelProfile {
            name: "GPT-5.5 Pro".into(),
            family: "gpt-5.5-pro".into(),
            description: Some("Extended-thinking variant for the hardest problems. Trades speed for deeper reasoning on math, science, and complex code.".into()),
            release_date: Some("2026-04-23".into()),
            last_updated: Some("2026-04-23".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-12-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 30.00,
                output: 180.00,
                cache_read: None,
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52_pro()),
            speed: Some(speed_flex_only()),
            verbosity: None,
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5.4 family: reasoning models with 1.05M context, tool_search, native phases.
        // Released 2026-03-05 (5.4, 5.4-pro), 2026-03-17 (5.4-mini, 5.4-nano).
        // 5.4 and 5.4-pro have tiered pricing above 200K context tokens.
        "gpt-5.4" => Some(ModelProfile {
            name: "GPT-5.4".into(),
            family: "gpt-5.4".into(),
            description: Some("Flagship reasoning model with 1M+ context. Best for complex multi-step tasks, code generation, and deep analysis.".into()),
            release_date: Some("2026-03-05".into()),
            last_updated: Some("2026-03-05".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 2.50,
                output: 15.00,
                cache_read: Some(0.25),
                cache_write: None,
                cost_tiers: vec![CostTier {
                    above_tokens: 200_000,
                    input: 5.00,
                    output: 22.50,
                    cache_read: Some(0.50),
                    cache_write: None,
                }],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image, Modality::Pdf],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: Some(speed_flex_priority()),
            verbosity: None,
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.4-mini" => Some(ModelProfile {
            name: "GPT-5.4 mini".into(),
            family: "gpt-5.4-mini".into(),
            description: Some("Fast, cost-effective reasoning model. Balances strong performance with low latency for everyday tasks.".into()),
            release_date: Some("2026-03-17".into()),
            last_updated: Some("2026-03-17".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.75,
                output: 4.50,
                cache_read: Some(0.075),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 400_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: Some(speed_flex_priority()),
            verbosity: None,
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.4-nano" => Some(ModelProfile {
            name: "GPT-5.4 nano".into(),
            family: "gpt-5.4-nano".into(),
            description: Some("Smallest and cheapest GPT-5.4 variant. Ideal for high-volume, latency-sensitive workloads.".into()),
            release_date: Some("2026-03-17".into()),
            last_updated: Some("2026-03-17".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 0.20,
                output: 1.25,
                cache_read: Some(0.02),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 400_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: Some(speed_flex_only()),
            verbosity: None,
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.4-pro" => Some(ModelProfile {
            name: "GPT-5.4 Pro".into(),
            family: "gpt-5.4-pro".into(),
            description: Some("Extended-thinking variant for the hardest problems. Trades speed for deeper reasoning on math, science, and complex code.".into()),
            release_date: Some("2026-03-05".into()),
            last_updated: Some("2026-03-05".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: false,
            open_weights: false,
            cost: Some(ModelCost {
                input: 30.00,
                output: 180.00,
                cache_read: None,
                cache_write: None,
                cost_tiers: vec![CostTier {
                    above_tokens: 200_000,
                    input: 60.00,
                    output: 270.00,
                    cache_read: None,
                    cache_write: None,
                }],
            }),
            limits: Some(ModelLimits {
                context: 1_050_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52_pro()),
            speed: Some(speed_flex_only()),
            verbosity: None,
            tool_search: true,
            supported_parameters: Vec::new(),
            supports_phases: true,
            supports_server_compaction: false,
            decisions: None,
        }),

        // GPT-5 chat-latest models (point to latest chat-optimized versions)
        "gpt-5-chat-latest" => Some(ModelProfile {
            name: "GPT-5 Chat".into(),
            family: "gpt-5".into(),
            description: None,
            release_date: Some("2025-08-07".into()),
            last_updated: Some("2025-08-07".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-10-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.25,
                output: 10.00,
                cache_read: Some(0.125),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt5_pre51()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.1-chat-latest" => Some(ModelProfile {
            name: "GPT-5.1 Chat".into(),
            family: "gpt-5.1".into(),
            description: None,
            release_date: Some("2025-11-13".into()),
            last_updated: Some("2025-11-13".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-09-30".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.50,
                output: 12.00,
                cache_read: Some(0.15),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 128_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt51()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "gpt-5.2-chat-latest" => Some(ModelProfile {
            name: "GPT-5.2 Chat".into(),
            family: "gpt-5.2".into(),
            description: None,
            release_date: Some("2025-12-11".into()),
            last_updated: Some("2025-12-11".into()),
            attachment: true,
            reasoning: true,
            temperature: false,
            knowledge: Some("2025-08-31".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.75,
                output: 14.00,
                cache_read: Some(0.175),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 128_000,
                input: None,
                output: 16_384,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_gpt52()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        // Deep research models
        "o3-deep-research" => Some(ModelProfile {
            name: "o3 Deep Research".into(),
            family: "o3".into(),
            description: None,
            release_date: Some("2025-04-16".into()),
            last_updated: Some("2025-04-16".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 2.00,
                output: 8.00,
                cache_read: Some(1.00),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 200_000,
                input: None,
                output: 100_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_standard()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        "o4-mini-deep-research" => Some(ModelProfile {
            name: "o4 mini Deep Research".into(),
            family: "o4-mini".into(),
            description: None,
            release_date: Some("2025-04-16".into()),
            last_updated: Some("2025-04-16".into()),
            attachment: true,
            reasoning: true,
            temperature: true,
            knowledge: Some("2024-06-01".into()),
            tool_call: true,
            structured_output: true,
            open_weights: false,
            cost: Some(ModelCost {
                input: 1.10,
                output: 4.40,
                cache_read: Some(0.55),
                cache_write: None,
                cost_tiers: vec![],
            }),
            limits: Some(ModelLimits {
                context: 200_000,
                input: None,
                output: 100_000,
                max_media: None,
            }),
            modalities: Some(ModelModalities {
                input: vec![Modality::Text, Modality::Image],
                output: vec![Modality::Text],
            }),
            reasoning_effort: Some(reasoning_effort_standard()),
            speed: None,
            verbosity: None,
            tool_search: false,
            supported_parameters: Vec::new(),
            supports_phases: false,
            supports_server_compaction: false,
            decisions: None,
        }),

        _ => None,
    }
}