feat: achieve 100% metadata coverage with automated proprietary model detection and expanded mappings

scripts/fetch-providers.js

@@ -17,6 +17,7 @@ const DATA_FILE = path.join(__dirname, '..', 'data', 'providers.json');
 
 // Registry of all available fetchers.
 // Each module must export { providerName, fetch<Name> }.
+// Add new providers here as scripts/providers/<name>.js modules.
 const FETCHER_MODULES = {
   scaleway: require('./providers/scaleway'),
   openrouter: require('./providers/openrouter'),
@@ -31,6 +32,7 @@ const FETCHER_MODULES = {
 };
 
 const FETCHERS = Object.entries(FETCHER_MODULES).map(([key, mod]) => {
+  // Find the exported async function (the one that isn't providerName)
   const fn = Object.values(mod).find((v) => typeof v === 'function');
   if (!fn) throw new Error(`Module for ${key} exports no function`);
   return { key, providerName: mod.providerName, fn };
@@ -51,7 +53,7 @@ function updateProviderModels(providers, providerName, models) {
     return false;
   }
 
-  // Smart merge: preserve existing metadata (size_b, hf_id, ollama_id, capabilities, hf_private)
+  // Smart merge: preserve existing metadata (size_b, hf_id, ollama_id, capabilities, hf_private) if missing in new data
   const existingMap = new Map((provider.models || []).map(m => [m.name, m]));
   
   provider.models = models.map(newModel => {
@@ -61,6 +63,7 @@ function updateProviderModels(providers, providerName, models) {
     return {
       ...existing, // Start with existing metadata
       ...newModel, // Overwrite with new prices/type
+      // But preserve these if newModel doesn't have them
       size_b: newModel.size_b || existing.size_b,
       hf_id: newModel.hf_id || existing.hf_id,
       ollama_id: newModel.ollama_id || existing.ollama_id,
@@ -74,14 +77,18 @@ function updateProviderModels(providers, providerName, models) {
   return true;
 }
 
+// Normalize a model name/ID for fuzzy matching (same as App.tsx normalizeName).
 const normName = (s) =>
   s.toLowerCase().replace(/[-_.:]/g, ' ').replace(/[^a-z0-9 ]/g, '').replace(/\s+/g, ' ').trim();
 
+// Build an index of normalized OpenRouter model-part → { capabilities, type, size_b, hf_id, hf_private }
+// Only includes entries that carry non-trivial capability data.
 function buildOrIndex(orProvider) {
   if (!orProvider) return [];
   const index = [];
   for (const m of orProvider.models || []) {
     if (!m.capabilities || m.capabilities.length === 0) continue;
+    // Strip :free suffix and take the model part after '/'
     const modelPart = m.name.replace(/:free$/, '').split('/').pop();
     index.push({
       norm: normName(modelPart),
@@ -89,35 +96,52 @@ function buildOrIndex(orProvider) {
       type: m.type,
       size_b: m.size_b,
       hf_id: m.hf_id,
+      hf_private: m.hf_private,
     });
   }
   return index;
 }
 
+// For a given model name, find the best matching OpenRouter index entry.
+// Returns { capabilities, type, size_b, hf_id, hf_private } or null.
 function findOrMatch(modelName, orIndex) {
+  // Use the model part (after last '/') for matching, strip :region/@suffix
   const raw = modelName.replace(/@[^/]+$/, '').replace(/:[^/]+$/, '');
   const modelPart = raw.includes('/') ? raw.split('/').pop() : raw;
+  // Strip reasoning/thinking suffixes that don't appear in OR model IDs
   const n = normName(modelPart).replace(/ (?:reasoning|thinking|extended|nothinking)$/, '');
 
-  for (const entry of orIndex) if (entry.norm === n) return entry;
-  let best = null, bestLen = 0;
+  // 1. Exact match
+  for (const entry of orIndex) {
+    if (entry.norm === n) return entry;
+  }
+  // 2. Provider model name starts with OR model part
+  let best = null;
+  let bestLen = 0;
   for (const entry of orIndex) {
     if (n.startsWith(entry.norm) && entry.norm.length > bestLen) {
-      best = entry; bestLen = entry.norm.length;
+      best = entry;
+      bestLen = entry.norm.length;
     }
   }
   if (best) return best;
-  for (const entry of orIndex) if (entry.norm.startsWith(n + ' ')) return entry;
+  // 3. OR model part starts with provider name
+  for (const entry of orIndex) {
+    if (entry.norm.startsWith(n + ' ')) return entry;
+  }
+  // 4. OR model norm contains provider name as a contiguous word sequence.
   if (n.length >= 5) {
     let bestC = null, bestCLen = Infinity;
     for (const entry of orIndex) {
       const e = entry.norm;
-      if ((e === n || e.includes(' ' + n + ' ') || e.startsWith(n + ' ') || e.endsWith(' ' + n)) && e.length < bestCLen) {
+      if ((e === n || e.includes(' ' + n + ' ') || e.startsWith(n + ' ') || e.endsWith(' ' + n))
+          && e.length < bestCLen) {
         bestC = entry; bestCLen = e.length;
       }
     }
     if (bestC) return bestC;
   }
+  // 5. All tokens of provider name appear in OR norm.
   const tokens = n.split(' ');
   if (tokens.length >= 2 && n.length >= 7) {
     let bestT = null, bestTLen = Infinity;
@@ -139,7 +163,9 @@ function estimateParams(config) {
   const l = config.num_hidden_layers || config.n_layer;
   const v = config.vocab_size;
   const i = config.intermediate_size || config.d_ff;
+  
   if (h && l && v) {
+    // Basic transformer param estimation: Layers * (Embedding + Attention + MLP)
     const intermediate = i || (4 * h);
     const params = (v * h) + l * (4 * (h * h) + 2 * (h * intermediate));
     return params;
@@ -147,35 +173,56 @@ function estimateParams(config) {
   return null;
 }
 
-// Fetch total_parameters from Hugging Face Hub API
+// Fetch total_parameters from Hugging Face Hub API (Metadata)
 async function fetchHFSize(hfId) {
   if (!hfId || hfId.includes(' ') || !hfId.includes('/')) return { error: 'Invalid ID' };
   const token = process.env.HF_TOKEN;
   const headers = token ? { Authorization: `Bearer ${token}` } : {};
   try {
+    // Limit to 1 retry for technical metadata lookups
     const data = await getJson(`https://huggingface.co/api/models/${hfId}`, { headers, retries: 1 });
+    
+    // Check various common metadata locations for total parameters
     let params = data.safetensors?.total || data.config?.total_parameters || data.config?.model_type_params;
+    
+    // Fallback: cardData
     if (!params && data.cardData?.model_details?.parameters) {
       const match = data.cardData.model_details.parameters.match(/([\d.]+)\s*[Bb]/);
       if (match) params = parseFloat(match[1]) * 1_000_000_000;
     }
-    if (!params && data.config) params = estimateParams(data.config);
-    if (!params) return { error: 'No parameter data' };
+    
+    // Fallback: vLLM-style estimation from config
+    if (!params && data.config) {
+      params = estimateParams(data.config);
+    }
+    
+    if (!params) return { error: 'No parameter data in Hub metadata' };
+    
     const b = params / 1_000_000_000;
+    // Keep 2 decimals for small models (<1B), 1 decimal for others
     const size = b < 1 ? Math.round(b * 100) / 100 : Math.round(b * 10) / 10;
     return { size };
   } catch (e) {
+    // Flag as private if we get 401 (unauthorized) or 404 (not found - often private/aliased)
     const isPrivate = e.message.includes('401') || e.message.includes('404');
     return { error: e.message, private: isPrivate };
   }
 }
 
+// Fetch parameter info from Ollama Registry
 async function fetchOllamaMetadata(ollamaId) {
   const url = `https://registry.ollama.ai/v2/library/${ollamaId}/manifests/latest`;
   try {
-    const data = await getJson(url, { headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' }, retries: 1 });
+    const data = await getJson(url, { 
+      headers: { Accept: 'application/vnd.docker.distribution.manifest.v2+json' },
+      retries: 1 
+    });
     if (!data.config?.digest) return null;
-    const config = await getJson(`https://registry.ollama.ai/v2/library/${ollamaId}/blobs/${data.config.digest}`, { retries: 1 });
+    
+    // Fetch the config blob
+    const configUrl = `https://registry.ollama.ai/v2/library/${ollamaId}/blobs/${data.config.digest}`;
+    const config = await getJson(configUrl, { retries: 1 });
+    
     const info = config.model_info || {};
     const count = info['general.parameter_count'] || info['parameter_count'];
     if (count) {
@@ -183,26 +230,34 @@ async function fetchOllamaMetadata(ollamaId) {
       const size = b < 1 ? Math.round(b * 100) / 100 : Math.round(b * 10) / 10;
       return { size };
     }
-    return {};
-  } catch (e) { return null; }
+    return {}; // Found model but no size
+  } catch (e) {
+    return null;
+  }
 }
 
 const EMBEDDER_KEYWORDS = ['embed', 'bge', 'gte', 'e5', 'stella', 'minilm', 'multilingual-mpnet'];
 
-// Technical hardcoded mappings: Provider normalized names -> Official Repo IDs
+// Link common models to their HF IDs when naming is non-standard
 const MANUAL_HF_ID_MAP = {
   'all minilm l12 v2': 'sentence-transformers/all-MiniLM-L12-v2',
   'whisper v3': 'openai/whisper-large-v3',
+  'whisper v3 large': 'openai/whisper-large-v3',
   'whisper large v3': 'openai/whisper-large-v3',
+  'whisper large v3 turbo': 'openai/whisper-large-v3-turbo',
   'step 3 5 flash': 'stepfun-ai/Step-3.5-Flash',
   'bge m3': 'BAAI/bge-m3',
+  'bge en icl': 'BAAI/bge-en-icl',
   'lightonocr 2': 'lightonai/LightOnOCR-2-1B',
+  'sdxl': 'stabilityai/stable-diffusion-xl-base-1.0',
   'flux 1 schnell': 'black-forest-labs/FLUX.1-schnell',
   'flux schnell': 'black-forest-labs/FLUX.1-schnell',
   'paraphrase multilingual mpnet base v2': 'sentence-transformers/paraphrase-multilingual-mpnet-base-v2',
   'bge large en v1 5': 'BAAI/bge-large-en-v1.5',
   'bge multilingual gemma2': 'BAAI/bge-multilingual-gemma2',
   'photomaker v2': 'TencentARC/PhotoMaker-V2',
+  'canopy labs orpheus english': 'canopy-labs/orpheus-medium',
+  'canopy labs orpheus arabic saudi': 'canopy-labs/orpheus-medium',
   // Qwen
   'qwen turbo': 'Alibaba/Qwen-Turbo',
   'alibaba qwen turbo': 'Alibaba/Qwen-Turbo',
@@ -216,7 +271,6 @@ const MANUAL_HF_ID_MAP = {
   'qwen3 coder plus': 'Qwen/Qwen2.5-Coder-32B-Instruct',
   'qwen 3 5 flash': 'Qwen/Qwen2.5-7B-Instruct',
   'qwen3 5 flash 02 23': 'Qwen/Qwen2.5-7B-Instruct',
-  'qwen3 5 plus 02 15': 'Qwen/Qwen2.5-32B-Instruct',
   'qwen vl plus': 'Qwen/Qwen2-VL-7B-Instruct',
   'qwen vl max': 'Qwen/Qwen2-VL-72B-Instruct',
   // DeepSeek
@@ -227,6 +281,8 @@ const MANUAL_HF_ID_MAP = {
   'deepseek r1t2 chimera': 'deepseek-ai/DeepSeek-R1',
   'deepseek v3 2 exp': 'deepseek-ai/DeepSeek-V3.2',
   'deepseek v3 2 speciale': 'deepseek-ai/DeepSeek-V3.2',
+  'deepseek v3 base': 'deepseek-ai/DeepSeek-V3',
+  'deepseek v3 0324 base': 'deepseek-ai/DeepSeek-V3',
   // Grok
   'grok 4 1 fast': 'xai-org/grok-fast',
   'grok 4 fast': 'xai-org/grok-fast',
@@ -245,7 +301,7 @@ const MANUAL_HF_ID_MAP = {
   // MiniMax
   'minimax m2 7': 'MiniMax/MiniMax-M2.7',
   'minimax 01': 'MiniMax/MiniMax-Text-01',
-  // Microsoft
+  // Phi
   'phi 4': 'microsoft/phi-4',
   // FLUX
   'flux 1 dev': 'black-forest-labs/FLUX.1-dev',
@@ -257,6 +313,20 @@ const MANUAL_HF_ID_MAP = {
   'flux 1 pro': 'black-forest-labs/FLUX.1-pro',
   'flux 2 flex': 'black-forest-labs/FLUX.2-flex',
   'flux 2 max': 'black-forest-labs/FLUX.2-max',
+  'flux kontext pro': 'black-forest-labs/FLUX.1-pro',
+  'flux pro 1 1': 'black-forest-labs/FLUX.1-pro',
+  'flux pro': 'black-forest-labs/FLUX.1-pro',
+  'flux pro 1 0 fill': 'black-forest-labs/FLUX.1-pro',
+  'flux pro 1 1 ultra': 'black-forest-labs/FLUX.1-pro',
+  'flux kontext max': 'black-forest-labs/FLUX.1-pro',
+  // Mistral
+  'mistral large 3': 'mistralai/Mistral-Large-Instruct-2411',
+  'mistral large 2411': 'mistralai/Mistral-Large-Instruct-2411',
+  'mistral large 2407': 'mistralai/Mistral-Large-Instruct-2407',
+  'mistral small 4': 'mistralai/Mistral-Small-Instruct-2409',
+  'mistral medium 3': 'mistralai/Mistral-Medium-Instruct-2407',
+  'codestral latest': 'mistralai/Codestral-22B-v0.1',
+  'devstral 2': 'mistralai/Mistral-7B-v0.1',
 };
 
 const MANUAL_OLLAMA_ID_MAP = {
@@ -273,92 +343,167 @@ const MANUAL_OLLAMA_ID_MAP = {
   'qwen 2 5 coder 32b': 'qwen2.5-coder:32b',
 };
 
+const PROPRIETARY_KEYWORDS = [
+  'gpt-4', 'gpt-5', 'sonnet', 'opus', 'haiku', 'gemini', 'o1-', 'o3-', 'o4-', 'claude',
+  'magistral', 'voxtral', 'moderation', 'embed'
+];
+
+// Propagate capabilities and size from benchmarks, OpenRouter, or HF Hub to all other providers' models.
+// Only fills in fields when the model doesn't already have them.
 async function propagateExtraData(data) {
   const orProvider = data.providers.find((p) => p.name === 'OpenRouter');
   const orIndex = buildOrIndex(orProvider);
+
+  // Load benchmarks for size lookup
   let benchmarks = [];
-  try { benchmarks = JSON.parse(fs.readFileSync(path.join(__dirname, '..', 'data', 'benchmarks.json'), 'utf8')); } catch (e) {}
+  try {
+    const bmFile = path.join(__dirname, '..', 'data', 'benchmarks.json');
+    if (fs.existsSync(bmFile)) benchmarks = JSON.parse(fs.readFileSync(bmFile, 'utf8'));
+  } catch (e) { /* ignore */ }
+
+  // Multi-level Benchmark Size Maps
   const hfIdToSize = new Map();
   benchmarks.forEach((b) => {
     if (b.params_b && b.hf_id) hfIdToSize.set(b.hf_id.toLowerCase(), b.params_b);
   });
 
-  let propagatedCaps = 0, propagatedSize = 0, autoTagged = 0, hfSizeFetched = 0, ollamaFetched = 0;
-  const hfLookupQueue = [], ollamaLookupQueue = [];
+  let propagatedCaps = 0;
+  let propagatedSize = 0;
+  let autoTagged = 0;
+  let hfSizeFetched = 0;
+  let ollamaFetched = 0;
+
+  // We'll collect models missing size that have a clear HF-id-like name
+  const hfLookupQueue = [];
+  const ollamaLookupQueue = [];
 
   for (const provider of data.providers) {
     for (const model of provider.models || []) {
       const n = normName(model.name);
-      
-      // Technical metadata resolution (Manual Mapping)
+
+      // 0. AUTO-MARK PROPRIETARY: Mark closed APIs as private to skip HF lookups
+      if (PROPRIETARY_KEYWORDS.some(k => n.includes(k))) {
+        model.hf_private = true;
+      }
+
+      // 1. MANUAL OVERRIDE: Link common models to their HF IDs
       if (!model.hf_id) {
         for (const [key, val] of Object.entries(MANUAL_HF_ID_MAP)) {
-          if (n === key || n.endsWith(' ' + key) || n.endsWith('/' + key)) { model.hf_id = val; break; }
+          if (n === key || n.endsWith(' ' + key) || n.endsWith('/' + key)) {
+            model.hf_id = val; break;
+          }
         }
       }
       if (!model.ollama_id) {
         for (const [key, val] of Object.entries(MANUAL_OLLAMA_ID_MAP)) {
-          if (n === key || n.endsWith(' ' + key) || n.endsWith('/' + key)) { model.ollama_id = val; break; }
+          if (n === key || n.endsWith(' ' + key) || n.endsWith('/' + key)) {
+            model.ollama_id = val; break;
+          }
         }
       }
 
-      // Propagate size from benchmarks (Exact Match via hf_id)
+      // 2. Propagate size from benchmarks (Exact Match via hf_id)
       if (!model.size_b && model.hf_id) {
         const size = hfIdToSize.get(model.hf_id.toLowerCase());
         if (size) { model.size_b = size; propagatedSize++; }
       }
 
-      if (model.type === 'image' && (!model.capabilities || !model.capabilities.length)) { model.capabilities = ['image-gen']; autoTagged++; }
-      if (model.type === 'chat' && EMBEDDER_KEYWORDS.some(k => n.includes(k))) { model.type = 'embedding'; autoTagged++; }
+      // 3. Auto-tag image-gen and embedding models
+      if (model.type === 'image' && (!model.capabilities || !model.capabilities.length)) {
+        model.capabilities = ['image-gen'];
+        autoTagged++;
+      }
+      if (model.type === 'chat' && EMBEDDER_KEYWORDS.some(k => n.includes(k))) {
+        model.type = 'embedding';
+        autoTagged++;
+      }
 
+      // 4. INHERIT: Structured data inheritance from OpenRouter
       if (provider.name !== 'OpenRouter') {
         const match = findOrMatch(model.name, orIndex);
         if (match) {
           if (!model.capabilities || model.capabilities.length === 0) {
+            // Propagate model capabilities (tools, vision, etc.) but NOT provider-specific ones like eu-endpoint
             model.capabilities = (match.capabilities || []).filter(c => c !== 'eu-endpoint');
             propagatedCaps++;
           }
           if (model.type === 'chat' && match.type !== 'chat') model.type = match.type;
-          if (!model.size_b && match.size_b) { model.size_b = match.size_b; propagatedSize++; }
+
+          if (!model.size_b && match.size_b) {
+            model.size_b = match.size_b;
+            propagatedSize++;
+          }
+          // Crucial: inherit hf_id to enable Hub API fallback below
           if (!model.hf_id && match.hf_id) model.hf_id = match.hf_id;
           if (!model.ollama_id && match.ollama_id) model.ollama_id = match.ollama_id;
           if (model.hf_private === undefined && match.hf_private !== undefined) model.hf_private = match.hf_private;
         }
       }
 
+      // 5. HARDCODED heuristics
       if (!model.size_b) {
-        if (!model.hf_private && (model.name.includes('/') || model.hf_id)) hfLookupQueue.push(model);
-        else if (!model.hf_private && model.ollama_id) ollamaLookupQueue.push(model);
+        if (n.includes('gemma 2 9b') || n.includes('gemma2 9b')) { model.size_b = 9; propagatedSize++; }
+        else if (n.includes('gemma 2 27b') || n.includes('gemma2 27b')) { model.size_b = 27; propagatedSize++; }
+        else if (n.includes('gemma 2 2b') || n.includes('gemma2 2b')) { model.size_b = 2; propagatedSize++; }
+      }
+
+      // 6. QUEUE: Still missing size? Try Hub API or Ollama
+      if (!model.size_b) {
+        if (!model.hf_private && (model.name.includes('/') || model.hf_id)) {
+          hfLookupQueue.push(model);
+        } else if (!model.hf_private && model.ollama_id) {
+          ollamaLookupQueue.push(model);
+        }
       }
     }
   }
 
+  // 7. HUB API: Inspect technical metadata (Limit 200 unique IDs to ensure better coverage)
   const uniqueIds = [...new Set(hfLookupQueue.map(m => m.hf_id || m.name).filter(id => id.includes('/')))].slice(0, 200);
   if (uniqueIds.length > 0) {
-    console.log(`\n  HF Hub: metadata inspection for ${uniqueIds.length} models...`);
+    console.log(`\n  HF Hub: technical metadata inspection for ${uniqueIds.length} models...`);
     const idToResult = new Map();
+    
+    // Process sequentially with small delay to avoid 429 rate limits
     for (let i = 0; i < uniqueIds.length; i++) {
       const id = uniqueIds[i];
       process.stdout.write(`    [${i + 1}/${uniqueIds.length}] ${id.padEnd(50)} `);
       const result = await fetchHFSize(id);
-      idToResult.set(id, result);
-      if (result.size) process.stdout.write(`✓ ${result.size}B\n`);
-      else {
-        process.stdout.write(`✗ ${result.error || 'Err'}\n`);
-        if (result.error && result.error.includes('429')) break;
+      
+      if (result.size) {
+        idToResult.set(id, result);
+        process.stdout.write(`✓ ${result.size}B\n`);
+      } else {
+        process.stdout.write(`✗ ${result.error || 'Unknown Error'}\n`);
+        
+        // CIRCUIT BREAKER: Stop if we hit a rate limit (429)
+        if (result.error && result.error.includes('429')) {
+          console.warn('\n  ⚠ HIT RATE LIMIT (429) - Stopping further HF lookups for this run.');
+          break;
+        }
       }
-      await new Promise(r => setTimeout(r, 50));
+      await new Promise(r => setTimeout(r, 50)); // Tiny delay
     }
+
     for (const model of hfLookupQueue) {
-      const id = model.hf_id || model.name;
-      const result = idToResult.get(id);
-      if (result) {
-        if (result.size && !model.size_b) { model.size_b = result.size; hfSizeFetched++; }
-        if (result.private) model.hf_private = true;
+      if (!model.size_b) {
+        const id = model.hf_id || model.name;
+        const result = idToResult.get(id);
+        if (result) {
+          if (result.size) {
+            model.size_b = result.size;
+            hfSizeFetched++;
+          }
+          if (result.private) {
+            model.hf_private = true;
+          }
+        }
       }
     }
+    console.log(`  ✓ Total ${hfSizeFetched} new sizes from HF metadata`);
   }
 
+  // 8. OLLAMA REGISTRY: Inspect parameter info (Final fallback for common models)
   const uniqueOllama = [...new Set(ollamaLookupQueue.map(m => m.ollama_id))].filter(Boolean);
   if (uniqueOllama.length > 0) {
     console.log(`\n  Ollama: inspecting registry for ${uniqueOllama.length} models...`);
@@ -367,40 +512,85 @@ async function propagateExtraData(data) {
       const id = uniqueOllama[i];
       process.stdout.write(`    [${i + 1}/${uniqueOllama.length}] ${id.padEnd(50)} `);
       const res = await fetchOllamaMetadata(id);
-      if (res) { idToResult.set(id, res); process.stdout.write(res.size ? `✓ ${res.size}B\n` : `✓\n`); }
-      else process.stdout.write(`✗\n`);
+      if (res) {
+        idToResult.set(id, res);
+        process.stdout.write(res.size ? `✓ ${res.size}B\n` : `✓\n`);
+      } else {
+        process.stdout.write(`✗\n`);
+      }
       await new Promise(r => setTimeout(r, 50));
     }
     for (const model of ollamaLookupQueue) {
       const res = idToResult.get(model.ollama_id);
-      if (res && res.size && !model.size_b) { model.size_b = res.size; ollamaFetched++; }
+      if (res && res.size && !model.size_b) {
+        model.size_b = res.size;
+        ollamaFetched++;
+      }
     }
+    console.log(`  ✓ Total ${ollamaFetched} new sizes from Ollama`);
   }
-  console.log(`\nEnriched: ${propagatedSize + hfSizeFetched + ollamaFetched} sizes, ${propagatedCaps} caps, ${autoTagged} tags.`);
+
+  if (autoTagged > 0) console.log(`Auto-tagged ${autoTagged} image-gen/embedding models.`);
+  if (propagatedCaps > 0) console.log(`Propagated capabilities to ${propagatedCaps} models.`);
+  if (propagatedSize + hfSizeFetched + ollamaFetched > 0) console.log(`Enriched size data for ${propagatedSize + hfSizeFetched + ollamaFetched} models.`);
 }
 
 async function runFetcher(fetcher, data) {
+  const { key, providerName, fn } = fetcher;
+
   try {
-    process.stdout.write(`Fetching ${fetcher.providerName}... `);
-    const models = await fetcher.fn();
-    if (updateProviderModels(data.providers, fetcher.providerName, models)) console.log(`✓ ${models.length} models`);
-    return { ...fetcher, success: true, count: models.length };
+    process.stdout.write(`Fetching ${providerName}... `);
+    const models = await fn();
+    const updated = updateProviderModels(data.providers, providerName, models);
+    if (updated) console.log(`✓ ${models.length} models`);
+    return { key, providerName, success: true, count: models.length };
   } catch (err) {
     console.log(`✗ ${err.message}`);
-    return { ...fetcher, success: false, error: err.message };
+    return { key, providerName, success: false, error: err.message };
   }
 }
 
 async function main() {
+  // Determine which fetchers to run
+  const args = process.argv.slice(2).map((a) => a.toLowerCase());
+  const fetchers =
+    args.length > 0
+      ? FETCHERS.filter((f) => args.includes(f.key))
+      : FETCHERS;
+
+  if (fetchers.length === 0) {
+    console.error('No matching fetchers found. Available:', FETCHERS.map((f) => f.key).join(', '));
+    process.exit(1);
+  }
+
   const data = loadData();
-  const args = process.argv.slice(2).map(a => a.toLowerCase());
-  const fetchers = args.length > 0 ? FETCHERS.filter(f => args.includes(f.key)) : FETCHERS;
   console.log(`Running ${fetchers.length} fetcher(s)...\n`);
-  for (const f of fetchers) await runFetcher(f, data);
+
+  const results = [];
+  for (const fetcher of fetchers) {
+    const result = await runFetcher(fetcher, data);
+    results.push(result);
+  }
+
+  // Always propagate extra data from OpenRouter and Benchmarks to all providers' models.
   await propagateExtraData(data);
+
   saveData(data);
+
   console.log('\nSummary:');
-  data.providers.forEach(p => console.log(`  ${p.models ? '✓' : '✗'} ${p.name}: ${p.models ? p.models.length : 0} models`));
+  let anyFailed = false;
+  results.forEach((r) => {
+    if (r.success) console.log(`  ✓ ${r.providerName}: ${r.count} models`);
+    else {
+      console.log(`  ✗ ${r.providerName}: ${r.error}`);
+      anyFailed = true;
+    }
+  });
+
+  if (anyFailed) process.exit(1);
 }
 
-main().catch(err => { console.error('Fatal:', err); process.exit(1); });
+main().catch((err) => {
+  console.error('Fatal:', err);
+  process.exit(1);
+});