1use std::collections::HashMap;
7use std::sync::LazyLock;
8use tracing::warn;
9
10#[derive(Debug, Clone, Copy, PartialEq, Eq)]
12pub enum ModelType {
13 Reasoning,
15 Chat,
17 Embedding,
19 Moderation,
21}
22
23#[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 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 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 pub fn supports_temperature(&self, temperature: f32) -> bool {
51 match &self.supported_temperatures {
52 None => true, Some(temps) if temps.is_empty() => false, 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
76pub struct OpenAIModelRegistry {
81 models: HashMap<String, ModelCapabilities>,
82 pattern_mappings: HashMap<String, ModelType>,
83}
84
85impl OpenAIModelRegistry {
86 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 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 let supports_tools = !is_gpt5_mini && !is_o4_mini;
135 let supports_streaming = true;
136
137 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 let supported_temps = if model.starts_with("gpt-5.1") || model.starts_with("gpt-5.2") {
156 None } else if is_o_series || is_gpt5_series {
158 Some(vec![1.0]) } else {
160 None
161 };
162
163 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 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 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 let supports_tools =
232 model != "chatgpt-4o-latest" && !is_gpt41_nano_base && !is_audio && !is_search;
233
234 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 let supported_temps = if is_search { Some(vec![]) } else { None };
253
254 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 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 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 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 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 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 pub fn get_model_capabilities(&self, model_name: &str) -> ModelCapabilities {
462 if let Some(caps) = self.models.get(model_name) {
464 return caps.clone();
465 }
466
467 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 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 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 pub fn get_registered_models(&self) -> Vec<String> {
547 self.models.keys().cloned().collect()
548 }
549
550 pub fn register_model(&mut self, model_name: &str, capabilities: ModelCapabilities) {
552 self.models.insert(model_name.to_string(), capabilities);
553 }
554
555 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
567pub static MODEL_REGISTRY: LazyLock<OpenAIModelRegistry> = LazyLock::new(OpenAIModelRegistry::new);
569
570pub 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 #[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 #[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 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}