Skip to main content

mojentic/llm/gateways/
openai_model_registry.rs

1//! OpenAI Model Registry for managing model-specific configurations and capabilities.
2//!
3//! This module provides infrastructure for categorizing OpenAI models and managing
4//! their specific parameter requirements and capabilities.
5
6use std::collections::HashMap;
7use std::sync::LazyLock;
8use tracing::warn;
9
10/// Classification of OpenAI model types based on their capabilities and parameters.
11#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12pub enum ModelType {
13    /// Models like o1, o3 that use max_completion_tokens
14    Reasoning,
15    /// Standard chat models that use max_tokens
16    Chat,
17    /// Text embedding models
18    Embedding,
19    /// Content moderation models
20    Moderation,
21}
22
23/// Defines the capabilities and parameter requirements for a model.
24#[derive(Debug, Clone)]
25pub struct ModelCapabilities {
26    pub model_type: ModelType,
27    pub supports_tools: bool,
28    pub supports_streaming: bool,
29    pub supports_vision: bool,
30    pub max_context_tokens: Option<u32>,
31    pub max_output_tokens: Option<u32>,
32    /// None means all temperatures supported, empty vec means no temperature parameter allowed
33    pub supported_temperatures: Option<Vec<f32>>,
34    pub supports_chat_api: bool,
35    pub supports_completions_api: bool,
36    pub supports_responses_api: bool,
37}
38
39impl ModelCapabilities {
40    /// Get the correct parameter name for token limits based on model type.
41    pub fn get_token_limit_param(&self) -> &'static str {
42        if self.model_type == ModelType::Reasoning {
43            "max_completion_tokens"
44        } else {
45            "max_tokens"
46        }
47    }
48
49    /// Check if the model supports a specific temperature value.
50    pub fn supports_temperature(&self, temperature: f32) -> bool {
51        match &self.supported_temperatures {
52            None => true, // All temperatures supported if not restricted
53            Some(temps) if temps.is_empty() => false, // No temperature values supported
54            Some(temps) => temps.iter().any(|t| (*t - temperature).abs() < 0.01),
55        }
56    }
57}
58
59impl Default for ModelCapabilities {
60    fn default() -> Self {
61        Self {
62            model_type: ModelType::Chat,
63            supports_tools: true,
64            supports_streaming: true,
65            supports_vision: false,
66            max_context_tokens: None,
67            max_output_tokens: None,
68            supported_temperatures: None,
69            supports_chat_api: true,
70            supports_completions_api: false,
71            supports_responses_api: false,
72        }
73    }
74}
75
76/// Registry for managing OpenAI model configurations and capabilities.
77///
78/// This struct provides a centralized way to manage model-specific configurations,
79/// parameter mappings, and capabilities for OpenAI models.
80pub struct OpenAIModelRegistry {
81    models: HashMap<String, ModelCapabilities>,
82    pattern_mappings: HashMap<String, ModelType>,
83}
84
85impl OpenAIModelRegistry {
86    /// Create a new model registry with default models.
87    pub fn new() -> Self {
88        let mut registry = Self {
89            models: HashMap::new(),
90            pattern_mappings: HashMap::new(),
91        };
92        registry.initialize_default_models();
93        registry
94    }
95
96    fn initialize_default_models(&mut self) {
97        // Updated 2026-02-04 based on OpenAI API audit
98        // Reasoning Models (o1, o3, o4, gpt-5 series)
99        let reasoning_models = vec![
100            "o1",
101            "o1-2024-12-17",
102            "o3",
103            "o3-2025-04-16",
104            "o3-mini",
105            "o3-mini-2025-01-31",
106            "o4-mini",
107            "o4-mini-2025-04-16",
108            "gpt-5",
109            "gpt-5-2025-08-07",
110            "gpt-5-mini",
111            "gpt-5-mini-2025-08-07",
112            "gpt-5-nano",
113            "gpt-5-nano-2025-08-07",
114            "gpt-5-pro",
115            "gpt-5-pro-2025-10-06",
116            "gpt-5.1",
117            "gpt-5.1-2025-11-13",
118            "gpt-5.1-chat-latest",
119            "gpt-5.2",
120            "gpt-5.2-2025-12-11",
121            "gpt-5.2-chat-latest",
122        ];
123
124        for model in reasoning_models {
125            let is_gpt5_mini = model == "gpt-5-mini";
126            let is_o4_mini = model == "o4-mini";
127            let is_o_series =
128                model.starts_with("o1") || model.starts_with("o3") || model.starts_with("o4");
129            let is_gpt5_series = model.starts_with("gpt-5");
130            let is_mini_or_nano = model.contains("mini") || model.contains("nano");
131
132            // All reasoning models now support tools and streaming (audit 2026-02-04)
133            // Exceptions: gpt-5-mini (base) and o4-mini (base) do not support tools
134            let supports_tools = !is_gpt5_mini && !is_o4_mini;
135            let supports_streaming = true;
136
137            // Set context and output tokens based on model tier
138            let (context_tokens, output_tokens) = if is_gpt5_series {
139                if is_mini_or_nano {
140                    (200000, 32768)
141                } else {
142                    (300000, 50000)
143                }
144            } else {
145                (128000, 32768)
146            };
147
148            // Temperature restrictions based on model series (audit 2026-02-04)
149            // o1 series: temperature=1.0 only
150            // o3 series: temperature=1.0 only (was: no temperature)
151            // o4 series: temperature=1.0 only
152            // gpt-5 base/mini/nano/pro: temperature=1.0 only
153            // gpt-5.1*: all temperatures
154            // gpt-5.2*: all temperatures
155            let supported_temps = if model.starts_with("gpt-5.1") || model.starts_with("gpt-5.2") {
156                None // All temperatures supported
157            } else if is_o_series || is_gpt5_series {
158                Some(vec![1.0]) // Only temperature=1.0
159            } else {
160                None
161            };
162
163            // Endpoint support flags
164            let is_responses_only =
165                model.contains("pro") || model.contains("deep-research") || model == "gpt-5-codex";
166            let is_both_endpoint = model == "gpt-5.1" || model == "gpt-5.1-2025-11-13";
167
168            self.models.insert(
169                model.to_string(),
170                ModelCapabilities {
171                    model_type: ModelType::Reasoning,
172                    supports_tools,
173                    supports_streaming,
174                    supports_vision: false,
175                    max_context_tokens: Some(context_tokens),
176                    max_output_tokens: Some(output_tokens),
177                    supported_temperatures: supported_temps,
178                    supports_chat_api: !is_responses_only,
179                    supports_completions_api: is_both_endpoint,
180                    supports_responses_api: is_responses_only,
181                },
182            );
183        }
184
185        // Chat Models (GPT-4, GPT-4.1, and GPT-5 chat series)
186        let gpt4_and_newer_models = vec![
187            "chatgpt-4o-latest",
188            "gpt-4",
189            "gpt-4-0125-preview",
190            "gpt-4-0613",
191            "gpt-4-1106-preview",
192            "gpt-4-turbo",
193            "gpt-4-turbo-2024-04-09",
194            "gpt-4-turbo-preview",
195            "gpt-4.1",
196            "gpt-4.1-2025-04-14",
197            "gpt-4.1-mini",
198            "gpt-4.1-mini-2025-04-14",
199            "gpt-4.1-nano",
200            "gpt-4.1-nano-2025-04-14",
201            "gpt-4o",
202            "gpt-4o-2024-05-13",
203            "gpt-4o-2024-08-06",
204            "gpt-4o-2024-11-20",
205            "gpt-4o-audio-preview",
206            "gpt-4o-audio-preview-2024-12-17",
207            "gpt-4o-audio-preview-2025-06-03",
208            "gpt-4o-mini",
209            "gpt-4o-mini-2024-07-18",
210            "gpt-4o-mini-audio-preview",
211            "gpt-4o-mini-audio-preview-2024-12-17",
212            "gpt-4o-mini-search-preview",
213            "gpt-4o-mini-search-preview-2025-03-11",
214            "gpt-4o-search-preview",
215            "gpt-4o-search-preview-2025-03-11",
216            "gpt-5-chat-latest",
217            "gpt-5-search-api",
218            "gpt-5-search-api-2025-10-14",
219        ];
220
221        for model in gpt4_and_newer_models {
222            // Audit 2026-02-04: Keep vision=true for gpt-4o (probe limitation, not real capability change)
223            let vision_support = model.contains("gpt-4o");
224            let is_mini_or_nano = model.contains("mini") || model.contains("nano");
225            let is_audio = model.contains("audio-preview");
226            let is_search = model.contains("search");
227            let is_gpt41 = model.contains("gpt-4.1");
228            let is_gpt41_nano_base = model == "gpt-4.1-nano";
229
230            // Audit 2026-02-04: chatgpt-4o-latest, gpt-4.1-nano (base only), audio models, and search models don't support tools
231            let supports_tools =
232                model != "chatgpt-4o-latest" && !is_gpt41_nano_base && !is_audio && !is_search;
233
234            // Audio models don't support streaming (require audio modality)
235            let supports_streaming = !is_audio;
236
237            let (context_tokens, output_tokens) = if is_gpt41 {
238                if is_mini_or_nano {
239                    (128000, 16384)
240                } else {
241                    (200000, 32768)
242                }
243            } else if model.contains("gpt-4o") {
244                (128000, 16384)
245            } else if model.starts_with("gpt-5") {
246                (300000, 50000)
247            } else {
248                (32000, 8192)
249            };
250
251            // Search models don't allow temperature parameter
252            let supported_temps = if is_search { Some(vec![]) } else { None };
253
254            // Endpoint support flags
255            let is_both_endpoint = model == "gpt-4.1-nano"
256                || model == "gpt-4.1-nano-2025-04-14"
257                || model == "gpt-4o-mini"
258                || model == "gpt-4o-mini-2024-07-18";
259
260            self.models.insert(
261                model.to_string(),
262                ModelCapabilities {
263                    model_type: ModelType::Chat,
264                    supports_tools,
265                    supports_streaming,
266                    supports_vision: vision_support,
267                    max_context_tokens: Some(context_tokens),
268                    max_output_tokens: Some(output_tokens),
269                    supported_temperatures: supported_temps,
270                    supports_chat_api: true,
271                    supports_completions_api: is_both_endpoint,
272                    supports_responses_api: false,
273                },
274            );
275        }
276
277        // Chat Models (GPT-3.5 series)
278        let gpt35_models = vec![
279            "gpt-3.5-turbo",
280            "gpt-3.5-turbo-0125",
281            "gpt-3.5-turbo-1106",
282            "gpt-3.5-turbo-16k",
283            "gpt-3.5-turbo-instruct",
284            "gpt-3.5-turbo-instruct-0914",
285        ];
286
287        for model in gpt35_models {
288            let is_instruct = model.contains("instruct");
289
290            self.models.insert(
291                model.to_string(),
292                ModelCapabilities {
293                    model_type: ModelType::Chat,
294                    supports_tools: !is_instruct,
295                    supports_streaming: !is_instruct,
296                    supports_vision: false,
297                    max_context_tokens: Some(16385),
298                    max_output_tokens: Some(4096),
299                    supported_temperatures: None,
300                    supports_chat_api: !is_instruct,
301                    supports_completions_api: is_instruct,
302                    supports_responses_api: false,
303                },
304            );
305        }
306
307        // Embedding Models
308        let embedding_models = vec![
309            "text-embedding-3-large",
310            "text-embedding-3-small",
311            "text-embedding-ada-002",
312        ];
313
314        for model in embedding_models {
315            self.models.insert(
316                model.to_string(),
317                ModelCapabilities {
318                    model_type: ModelType::Embedding,
319                    supports_tools: false,
320                    supports_streaming: false,
321                    supports_vision: false,
322                    max_context_tokens: None,
323                    max_output_tokens: None,
324                    supported_temperatures: None,
325                    supports_chat_api: false,
326                    supports_completions_api: false,
327                    supports_responses_api: false,
328                },
329            );
330        }
331
332        // Legacy & Codex Models - completions-only and responses-only
333        self.models.insert(
334            "babbage-002".to_string(),
335            ModelCapabilities {
336                model_type: ModelType::Chat,
337                supports_tools: false,
338                supports_streaming: false,
339                supports_vision: false,
340                max_context_tokens: Some(16384),
341                max_output_tokens: Some(4096),
342                supported_temperatures: None,
343                supports_chat_api: false,
344                supports_completions_api: true,
345                supports_responses_api: false,
346            },
347        );
348        self.models.insert(
349            "davinci-002".to_string(),
350            ModelCapabilities {
351                model_type: ModelType::Chat,
352                supports_tools: false,
353                supports_streaming: false,
354                supports_vision: false,
355                max_context_tokens: Some(16384),
356                max_output_tokens: Some(4096),
357                supported_temperatures: None,
358                supports_chat_api: false,
359                supports_completions_api: true,
360                supports_responses_api: false,
361            },
362        );
363        self.models.insert(
364            "gpt-5.1-codex-mini".to_string(),
365            ModelCapabilities {
366                model_type: ModelType::Reasoning,
367                supports_tools: false,
368                supports_streaming: false,
369                supports_vision: false,
370                max_context_tokens: Some(200000),
371                max_output_tokens: Some(32768),
372                supported_temperatures: None,
373                supports_chat_api: false,
374                supports_completions_api: true,
375                supports_responses_api: false,
376            },
377        );
378        self.models.insert(
379            "codex-mini-latest".to_string(),
380            ModelCapabilities {
381                model_type: ModelType::Reasoning,
382                supports_tools: false,
383                supports_streaming: false,
384                supports_vision: false,
385                max_context_tokens: Some(200000),
386                max_output_tokens: Some(32768),
387                supported_temperatures: None,
388                supports_chat_api: false,
389                supports_completions_api: false,
390                supports_responses_api: true,
391            },
392        );
393
394        // GPT-5.4 and GPT-5.5 reasoning families (added 2026-05-21,
395        // verified against OpenAI developer docs).
396        //
397        // These are registered explicitly rather than via the reasoning
398        // loop above: that loop computes context/output token limits from
399        // the model name (300K/50K for gpt-5 base), which would produce
400        // wrong values for these models. GPT-5.4/5.5 expose a 1.05M context
401        // window (400K for mini/nano) with a 128K output cap.
402        //
403        // Common capabilities: support tools, streaming, and vision; accept
404        // only temperature 1.0; support the Chat Completions and Responses
405        // APIs but not the legacy Completions API.
406        let gpt54_and_55_models = vec![
407            ("gpt-5.4", 1_050_000_u32),
408            ("gpt-5.4-2026-03-05", 1_050_000),
409            ("gpt-5.4-mini", 400_000),
410            ("gpt-5.4-mini-2026-03-17", 400_000),
411            ("gpt-5.4-nano", 400_000),
412            ("gpt-5.4-nano-2026-03-17", 400_000),
413            ("gpt-5.5", 1_050_000),
414            ("gpt-5.5-2026-04-23", 1_050_000),
415            ("gpt-5.5-pro", 1_050_000),
416            ("gpt-5.5-pro-2026-04-23", 1_050_000),
417        ];
418
419        for (model, context_tokens) in gpt54_and_55_models {
420            self.models.insert(
421                model.to_string(),
422                ModelCapabilities {
423                    model_type: ModelType::Reasoning,
424                    supports_tools: true,
425                    supports_streaming: true,
426                    supports_vision: true,
427                    max_context_tokens: Some(context_tokens),
428                    max_output_tokens: Some(128_000),
429                    supported_temperatures: Some(vec![1.0]),
430                    supports_chat_api: true,
431                    supports_completions_api: false,
432                    supports_responses_api: true,
433                },
434            );
435        }
436
437        // Pattern mappings for unknown models
438        self.pattern_mappings.insert("o1".to_string(), ModelType::Reasoning);
439        self.pattern_mappings.insert("o3".to_string(), ModelType::Reasoning);
440        self.pattern_mappings.insert("o4".to_string(), ModelType::Reasoning);
441        self.pattern_mappings.insert("gpt-5.5".to_string(), ModelType::Reasoning);
442        self.pattern_mappings.insert("gpt-5.4".to_string(), ModelType::Reasoning);
443        self.pattern_mappings.insert("gpt-5.3".to_string(), ModelType::Reasoning);
444        self.pattern_mappings.insert("gpt-5.2".to_string(), ModelType::Reasoning);
445        self.pattern_mappings.insert("gpt-5.1".to_string(), ModelType::Reasoning);
446        self.pattern_mappings.insert("gpt-5".to_string(), ModelType::Reasoning);
447        self.pattern_mappings.insert("gpt-4".to_string(), ModelType::Chat);
448        self.pattern_mappings.insert("gpt-4.1".to_string(), ModelType::Chat);
449        self.pattern_mappings.insert("gpt-3.5".to_string(), ModelType::Chat);
450        self.pattern_mappings.insert("chatgpt".to_string(), ModelType::Chat);
451        self.pattern_mappings.insert("text-embedding".to_string(), ModelType::Embedding);
452        self.pattern_mappings
453            .insert("text-moderation".to_string(), ModelType::Moderation);
454    }
455
456    pub(crate) fn registered_context_window(&self, model: &str) -> Option<u32> {
457        self.models.get(model).and_then(|caps| caps.max_context_tokens)
458    }
459
460    /// Get the capabilities for a specific model.
461    pub fn get_model_capabilities(&self, model_name: &str) -> ModelCapabilities {
462        // Direct lookup first
463        if let Some(caps) = self.models.get(model_name) {
464            return caps.clone();
465        }
466
467        // Pattern matching for unknown models
468        let model_lower = model_name.to_lowercase();
469        for (pattern, model_type) in &self.pattern_mappings {
470            if model_lower.contains(pattern) {
471                warn!(
472                    model = model_name,
473                    pattern = pattern,
474                    inferred_type = ?model_type,
475                    "Using pattern matching for unknown model"
476                );
477                return self.get_default_capabilities_for_type(*model_type);
478            }
479        }
480
481        // Default to chat model if no pattern matches
482        warn!(model = model_name, "Unknown model, defaulting to chat model capabilities");
483        self.get_default_capabilities_for_type(ModelType::Chat)
484    }
485
486    fn get_default_capabilities_for_type(&self, model_type: ModelType) -> ModelCapabilities {
487        match model_type {
488            ModelType::Reasoning => ModelCapabilities {
489                model_type: ModelType::Reasoning,
490                supports_tools: false,
491                supports_streaming: false,
492                supports_vision: false,
493                max_context_tokens: None,
494                max_output_tokens: None,
495                supported_temperatures: None,
496                supports_chat_api: true,
497                supports_completions_api: false,
498                supports_responses_api: false,
499            },
500            ModelType::Chat => ModelCapabilities {
501                model_type: ModelType::Chat,
502                supports_tools: true,
503                supports_streaming: true,
504                supports_vision: false,
505                max_context_tokens: None,
506                max_output_tokens: None,
507                supported_temperatures: None,
508                supports_chat_api: true,
509                supports_completions_api: false,
510                supports_responses_api: false,
511            },
512            ModelType::Embedding => ModelCapabilities {
513                model_type: ModelType::Embedding,
514                supports_tools: false,
515                supports_streaming: false,
516                supports_vision: false,
517                max_context_tokens: None,
518                max_output_tokens: None,
519                supported_temperatures: None,
520                supports_chat_api: false,
521                supports_completions_api: false,
522                supports_responses_api: false,
523            },
524            ModelType::Moderation => ModelCapabilities {
525                model_type: ModelType::Moderation,
526                supports_tools: false,
527                supports_streaming: false,
528                supports_vision: false,
529                max_context_tokens: None,
530                max_output_tokens: None,
531                supported_temperatures: None,
532                supports_chat_api: false,
533                supports_completions_api: false,
534                supports_responses_api: false,
535            },
536        }
537    }
538
539    /// Check if a model is a reasoning model.
540    pub fn is_reasoning_model(&self, model_name: &str) -> bool {
541        let capabilities = self.get_model_capabilities(model_name);
542        capabilities.model_type == ModelType::Reasoning
543    }
544
545    /// Get a list of all explicitly registered models.
546    pub fn get_registered_models(&self) -> Vec<String> {
547        self.models.keys().cloned().collect()
548    }
549
550    /// Register a new model with its capabilities.
551    pub fn register_model(&mut self, model_name: &str, capabilities: ModelCapabilities) {
552        self.models.insert(model_name.to_string(), capabilities);
553    }
554
555    /// Register a pattern for inferring model types.
556    pub fn register_pattern(&mut self, pattern: &str, model_type: ModelType) {
557        self.pattern_mappings.insert(pattern.to_string(), model_type);
558    }
559}
560
561impl Default for OpenAIModelRegistry {
562    fn default() -> Self {
563        Self::new()
564    }
565}
566
567/// Global registry instance.
568pub static MODEL_REGISTRY: LazyLock<OpenAIModelRegistry> = LazyLock::new(OpenAIModelRegistry::new);
569
570/// Get the global OpenAI model registry instance.
571pub fn get_model_registry() -> &'static OpenAIModelRegistry {
572    &MODEL_REGISTRY
573}
574
575#[cfg(test)]
576mod tests {
577    use super::*;
578
579    #[test]
580    fn test_model_type_enum() {
581        assert_ne!(ModelType::Reasoning, ModelType::Chat);
582        assert_eq!(ModelType::Reasoning, ModelType::Reasoning);
583    }
584
585    #[test]
586    fn test_model_capabilities_default() {
587        let caps = ModelCapabilities::default();
588        assert_eq!(caps.model_type, ModelType::Chat);
589        assert!(caps.supports_tools);
590        assert!(caps.supports_streaming);
591        assert!(!caps.supports_vision);
592    }
593
594    #[test]
595    fn test_get_token_limit_param_reasoning() {
596        let caps = ModelCapabilities {
597            model_type: ModelType::Reasoning,
598            ..Default::default()
599        };
600        assert_eq!(caps.get_token_limit_param(), "max_completion_tokens");
601    }
602
603    #[test]
604    fn test_get_token_limit_param_chat() {
605        let caps = ModelCapabilities {
606            model_type: ModelType::Chat,
607            ..Default::default()
608        };
609        assert_eq!(caps.get_token_limit_param(), "max_tokens");
610    }
611
612    #[test]
613    fn test_supports_temperature_unrestricted() {
614        let caps = ModelCapabilities {
615            supported_temperatures: None,
616            ..Default::default()
617        };
618        assert!(caps.supports_temperature(0.5));
619        assert!(caps.supports_temperature(1.0));
620        assert!(caps.supports_temperature(0.0));
621    }
622
623    #[test]
624    fn test_supports_temperature_restricted() {
625        let caps = ModelCapabilities {
626            supported_temperatures: Some(vec![1.0]),
627            ..Default::default()
628        };
629        assert!(caps.supports_temperature(1.0));
630        assert!(!caps.supports_temperature(0.5));
631    }
632
633    #[test]
634    fn test_supports_temperature_none_allowed() {
635        let caps = ModelCapabilities {
636            supported_temperatures: Some(vec![]),
637            ..Default::default()
638        };
639        assert!(!caps.supports_temperature(1.0));
640        assert!(!caps.supports_temperature(0.5));
641    }
642
643    #[test]
644    fn test_registry_new() {
645        let registry = OpenAIModelRegistry::new();
646        assert!(!registry.models.is_empty());
647        assert!(!registry.pattern_mappings.is_empty());
648    }
649
650    #[test]
651    fn test_get_known_model_capabilities() {
652        let registry = OpenAIModelRegistry::new();
653        let caps = registry.get_model_capabilities("gpt-4");
654        assert_eq!(caps.model_type, ModelType::Chat);
655        assert!(caps.supports_tools);
656    }
657
658    #[test]
659    fn test_get_reasoning_model_capabilities() {
660        let registry = OpenAIModelRegistry::new();
661        let caps = registry.get_model_capabilities("o1");
662        assert_eq!(caps.model_type, ModelType::Reasoning);
663    }
664
665    #[test]
666    fn test_get_unknown_model_pattern_matching() {
667        let registry = OpenAIModelRegistry::new();
668        let caps = registry.get_model_capabilities("gpt-4-unknown-version");
669        assert_eq!(caps.model_type, ModelType::Chat);
670    }
671
672    #[test]
673    fn test_get_unknown_model_default() {
674        let registry = OpenAIModelRegistry::new();
675        let caps = registry.get_model_capabilities("completely-unknown-model");
676        assert_eq!(caps.model_type, ModelType::Chat);
677    }
678
679    #[test]
680    fn test_is_reasoning_model() {
681        let registry = OpenAIModelRegistry::new();
682        assert!(registry.is_reasoning_model("o1"));
683        assert!(registry.is_reasoning_model("o3-mini"));
684        assert!(!registry.is_reasoning_model("gpt-4"));
685    }
686
687    #[test]
688    fn test_get_registered_models() {
689        let registry = OpenAIModelRegistry::new();
690        let models = registry.get_registered_models();
691        assert!(models.contains(&"gpt-4".to_string()));
692        assert!(models.contains(&"o1".to_string()));
693    }
694
695    #[test]
696    fn test_register_model() {
697        let mut registry = OpenAIModelRegistry::new();
698        registry.register_model(
699            "custom-model",
700            ModelCapabilities {
701                model_type: ModelType::Chat,
702                supports_tools: false,
703                ..Default::default()
704            },
705        );
706        let caps = registry.get_model_capabilities("custom-model");
707        assert!(!caps.supports_tools);
708    }
709
710    #[test]
711    fn test_register_pattern() {
712        let mut registry = OpenAIModelRegistry::new();
713        registry.register_pattern("custom-pattern", ModelType::Embedding);
714        let caps = registry.get_model_capabilities("my-custom-pattern-model");
715        assert_eq!(caps.model_type, ModelType::Embedding);
716    }
717
718    #[test]
719    fn test_global_registry() {
720        let registry = get_model_registry();
721        let caps = registry.get_model_capabilities("gpt-4");
722        assert_eq!(caps.model_type, ModelType::Chat);
723    }
724
725    #[test]
726    fn test_embedding_models() {
727        let registry = OpenAIModelRegistry::new();
728        let caps = registry.get_model_capabilities("text-embedding-3-large");
729        assert_eq!(caps.model_type, ModelType::Embedding);
730        assert!(!caps.supports_tools);
731        assert!(!caps.supports_streaming);
732    }
733
734    #[test]
735    fn test_gpt35_instruct_no_tools() {
736        let registry = OpenAIModelRegistry::new();
737        let caps = registry.get_model_capabilities("gpt-3.5-turbo-instruct");
738        assert_eq!(caps.model_type, ModelType::Chat);
739        assert!(!caps.supports_tools);
740        assert!(!caps.supports_streaming);
741    }
742
743    // Tests for audit 2026-02-04 changes
744
745    #[test]
746    fn test_o1_supports_tools_and_streaming() {
747        let registry = OpenAIModelRegistry::new();
748        let caps = registry.get_model_capabilities("o1");
749        assert!(caps.supports_tools);
750        assert!(caps.supports_streaming);
751        assert_eq!(caps.supported_temperatures, Some(vec![1.0]));
752    }
753
754    #[test]
755    fn test_o3_supports_tools_and_streaming_and_temperature() {
756        let registry = OpenAIModelRegistry::new();
757        let caps = registry.get_model_capabilities("o3");
758        assert!(caps.supports_tools);
759        assert!(caps.supports_streaming);
760        assert_eq!(caps.supported_temperatures, Some(vec![1.0]));
761    }
762
763    #[test]
764    fn test_o3_mini_supports_tools_and_streaming() {
765        let registry = OpenAIModelRegistry::new();
766        let caps = registry.get_model_capabilities("o3-mini");
767        assert!(caps.supports_tools);
768        assert!(caps.supports_streaming);
769        assert_eq!(caps.supported_temperatures, Some(vec![1.0]));
770    }
771
772    #[test]
773    fn test_o4_mini_no_tools_but_supports_streaming() {
774        let registry = OpenAIModelRegistry::new();
775        let caps = registry.get_model_capabilities("o4-mini");
776        assert!(!caps.supports_tools);
777        assert!(caps.supports_streaming);
778    }
779
780    #[test]
781    fn test_o4_mini_dated_supports_tools() {
782        let registry = OpenAIModelRegistry::new();
783        let caps = registry.get_model_capabilities("o4-mini-2025-04-16");
784        assert!(caps.supports_tools);
785        assert!(caps.supports_streaming);
786    }
787
788    #[test]
789    fn test_chatgpt_4o_latest_no_tools() {
790        let registry = OpenAIModelRegistry::new();
791        let caps = registry.get_model_capabilities("chatgpt-4o-latest");
792        assert!(!caps.supports_tools);
793        assert!(caps.supports_streaming);
794    }
795
796    #[test]
797    fn test_gpt41_nano_base_no_tools() {
798        let registry = OpenAIModelRegistry::new();
799        let caps = registry.get_model_capabilities("gpt-4.1-nano");
800        assert!(!caps.supports_tools);
801    }
802
803    #[test]
804    fn test_gpt41_nano_dated_has_tools() {
805        let registry = OpenAIModelRegistry::new();
806        let caps = registry.get_model_capabilities("gpt-4.1-nano-2025-04-14");
807        assert!(caps.supports_tools);
808    }
809
810    #[test]
811    fn test_audio_preview_no_tools_no_streaming() {
812        let registry = OpenAIModelRegistry::new();
813        let caps = registry.get_model_capabilities("gpt-4o-audio-preview");
814        assert!(!caps.supports_tools);
815        assert!(!caps.supports_streaming);
816    }
817
818    #[test]
819    fn test_search_preview_no_tools_no_temperature() {
820        let registry = OpenAIModelRegistry::new();
821        let caps = registry.get_model_capabilities("gpt-4o-search-preview");
822        assert!(!caps.supports_tools);
823        assert!(caps.supports_streaming);
824        assert_eq!(caps.supported_temperatures, Some(vec![]));
825    }
826
827    #[test]
828    fn test_gpt5_chat_latest_is_chat_type() {
829        let registry = OpenAIModelRegistry::new();
830        let caps = registry.get_model_capabilities("gpt-5-chat-latest");
831        assert_eq!(caps.model_type, ModelType::Chat);
832        assert!(caps.supports_tools);
833        assert_eq!(caps.supported_temperatures, None);
834    }
835
836    #[test]
837    fn test_gpt5_mini_base_no_tools() {
838        let registry = OpenAIModelRegistry::new();
839        let caps = registry.get_model_capabilities("gpt-5-mini");
840        assert!(!caps.supports_tools);
841    }
842
843    #[test]
844    fn test_gpt5_mini_dated_has_tools() {
845        let registry = OpenAIModelRegistry::new();
846        let caps = registry.get_model_capabilities("gpt-5-mini-2025-08-07");
847        assert!(caps.supports_tools);
848    }
849
850    #[test]
851    fn test_gpt5_pro_exists() {
852        let registry = OpenAIModelRegistry::new();
853        let caps = registry.get_model_capabilities("gpt-5-pro");
854        assert_eq!(caps.model_type, ModelType::Reasoning);
855        assert!(caps.supports_tools);
856    }
857
858    #[test]
859    fn test_gpt5_search_api_no_tools_no_temperature() {
860        let registry = OpenAIModelRegistry::new();
861        let caps = registry.get_model_capabilities("gpt-5-search-api");
862        assert_eq!(caps.model_type, ModelType::Chat);
863        assert!(!caps.supports_tools);
864        assert_eq!(caps.supported_temperatures, Some(vec![]));
865    }
866
867    #[test]
868    fn test_gpt51_all_temperatures() {
869        let registry = OpenAIModelRegistry::new();
870        let caps = registry.get_model_capabilities("gpt-5.1");
871        assert_eq!(caps.model_type, ModelType::Reasoning);
872        assert_eq!(caps.supported_temperatures, None);
873    }
874
875    #[test]
876    fn test_gpt52_all_temperatures() {
877        let registry = OpenAIModelRegistry::new();
878        let caps = registry.get_model_capabilities("gpt-5.2");
879        assert_eq!(caps.model_type, ModelType::Reasoning);
880        assert_eq!(caps.supported_temperatures, None);
881    }
882
883    #[test]
884    fn test_gpt51_pattern_matching() {
885        let registry = OpenAIModelRegistry::new();
886        let caps = registry.get_model_capabilities("gpt-5.1-unknown");
887        assert_eq!(caps.model_type, ModelType::Reasoning);
888    }
889
890    #[test]
891    fn test_gpt52_pattern_matching() {
892        let registry = OpenAIModelRegistry::new();
893        let caps = registry.get_model_capabilities("gpt-5.2-unknown");
894        assert_eq!(caps.model_type, ModelType::Reasoning);
895    }
896
897    // Tests for GPT-5.4 and GPT-5.5 families (added 2026-05-21)
898
899    #[test]
900    fn test_gpt54_base_capabilities() {
901        let registry = OpenAIModelRegistry::new();
902        let caps = registry.get_model_capabilities("gpt-5.4");
903        assert_eq!(caps.model_type, ModelType::Reasoning);
904        assert_eq!(caps.max_context_tokens, Some(1_050_000));
905        assert_eq!(caps.max_output_tokens, Some(128_000));
906        assert!(caps.supports_tools);
907        assert!(caps.supports_streaming);
908        assert!(caps.supports_vision);
909        assert_eq!(caps.supported_temperatures, Some(vec![1.0]));
910        assert!(caps.supports_chat_api);
911        assert!(!caps.supports_completions_api);
912        assert!(caps.supports_responses_api);
913    }
914
915    #[test]
916    fn test_gpt54_dated_capabilities() {
917        let registry = OpenAIModelRegistry::new();
918        let caps = registry.get_model_capabilities("gpt-5.4-2026-03-05");
919        assert_eq!(caps.model_type, ModelType::Reasoning);
920        assert_eq!(caps.max_context_tokens, Some(1_050_000));
921        assert_eq!(caps.max_output_tokens, Some(128_000));
922    }
923
924    #[test]
925    fn test_gpt54_mini_capabilities() {
926        let registry = OpenAIModelRegistry::new();
927        let caps = registry.get_model_capabilities("gpt-5.4-mini");
928        assert_eq!(caps.model_type, ModelType::Reasoning);
929        assert_eq!(caps.max_context_tokens, Some(400_000));
930        assert_eq!(caps.max_output_tokens, Some(128_000));
931        assert!(caps.supports_tools);
932        assert!(caps.supports_vision);
933    }
934
935    #[test]
936    fn test_gpt54_mini_dated_capabilities() {
937        let registry = OpenAIModelRegistry::new();
938        let caps = registry.get_model_capabilities("gpt-5.4-mini-2026-03-17");
939        assert_eq!(caps.model_type, ModelType::Reasoning);
940        assert_eq!(caps.max_context_tokens, Some(400_000));
941        assert_eq!(caps.max_output_tokens, Some(128_000));
942    }
943
944    #[test]
945    fn test_gpt54_nano_capabilities() {
946        let registry = OpenAIModelRegistry::new();
947        let caps = registry.get_model_capabilities("gpt-5.4-nano");
948        assert_eq!(caps.model_type, ModelType::Reasoning);
949        assert_eq!(caps.max_context_tokens, Some(400_000));
950        assert_eq!(caps.max_output_tokens, Some(128_000));
951    }
952
953    #[test]
954    fn test_gpt54_nano_dated_capabilities() {
955        let registry = OpenAIModelRegistry::new();
956        let caps = registry.get_model_capabilities("gpt-5.4-nano-2026-03-17");
957        assert_eq!(caps.model_type, ModelType::Reasoning);
958        assert_eq!(caps.max_context_tokens, Some(400_000));
959        assert_eq!(caps.max_output_tokens, Some(128_000));
960    }
961
962    #[test]
963    fn test_gpt55_base_capabilities() {
964        let registry = OpenAIModelRegistry::new();
965        let caps = registry.get_model_capabilities("gpt-5.5");
966        assert_eq!(caps.model_type, ModelType::Reasoning);
967        assert_eq!(caps.max_context_tokens, Some(1_050_000));
968        assert_eq!(caps.max_output_tokens, Some(128_000));
969        assert!(caps.supports_tools);
970        assert!(caps.supports_streaming);
971        assert!(caps.supports_vision);
972        assert_eq!(caps.supported_temperatures, Some(vec![1.0]));
973        assert!(caps.supports_chat_api);
974        assert!(!caps.supports_completions_api);
975        assert!(caps.supports_responses_api);
976    }
977
978    #[test]
979    fn test_gpt55_dated_capabilities() {
980        let registry = OpenAIModelRegistry::new();
981        let caps = registry.get_model_capabilities("gpt-5.5-2026-04-23");
982        assert_eq!(caps.model_type, ModelType::Reasoning);
983        assert_eq!(caps.max_context_tokens, Some(1_050_000));
984        assert_eq!(caps.max_output_tokens, Some(128_000));
985    }
986
987    #[test]
988    fn test_gpt55_pro_capabilities() {
989        let registry = OpenAIModelRegistry::new();
990        let caps = registry.get_model_capabilities("gpt-5.5-pro");
991        assert_eq!(caps.model_type, ModelType::Reasoning);
992        assert_eq!(caps.max_context_tokens, Some(1_050_000));
993        assert_eq!(caps.max_output_tokens, Some(128_000));
994        assert!(caps.supports_tools);
995        assert!(caps.supports_vision);
996        assert!(caps.supports_responses_api);
997    }
998
999    #[test]
1000    fn test_gpt55_pro_dated_capabilities() {
1001        let registry = OpenAIModelRegistry::new();
1002        let caps = registry.get_model_capabilities("gpt-5.5-pro-2026-04-23");
1003        assert_eq!(caps.model_type, ModelType::Reasoning);
1004        assert_eq!(caps.max_context_tokens, Some(1_050_000));
1005        assert_eq!(caps.max_output_tokens, Some(128_000));
1006    }
1007
1008    #[test]
1009    fn test_gpt54_uses_completion_token_param() {
1010        let registry = OpenAIModelRegistry::new();
1011        let caps = registry.get_model_capabilities("gpt-5.4");
1012        assert_eq!(caps.get_token_limit_param(), "max_completion_tokens");
1013    }
1014
1015    #[test]
1016    fn test_gpt54_pattern_matching() {
1017        let registry = OpenAIModelRegistry::new();
1018        let caps = registry.get_model_capabilities("gpt-5.4-unknown-variant");
1019        assert_eq!(caps.model_type, ModelType::Reasoning);
1020    }
1021
1022    #[test]
1023    fn test_gpt55_pattern_matching() {
1024        let registry = OpenAIModelRegistry::new();
1025        let caps = registry.get_model_capabilities("gpt-5.5-unknown-variant");
1026        assert_eq!(caps.model_type, ModelType::Reasoning);
1027    }
1028
1029    #[test]
1030    fn test_gpt53_pattern_matching() {
1031        let registry = OpenAIModelRegistry::new();
1032        let caps = registry.get_model_capabilities("gpt-5.3-future-model");
1033        assert_eq!(caps.model_type, ModelType::Reasoning);
1034    }
1035
1036    #[test]
1037    fn test_deprecated_models_removed() {
1038        let registry = OpenAIModelRegistry::new();
1039        let models = registry.get_registered_models();
1040
1041        // Verify removed models are not in registry
1042        assert!(!models.contains(&"o1-mini".to_string()));
1043        assert!(!models.contains(&"o1-mini-2024-09-12".to_string()));
1044        assert!(!models.contains(&"o1-pro".to_string()));
1045        assert!(!models.contains(&"o3-pro".to_string()));
1046        assert!(!models.contains(&"o3-deep-research".to_string()));
1047        assert!(!models.contains(&"o4-mini-deep-research".to_string()));
1048        assert!(!models.contains(&"gpt-4o-audio-preview-2024-10-01".to_string()));
1049        assert!(!models.contains(&"gpt-5-codex".to_string()));
1050    }
1051
1052    #[test]
1053    fn test_chat_only_model_endpoint_flags() {
1054        let registry = OpenAIModelRegistry::new();
1055        let caps = registry.get_model_capabilities("gpt-4");
1056        assert!(caps.supports_chat_api);
1057        assert!(!caps.supports_completions_api);
1058        assert!(!caps.supports_responses_api);
1059    }
1060
1061    #[test]
1062    fn test_both_endpoint_model_flags() {
1063        let registry = OpenAIModelRegistry::new();
1064        let caps = registry.get_model_capabilities("gpt-4o-mini");
1065        assert!(caps.supports_chat_api);
1066        assert!(caps.supports_completions_api);
1067        assert!(!caps.supports_responses_api);
1068    }
1069
1070    #[test]
1071    fn test_completions_only_model_flags() {
1072        let registry = OpenAIModelRegistry::new();
1073        let caps = registry.get_model_capabilities("gpt-3.5-turbo-instruct");
1074        assert!(!caps.supports_chat_api);
1075        assert!(caps.supports_completions_api);
1076        assert!(!caps.supports_responses_api);
1077    }
1078
1079    #[test]
1080    fn test_responses_only_model_flags() {
1081        let registry = OpenAIModelRegistry::new();
1082        let caps = registry.get_model_capabilities("gpt-5-pro");
1083        assert!(!caps.supports_chat_api);
1084        assert!(!caps.supports_completions_api);
1085        assert!(caps.supports_responses_api);
1086    }
1087
1088    #[test]
1089    fn test_legacy_completions_model_flags() {
1090        let registry = OpenAIModelRegistry::new();
1091        let caps = registry.get_model_capabilities("babbage-002");
1092        assert!(!caps.supports_chat_api);
1093        assert!(caps.supports_completions_api);
1094        assert!(!caps.supports_responses_api);
1095    }
1096
1097    #[test]
1098    fn test_embedding_model_endpoint_flags() {
1099        let registry = OpenAIModelRegistry::new();
1100        let caps = registry.get_model_capabilities("text-embedding-3-large");
1101        assert!(!caps.supports_chat_api);
1102        assert!(!caps.supports_completions_api);
1103        assert!(!caps.supports_responses_api);
1104    }
1105
1106    #[test]
1107    fn test_codex_mini_latest_responses_only() {
1108        let registry = OpenAIModelRegistry::new();
1109        let caps = registry.get_model_capabilities("codex-mini-latest");
1110        assert!(!caps.supports_chat_api);
1111        assert!(!caps.supports_completions_api);
1112        assert!(caps.supports_responses_api);
1113    }
1114
1115    #[test]
1116    fn test_gpt51_both_chat_and_completions() {
1117        let registry = OpenAIModelRegistry::new();
1118        let caps = registry.get_model_capabilities("gpt-5.1");
1119        assert!(caps.supports_chat_api);
1120        assert!(caps.supports_completions_api);
1121        assert!(!caps.supports_responses_api);
1122    }
1123
1124    #[test]
1125    fn test_default_capabilities_include_endpoint_flags() {
1126        let registry = OpenAIModelRegistry::new();
1127        let caps = registry.get_model_capabilities("completely-unknown-model-xyz");
1128        assert!(caps.supports_chat_api);
1129        assert!(!caps.supports_completions_api);
1130        assert!(!caps.supports_responses_api);
1131    }
1132}