vtcode_config/models/model_id/
capabilities.rs

1use crate::models::Provider;
2
3use super::ModelId;
4
5#[cfg(not(docsrs))]
6#[allow(dead_code)]
7mod capability_generated {
8    include!(concat!(env!("OUT_DIR"), "/model_capabilities.rs"));
9}
10
11#[cfg(docsrs)]
12#[allow(dead_code)]
13mod capability_generated {
14    #[derive(Clone, Copy)]
15    pub struct Pricing {
16        pub input: Option<f64>,
17        pub output: Option<f64>,
18        pub cache_read: Option<f64>,
19        pub cache_write: Option<f64>,
20    }
21
22    #[derive(Clone, Copy)]
23    pub struct Entry {
24        pub provider: &'static str,
25        pub id: &'static str,
26        pub display_name: &'static str,
27        pub description: &'static str,
28        pub context_window: usize,
29        pub max_output_tokens: Option<usize>,
30        pub reasoning: bool,
31        pub tool_call: bool,
32        pub vision: bool,
33        pub input_modalities: &'static [&'static str],
34        pub caching: bool,
35        pub structured_output: bool,
36        pub pricing: Pricing,
37    }
38
39    pub const ENTRIES: &[Entry] = &[];
40    pub const PROVIDERS: &[&str] = &[];
41
42    pub fn metadata_for(_provider: &str, _id: &str) -> Option<Entry> {
43        None
44    }
45
46    pub fn models_for_provider(_provider: &str) -> Option<&'static [&'static str]> {
47        None
48    }
49}
50
51/// Catalog metadata generated from `docs/models.json`.
52#[derive(Clone, Copy, Debug, PartialEq)]
53pub struct ModelPricing {
54    pub input: Option<f64>,
55    pub output: Option<f64>,
56    pub cache_read: Option<f64>,
57    pub cache_write: Option<f64>,
58}
59
60#[derive(Clone, Copy, Debug, PartialEq)]
61pub struct ModelCatalogEntry {
62    pub provider: &'static str,
63    pub id: &'static str,
64    pub display_name: &'static str,
65    pub description: &'static str,
66    pub context_window: usize,
67    pub max_output_tokens: Option<usize>,
68    pub reasoning: bool,
69    pub tool_call: bool,
70    pub vision: bool,
71    pub input_modalities: &'static [&'static str],
72    pub caching: bool,
73    pub structured_output: bool,
74    pub pricing: ModelPricing,
75}
76
77fn catalog_provider_key(provider: &str) -> &str {
78    if provider.eq_ignore_ascii_case("google") || provider.eq_ignore_ascii_case("gemini") {
79        "gemini"
80    } else if provider.eq_ignore_ascii_case("openai") {
81        "openai"
82    } else if provider.eq_ignore_ascii_case("anthropic") {
83        "anthropic"
84    } else if provider.eq_ignore_ascii_case("deepseek") {
85        "deepseek"
86    } else if provider.eq_ignore_ascii_case("openrouter") {
87        "openrouter"
88    } else if provider.eq_ignore_ascii_case("ollama") {
89        "ollama"
90    } else if provider.eq_ignore_ascii_case("lmstudio") {
91        "lmstudio"
92    } else if provider.eq_ignore_ascii_case("moonshot") {
93        "moonshot"
94    } else if provider.eq_ignore_ascii_case("zai") {
95        "zai"
96    } else if provider.eq_ignore_ascii_case("minimax") {
97        "minimax"
98    } else if provider.eq_ignore_ascii_case("huggingface") {
99        "huggingface"
100    } else {
101        provider
102    }
103}
104
105fn capability_provider_key(provider: Provider) -> &'static str {
106    match provider {
107        Provider::Gemini => "gemini",
108        Provider::OpenAI => "openai",
109        Provider::Anthropic => "anthropic",
110        Provider::Copilot => "copilot",
111        Provider::DeepSeek => "deepseek",
112        Provider::OpenRouter => "openrouter",
113        Provider::Ollama => "ollama",
114        Provider::LmStudio => "lmstudio",
115        Provider::Moonshot => "moonshot",
116        Provider::ZAI => "zai",
117        Provider::Minimax => "minimax",
118        Provider::MiMo => "mimo",
119        Provider::Mistral => "mistral",
120        Provider::HuggingFace => "huggingface",
121        Provider::OpenCodeZen => "opencode-zen",
122        Provider::OpenCodeGo => "opencode-go",
123        Provider::Qwen => "qwen",
124    }
125}
126
127fn generated_catalog_entry(provider: &str, id: &str) -> Option<ModelCatalogEntry> {
128    capability_generated::metadata_for(catalog_provider_key(provider), id).map(|entry| {
129        ModelCatalogEntry {
130            provider: entry.provider,
131            id: entry.id,
132            display_name: entry.display_name,
133            description: entry.description,
134            context_window: entry.context_window,
135            max_output_tokens: entry.max_output_tokens,
136            reasoning: entry.reasoning,
137            tool_call: entry.tool_call,
138            vision: entry.vision,
139            input_modalities: entry.input_modalities,
140            caching: entry.caching,
141            structured_output: entry.structured_output,
142            pricing: ModelPricing {
143                input: entry.pricing.input,
144                output: entry.pricing.output,
145                cache_read: entry.pricing.cache_read,
146                cache_write: entry.pricing.cache_write,
147            },
148        }
149    })
150}
151
152pub fn model_catalog_entry(provider: &str, id: &str) -> Option<ModelCatalogEntry> {
153    generated_catalog_entry(provider, id)
154}
155
156pub fn supported_models_for_provider(provider: &str) -> Option<&'static [&'static str]> {
157    capability_generated::models_for_provider(catalog_provider_key(provider))
158}
159
160pub fn catalog_provider_keys() -> &'static [&'static str] {
161    capability_generated::PROVIDERS
162}
163
164impl ModelId {
165    fn generated_capabilities(&self) -> Option<ModelCatalogEntry> {
166        generated_catalog_entry(capability_provider_key(self.provider()), self.as_str())
167    }
168
169    /// Preferred built-in lightweight sibling or lower-tier fallback for this model.
170    pub fn preferred_lightweight_variant(&self) -> Option<Self> {
171        match self {
172            ModelId::Gemini31ProPreview | ModelId::Gemini31ProPreviewCustomTools => {
173                Some(ModelId::Gemini31FlashLitePreview)
174            }
175            ModelId::GPT55 | ModelId::GPT54 | ModelId::GPT54Pro => Some(ModelId::GPT54Mini),
176            ModelId::OpenCodeZenGPT54 => Some(ModelId::OpenCodeZenGPT54Mini),
177            ModelId::GPT52
178            | ModelId::GPT52Codex
179            | ModelId::GPT53Codex
180            | ModelId::GPT51Codex
181            | ModelId::GPT51CodexMax
182            | ModelId::GPT5
183            | ModelId::GPT5Codex => Some(ModelId::GPT5Mini),
184            ModelId::ClaudeOpus47
185            | ModelId::ClaudeOpus46
186            | ModelId::ClaudeSonnet46
187            | ModelId::ClaudeMythosPreview => Some(ModelId::ClaudeHaiku45),
188            ModelId::CopilotGPT54 => Some(ModelId::CopilotGPT54Mini),
189            ModelId::CopilotGPT52Codex | ModelId::CopilotGPT51CodexMax => {
190                Some(ModelId::CopilotGPT54Mini)
191            }
192            ModelId::DeepSeekV4Pro => Some(ModelId::DeepSeekV4Flash),
193            ModelId::HuggingFaceDeepseekV4ProTogether => {
194                Some(ModelId::HuggingFaceDeepseekV4FlashNovita)
195            }
196            ModelId::OllamaDeepseekV4ProCloud => Some(ModelId::OllamaDeepseekV4FlashCloud),
197            ModelId::ZaiGlm51 => Some(ModelId::ZaiGlm5),
198            ModelId::MinimaxM27 => Some(ModelId::MinimaxM25),
199            ModelId::OpenCodeGoMinimaxM27 => Some(ModelId::OpenCodeGoMinimaxM25),
200            _ => None,
201        }
202    }
203
204    /// Attempt to find a non-reasoning variant for this model.
205    pub fn non_reasoning_variant(&self) -> Option<Self> {
206        if let Some(meta) = self.openrouter_metadata() {
207            if !meta.reasoning {
208                return None;
209            }
210
211            let vendor = meta.vendor;
212            let mut candidates: Vec<Self> = Self::openrouter_vendor_groups()
213                .into_iter()
214                .find(|(candidate_vendor, _)| *candidate_vendor == vendor)
215                .map(|(_, models)| {
216                    models
217                        .iter()
218                        .copied()
219                        .filter(|candidate| candidate != self)
220                        .filter(|candidate| {
221                            candidate
222                                .openrouter_metadata()
223                                .map(|other| !other.reasoning)
224                                .unwrap_or(false)
225                        })
226                        .collect()
227                })
228                .unwrap_or_default();
229
230            if candidates.is_empty() {
231                return None;
232            }
233
234            candidates.sort_by_key(|candidate| {
235                candidate
236                    .openrouter_metadata()
237                    .map(|data| (!data.efficient, data.display))
238                    .unwrap_or((true, ""))
239            });
240
241            return candidates.into_iter().next();
242        }
243
244        let direct = match self {
245            ModelId::Gemini31ProPreview
246            | ModelId::Gemini31ProPreviewCustomTools
247            | ModelId::Gemini31FlashLitePreview => Some(ModelId::Gemini3FlashPreview),
248            ModelId::GPT55
249            | ModelId::GPT52
250            | ModelId::GPT54
251            | ModelId::GPT54Pro
252            | ModelId::GPT54Nano
253            | ModelId::GPT54Mini
254            | ModelId::GPT5 => Some(ModelId::GPT5Mini),
255            ModelId::OpenCodeZenGPT54 => Some(ModelId::OpenCodeZenGPT54Mini),
256            ModelId::CopilotGPT52Codex | ModelId::CopilotGPT54 => Some(ModelId::CopilotGPT54Mini),
257            ModelId::DeepSeekV4Pro => Some(ModelId::DeepSeekV4Flash),
258            ModelId::HuggingFaceDeepseekV4ProTogether => {
259                Some(ModelId::HuggingFaceDeepseekV4FlashNovita)
260            }
261            ModelId::OllamaDeepseekV4ProCloud => Some(ModelId::OllamaDeepseekV4FlashCloud),
262            ModelId::ZaiGlm5 | ModelId::ZaiGlm51 => Some(ModelId::OllamaGlm5Cloud),
263            ModelId::ClaudeOpus47
264            | ModelId::ClaudeOpus46
265            | ModelId::ClaudeSonnet46
266            | ModelId::ClaudeMythosPreview => Some(ModelId::ClaudeSonnet46),
267            ModelId::OpenCodeGoMinimaxM27 => Some(ModelId::OpenCodeGoMinimaxM25),
268            ModelId::MinimaxM27 | ModelId::MinimaxM25 => None,
269            _ => None,
270        };
271
272        direct.and_then(|candidate| {
273            if candidate.supports_reasoning_effort() {
274                None
275            } else {
276                Some(candidate)
277            }
278        })
279    }
280
281    /// Check if this is a "flash" variant (optimized for speed)
282    pub fn is_flash_variant(&self) -> bool {
283        matches!(
284            self,
285            ModelId::Gemini3FlashPreview
286                | ModelId::Gemini31FlashLitePreview
287                | ModelId::OpenRouterStepfunStep35FlashFree
288                | ModelId::OpenRouterNvidiaNemotron3Super120bA12bFree
289                | ModelId::OllamaGemini3FlashPreviewCloud
290                | ModelId::HuggingFaceStep35Flash
291                | ModelId::HuggingFaceDeepseekV4FlashNovita
292        )
293    }
294
295    /// Check if this is a "pro" variant (optimized for capability)
296    pub fn is_pro_variant(&self) -> bool {
297        matches!(
298            self,
299            ModelId::Gemini31ProPreview
300                | ModelId::Gemini31ProPreviewCustomTools
301                | ModelId::OpenRouterGoogleGemini31ProPreview
302                | ModelId::GPT55
303                | ModelId::GPT5
304                | ModelId::GPT52
305                | ModelId::GPT52Codex
306                | ModelId::GPT54
307                | ModelId::GPT54Pro
308                | ModelId::GPT53Codex
309                | ModelId::GPT51Codex
310                | ModelId::GPT51CodexMax
311                | ModelId::CopilotGPT52Codex
312                | ModelId::CopilotGPT51CodexMax
313                | ModelId::CopilotGPT54
314                | ModelId::CopilotClaudeSonnet46
315                | ModelId::GPT5Codex
316                | ModelId::ClaudeOpus47
317                | ModelId::ClaudeOpus46
318                | ModelId::ClaudeSonnet46
319                | ModelId::ClaudeMythosPreview
320                | ModelId::OpenCodeZenGPT54
321                | ModelId::OpenCodeZenClaudeSonnet46
322                | ModelId::OpenCodeZenGlm51
323                | ModelId::OpenCodeZenKimiK25
324                | ModelId::OpenCodeGoGlm51
325                | ModelId::OpenCodeGoKimiK25
326                | ModelId::OpenCodeGoMinimaxM27
327                | ModelId::DeepSeekV4Pro
328                | ModelId::ZaiGlm5
329                | ModelId::ZaiGlm51
330                | ModelId::OpenRouterStepfunStep35FlashFree
331                | ModelId::OpenRouterNvidiaNemotron3Super120bA12bFree
332                | ModelId::MinimaxM27
333                | ModelId::MinimaxM25
334                | ModelId::OpenCodeGoMinimaxM25
335                | ModelId::OllamaGlm5Cloud
336                | ModelId::OllamaGlm51Cloud
337                | ModelId::OllamaNemotron3SuperCloud
338                | ModelId::OllamaMinimaxM25Cloud
339                | ModelId::HuggingFaceQwen3CoderNextNovita
340                | ModelId::HuggingFaceQwen35397BA17BTogether
341                | ModelId::HuggingFaceDeepseekV4ProTogether
342                | ModelId::OpenRouterMoonshotaiKimiK26
343        )
344    }
345
346    /// Check if this is an optimized/efficient variant
347    pub fn is_efficient_variant(&self) -> bool {
348        if let Some(meta) = self.openrouter_metadata() {
349            return meta.efficient;
350        }
351        matches!(
352            self,
353            ModelId::Gemini3FlashPreview
354                | ModelId::Gemini31FlashLitePreview
355                | ModelId::GPT5Mini
356                | ModelId::GPT5Nano
357                | ModelId::CopilotGPT54Mini
358                | ModelId::ClaudeHaiku45
359                | ModelId::OpenCodeZenGPT54Mini
360                | ModelId::OpenCodeGoMinimaxM25
361                | ModelId::DeepSeekV4Flash
362                | ModelId::HuggingFaceStep35Flash
363                | ModelId::HuggingFaceDeepseekV4FlashNovita
364        )
365    }
366
367    /// Check if this is a top-tier model
368    pub fn is_top_tier(&self) -> bool {
369        if let Some(meta) = self.openrouter_metadata() {
370            return meta.top_tier;
371        }
372        matches!(
373            self,
374            ModelId::Gemini31ProPreview
375                | ModelId::Gemini31ProPreviewCustomTools
376                | ModelId::OpenRouterGoogleGemini31ProPreview
377                | ModelId::Gemini3FlashPreview
378                | ModelId::Gemini31FlashLitePreview
379                | ModelId::GPT55
380                | ModelId::GPT5
381                | ModelId::GPT52
382                | ModelId::GPT52Codex
383                | ModelId::GPT54
384                | ModelId::GPT54Pro
385                | ModelId::GPT53Codex
386                | ModelId::GPT51Codex
387                | ModelId::GPT51CodexMax
388                | ModelId::GPT5Codex
389                | ModelId::ClaudeOpus47
390                | ModelId::ClaudeOpus46
391                | ModelId::ClaudeSonnet46
392                | ModelId::ClaudeMythosPreview
393                | ModelId::OpenCodeZenGPT54
394                | ModelId::OpenCodeZenClaudeSonnet46
395                | ModelId::OpenCodeZenGlm51
396                | ModelId::OpenCodeZenKimiK25
397                | ModelId::OpenCodeGoGlm51
398                | ModelId::OpenCodeGoKimiK25
399                | ModelId::OpenCodeGoMinimaxM27
400                | ModelId::DeepSeekV4Pro
401                | ModelId::ZaiGlm5
402                | ModelId::ZaiGlm51
403                | ModelId::OpenRouterStepfunStep35FlashFree
404                | ModelId::HuggingFaceQwen3CoderNextNovita
405                | ModelId::HuggingFaceQwen35397BA17BTogether
406                | ModelId::HuggingFaceDeepseekV4FlashNovita
407                | ModelId::HuggingFaceDeepseekV4ProTogether
408                | ModelId::OpenRouterMoonshotaiKimiK26
409        )
410    }
411
412    /// Determine whether the model is a reasoning-capable variant
413    pub fn is_reasoning_variant(&self) -> bool {
414        if let Some(meta) = self.openrouter_metadata() {
415            return meta.reasoning;
416        }
417        self.provider().supports_reasoning_effort(self.as_str())
418    }
419
420    /// Determine whether the model supports tool calls/function execution
421    pub fn supports_tool_calls(&self) -> bool {
422        if let Some(meta) = self.generated_capabilities() {
423            return meta.tool_call;
424        }
425        if let Some(meta) = self.openrouter_metadata() {
426            return meta.tool_call;
427        }
428        true
429    }
430
431    /// Ordered list of supported input modalities when VT Code has metadata for this model.
432    pub fn input_modalities(&self) -> &'static [&'static str] {
433        self.generated_capabilities()
434            .map(|meta| meta.input_modalities)
435            .unwrap_or(&[])
436    }
437
438    /// Get the generation/version string for this model
439    pub fn generation(&self) -> &'static str {
440        if let Some(meta) = self.openrouter_metadata() {
441            return meta.generation;
442        }
443        match self {
444            // Gemini generations
445            ModelId::Gemini31ProPreview | ModelId::Gemini31ProPreviewCustomTools => "3.1",
446            ModelId::Gemini31FlashLitePreview => "3.1-lite",
447            ModelId::Gemini3FlashPreview => "3",
448            // OpenAI generations
449            ModelId::GPT55 => "5.5",
450            ModelId::GPT52 | ModelId::GPT52Codex => "5.2",
451            ModelId::GPT54 | ModelId::GPT54Pro | ModelId::GPT54Nano | ModelId::GPT54Mini => "5.4",
452            ModelId::GPT53Codex => "5.3",
453            ModelId::GPT51Codex | ModelId::GPT51CodexMax => "5.1",
454            ModelId::GPT5
455            | ModelId::GPT5Codex
456            | ModelId::GPT5Mini
457            | ModelId::GPT5Nano
458            | ModelId::OpenAIGptOss20b
459            | ModelId::OpenAIGptOss120b => "5",
460            // Anthropic generations
461            ModelId::ClaudeOpus47 => "4.7",
462            ModelId::ClaudeOpus46 => "4.6",
463            ModelId::ClaudeSonnet46 => "4.6",
464            ModelId::ClaudeHaiku45 => "4.5",
465            ModelId::ClaudeMythosPreview => "preview",
466            // DeepSeek generations
467            ModelId::DeepSeekV4Pro | ModelId::DeepSeekV4Flash => "4",
468            // Z.AI generations
469            ModelId::ZaiGlm5 => "5",
470            ModelId::ZaiGlm51 => "5.1",
471            ModelId::OpenCodeZenGPT54 | ModelId::OpenCodeZenGPT54Mini => "5.4",
472            ModelId::OpenCodeZenClaudeSonnet46 => "4.6",
473            ModelId::OpenCodeZenGlm51 | ModelId::OpenCodeGoGlm51 => "5.1",
474            ModelId::OpenCodeZenKimiK25 | ModelId::OpenCodeGoKimiK25 => "k2.5",
475            ModelId::OpenCodeGoMinimaxM25 => "m2.5",
476            ModelId::OpenCodeGoMinimaxM27 => "m2.7",
477            ModelId::OllamaGptOss20b => "oss",
478            ModelId::OllamaGptOss20bCloud => "oss-cloud",
479            ModelId::OllamaGptOss120bCloud => "oss-cloud",
480            ModelId::OllamaQwen317b => "oss",
481            ModelId::OllamaQwen3CoderNext => "qwen3-coder-next:cloud",
482            ModelId::OllamaDeepseekV32Cloud => "deepseek-v3.2",
483            ModelId::OllamaDeepseekV4FlashCloud => "deepseek-v4-flash",
484            ModelId::OllamaDeepseekV4ProCloud => "deepseek-v4-pro",
485            ModelId::OllamaQwen3Next80bCloud => "qwen3-next",
486            ModelId::OllamaMinimaxM2Cloud => "minimax-m2",
487            ModelId::OllamaMinimaxM27Cloud => "minimax-m2.7",
488            ModelId::OllamaGlm5Cloud => "glm-5",
489            ModelId::OllamaGlm51Cloud => "glm-5.1",
490            ModelId::OllamaMinimaxM25Cloud => "minimax-m2.5",
491            ModelId::OllamaKimiK26Cloud => "kimi-k2.6",
492            ModelId::OllamaNemotron3SuperCloud => "nemotron-3",
493            ModelId::OllamaGemini3FlashPreviewCloud => "gemini-3",
494            // MiniMax models
495            ModelId::MinimaxM27 => "M2.7",
496            ModelId::MinimaxM25 => "M2.5",
497            // Moonshot models
498            ModelId::MoonshotKimiK26 => "k2.6",
499            ModelId::MoonshotKimiK25 => "k2.5",
500            // Hugging Face generations
501            ModelId::HuggingFaceDeepseekV32 => "V3.2-Exp",
502            ModelId::HuggingFaceOpenAIGptOss20b => "oss",
503            ModelId::HuggingFaceOpenAIGptOss120b => "oss",
504            ModelId::HuggingFaceMinimaxM25Novita => "m2.5",
505            ModelId::HuggingFaceDeepseekV32Novita => "v3.2",
506            ModelId::HuggingFaceXiaomiMimoV2FlashNovita => "v2-flash",
507            ModelId::HuggingFaceGlm5Novita => "5",
508            ModelId::HuggingFaceGlm51ZaiOrg => "5.1",
509            ModelId::HuggingFaceKimiK26Novita => "k2.6",
510            ModelId::HuggingFaceDeepseekV4FlashNovita => "v4-flash",
511            ModelId::HuggingFaceDeepseekV4ProTogether => "v4-pro",
512            ModelId::HuggingFaceStep35Flash => "3.5",
513            ModelId::HuggingFaceQwen3CoderNextNovita | ModelId::OpenRouterQwen3CoderNext => {
514                "qwen3-coder-next"
515            }
516            // Qwen models
517            ModelId::Qwen37Max => "3.7",
518            ModelId::Qwen36Flash | ModelId::Qwen36Plus => "3.6",
519            ModelId::QwenDeepSeekV4Flash | ModelId::QwenDeepSeekV4Pro => "v4",
520            ModelId::QwenGlm51 => "5.1",
521            _ => "unknown",
522        }
523    }
524
525    /// Determine if this model supports GPT-5.1+/5.2+/5.3+ shell tool type
526    pub fn supports_shell_tool(&self) -> bool {
527        matches!(
528            self,
529            ModelId::GPT55
530                | ModelId::GPT52
531                | ModelId::GPT52Codex
532                | ModelId::GPT54
533                | ModelId::GPT54Pro
534                | ModelId::GPT53Codex
535                | ModelId::GPT51Codex
536                | ModelId::GPT51CodexMax
537                | ModelId::GPT5Codex
538        )
539    }
540
541    /// Determine if this model supports optimized apply_patch tool
542    pub fn supports_apply_patch_tool(&self) -> bool {
543        false // Placeholder for future optimization
544    }
545}
vtcode_config/models/model_id/capabilities.rs

vtcode_config/models/model_id/
capabilities.rs
