free-coding-models 0.1.51 → 0.1.54

package/README.md

@@ -2,14 +2,14 @@
   <img src="https://img.shields.io/npm/v/free-coding-models?color=76b900&label=npm&logo=npm" alt="npm version">
   <img src="https://img.shields.io/node/v/free-coding-models?color=76b900&logo=node.js" alt="node version">
   <img src="https://img.shields.io/npm/l/free-coding-models?color=76b900" alt="license">
-  <img src="https://img.shields.io/badge/models-53-76b900?logo=nvidia" alt="models count">
-  <img src="https://img.shields.io/badge/providers-3-blue" alt="providers count">
+  <img src="https://img.shields.io/badge/models-101-76b900?logo=nvidia" alt="models count">
+  <img src="https://img.shields.io/badge/providers-9-blue" alt="providers count">
 </p>
 
 <h1 align="center">free-coding-models</h1>
 
 <p align="center">
-  <strong>Want to contribute or discuss the project?</strong> Join our <a href="https://discord.gg/5MbTnDC3Md">Discord community</a>!
+  💬 <a href="https://discord.gg/5MbTnDC3Md">Let's talk about the project on Discord</a>
 </p>
 
 <p align="center">
@@ -24,7 +24,7 @@
 
 <p align="center">
   <strong>Find the fastest coding LLM models in seconds</strong><br>
-  <sub>Ping free models from NVIDIA NIM, Groq, and Cerebras in real-time — pick the best one for OpenCode, OpenClaw, or any AI coding assistant</sub>
+  <sub>Ping free models from NVIDIA NIM, Groq, Cerebras, and SambaNova in real-time — pick the best one for OpenCode, OpenClaw, or any AI coding assistant</sub>
 </p>
 
 <p align="center">
@@ -47,7 +47,7 @@
 ## ✨ Features
 
 - **🎯 Coding-focused** — Only LLM models optimized for code generation, not chat or vision
-- **🌐 Multi-provider** — 53 models from NVIDIA NIM, Groq, and Cerebras — all free to use
+- **🌐 Multi-provider** — 101 models from NVIDIA NIM, Groq, Cerebras, SambaNova, OpenRouter, Codestral, Hyperbolic, Scaleway, and Google AI — all free to use
 - **⚙️ Settings screen** — Press `P` to manage provider API keys, enable/disable providers, and test keys live
 - **🚀 Parallel pings** — All models tested simultaneously via native `fetch`
 - **📊 Real-time animation** — Watch latency appear live in alternate screen buffer
@@ -76,10 +76,16 @@ Before using `free-coding-models`, make sure you have:
    - **NVIDIA NIM** — [build.nvidia.com](https://build.nvidia.com) → Profile → API Keys → Generate
    - **Groq** — [console.groq.com/keys](https://console.groq.com/keys) → Create API Key
    - **Cerebras** — [cloud.cerebras.ai](https://cloud.cerebras.ai) → API Keys → Create
+   - **SambaNova** — [cloud.sambanova.ai/apis](https://cloud.sambanova.ai/apis) → API Keys → Create ($5 free trial, 3 months)
+   - **OpenRouter** — [openrouter.ai/settings/keys](https://openrouter.ai/settings/keys) → Create key (50 free req/day)
+   - **Mistral Codestral** — [codestral.mistral.ai](https://codestral.mistral.ai) → API Keys (30 req/min, 2000/day — phone required)
+   - **Hyperbolic** — [app.hyperbolic.ai/settings](https://app.hyperbolic.ai/settings) → API Keys ($1 free trial)
+   - **Scaleway** — [console.scaleway.com/iam/api-keys](https://console.scaleway.com/iam/api-keys) → IAM → API Keys (1M free tokens)
+   - **Google AI Studio** — [aistudio.google.com/apikey](https://aistudio.google.com/apikey) → Get API key (free Gemma models, 14.4K req/day)
 3. **OpenCode** *(optional)* — [Install OpenCode](https://github.com/opencode-ai/opencode) to use the OpenCode integration
 4. **OpenClaw** *(optional)* — [Install OpenClaw](https://openclaw.ai) to use the OpenClaw integration
 
-> 💡 **Tip:** You don't need all three providers. One key is enough to get started. Add more later via the Settings screen (`P` key). Models without a key still show real latency (`🔑 NO KEY`) so you can evaluate providers before signing up.
+> 💡 **Tip:** You don't need all four providers. One key is enough to get started. Add more later via the Settings screen (`P` key). Models without a key still show real latency (`🔑 NO KEY`) so you can evaluate providers before signing up.
 
 ---
 
@@ -157,13 +163,13 @@ When you run `free-coding-models` without `--opencode` or `--openclaw`, you get
 Use `↑↓` arrows to select, `Enter` to confirm. Then the TUI launches with your chosen mode shown in the header badge.
 
 **How it works:**
-1. **Ping phase** — All enabled models are pinged in parallel (up to 53 across 3 providers)
+1. **Ping phase** — All enabled models are pinged in parallel (up to 101 across 9 providers)
 2. **Continuous monitoring** — Models are re-pinged every 2 seconds forever
 3. **Real-time updates** — Watch "Latest", "Avg", and "Up%" columns update live
 4. **Select anytime** — Use ↑↓ arrows to navigate, press Enter on a model to act
 5. **Smart detection** — Automatically detects if NVIDIA NIM is configured in OpenCode or OpenClaw
 
-Setup wizard (first run — walks through all 3 providers):
+Setup wizard (first run — walks through all 9 providers):
 
 ```
   🔑 First-time setup — API keys
@@ -184,11 +190,16 @@ Setup wizard (first run — walks through all 3 providers):
     API Keys → Create
   Enter key (or Enter to skip):
 
+  ● SambaNova
+    Free key at: https://cloud.sambanova.ai/apis
+    API Keys → Create ($5 free trial, 3 months)
+  Enter key (or Enter to skip):
+
   ✅ 2 key(s) saved to ~/.free-coding-models.json
   You can add or change keys anytime with the P key in the TUI.
 ```
 
-You don't need all three — skip any provider by pressing Enter. At least one key is required.
+You don't need all four — skip any provider by pressing Enter. At least one key is required.
 
 ### Adding or changing keys later
 
@@ -246,7 +257,7 @@ CEREBRAS_API_KEY=csk_xxx free-coding-models
 
 ## 🤖 Coding Models
 
-**53 coding models** across 3 providers and 8 tiers, ranked by [SWE-bench Verified](https://www.swebench.com) — the industry-standard benchmark measuring real GitHub issue resolution. Scores are self-reported by providers unless noted.
+**101 coding models** across 9 providers and 8 tiers, ranked by [SWE-bench Verified](https://www.swebench.com) — the industry-standard benchmark measuring real GitHub issue resolution. Scores are self-reported by providers unless noted.
 
 ### NVIDIA NIM (44 models)
 
@@ -601,4 +612,8 @@ We welcome contributions! Feel free to open issues, submit pull requests, or get
 **A:** No — `free-coding-models` configures OpenClaw to use NVIDIA NIM's remote API, so models run on NVIDIA's infrastructure. No GPU or local setup required.
 
 ## 📧 Support
-For questions or issues, open a GitHub issue or join our community Discord: https://discord.gg/5MbTnDC3Md
+
+For questions or issues, open a [GitHub issue](https://github.com/vava-nessa/free-coding-models/issues).
+
+💬 Let's talk about the project on Discord: https://discord.gg/5MbTnDC3Md
+📚 Read the docs on GitHub: https://github.com/vava-nessa/free-coding-models#readme ⚠️ free-coding-models is a BETA TUI — expect rough edges and occasional crashes.

package/bin/free-coding-models.js

@@ -198,6 +198,54 @@ async function promptApiKey(config) {
       hint: 'API Keys → Create',
       prefix: 'csk_ / cauth_',
     },
+    {
+      key: 'sambanova',
+      label: 'SambaNova',
+      color: chalk.rgb(255, 165, 0),
+      url: 'https://cloud.sambanova.ai/apis',
+      hint: 'API Keys → Create ($5 free trial, 3 months)',
+      prefix: 'sn-',
+    },
+    {
+      key: 'openrouter',
+      label: 'OpenRouter',
+      color: chalk.rgb(120, 80, 255),
+      url: 'https://openrouter.ai/settings/keys',
+      hint: 'API Keys → Create key (50 free req/day, shared quota)',
+      prefix: 'sk-or-',
+    },
+    {
+      key: 'codestral',
+      label: 'Mistral Codestral',
+      color: chalk.rgb(255, 100, 100),
+      url: 'https://codestral.mistral.ai',
+      hint: 'API Keys → Create key (30 req/min, 2000/day — phone required)',
+      prefix: 'csk-',
+    },
+    {
+      key: 'hyperbolic',
+      label: 'Hyperbolic',
+      color: chalk.rgb(0, 200, 150),
+      url: 'https://app.hyperbolic.ai/settings',
+      hint: 'Settings → API Keys ($1 free trial)',
+      prefix: 'eyJ',
+    },
+    {
+      key: 'scaleway',
+      label: 'Scaleway',
+      color: chalk.rgb(130, 0, 250),
+      url: 'https://console.scaleway.com/iam/api-keys',
+      hint: 'IAM → API Keys (1M free tokens)',
+      prefix: 'scw-',
+    },
+    {
+      key: 'googleai',
+      label: 'Google AI Studio',
+      color: chalk.rgb(66, 133, 244),
+      url: 'https://aistudio.google.com/apikey',
+      hint: 'Get API key (free Gemma models, 14.4K req/day)',
+      prefix: 'AIza',
+    },
   ]
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
@@ -412,7 +460,7 @@ function calculateViewport(terminalRows, scrollOffset, totalModels) {
 }
 
 // 📖 renderTable: mode param controls footer hint text (opencode vs openclaw)
-function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0) {
+function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode', tierFilterMode = 0, scrollOffset = 0, terminalRows = 0, originFilterMode = 0) {
   // 📖 Filter out hidden models for display
   const visibleResults = results.filter(r => !r.hidden)
 
@@ -453,6 +501,17 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     tierBadge = chalk.bold.rgb(255, 200, 0)(` [${TIER_CYCLE_NAMES[tierFilterMode]}]`)
   }
 
+  // 📖 Origin filter badge — shown when filtering by provider is active
+  let originBadge = ''
+  if (originFilterMode > 0) {
+    const originKeys = [null, ...Object.keys(sources)]
+    const activeOriginKey = originKeys[originFilterMode]
+    const activeOriginName = activeOriginKey ? sources[activeOriginKey]?.name ?? activeOriginKey : null
+    if (activeOriginName) {
+      originBadge = chalk.bold.rgb(100, 200, 255)(` [${activeOriginName}]`)
+    }
+  }
+
   // 📖 Column widths (generous spacing with margins)
   const W_RANK = 6
   const W_TIER = 6
@@ -471,7 +530,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
 
   const lines = [
     '',
-    `  ${chalk.bold('⚡ Free Coding Models')} ${chalk.dim('v' + LOCAL_VERSION)}${modeBadge}${modeHint}${tierBadge}   ` +
+    `  ${chalk.bold('⚡ Free Coding Models')} ${chalk.dim('v' + LOCAL_VERSION)}${modeBadge}${modeHint}${tierBadge}${originBadge}   ` +
       chalk.greenBright(`✅ ${up}`) + chalk.dim(' up  ') +
       chalk.yellow(`⏱ ${timeout}`) + chalk.dim(' timeout  ') +
       chalk.red(`❌ ${down}`) + chalk.dim(' down  ') +
@@ -509,7 +568,10 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
   // 📖 Now colorize after padding is calculated on plain text
   const rankH_c    = colorFirst(rankH, W_RANK)
   const tierH_c    = colorFirst('Tier', W_TIER)
-  const originH_c  = sortColumn === 'origin' ? chalk.bold.cyan(originH.padEnd(W_SOURCE)) : colorFirst(originH, W_SOURCE)
+  const originLabel = 'Origin(N)'
+  const originH_c  = sortColumn === 'origin'
+    ? chalk.bold.cyan(originLabel.padEnd(W_SOURCE))
+    : (originFilterMode > 0 ? chalk.bold.rgb(100, 200, 255)(originLabel.padEnd(W_SOURCE)) : colorFirst(originLabel, W_SOURCE))
   const modelH_c   = colorFirst(modelH, W_MODEL)
   const sweH_c     = sortColumn === 'swe' ? chalk.bold.cyan(sweH.padEnd(W_SWE)) : colorFirst(sweH, W_SWE)
   const ctxH_c     = sortColumn === 'ctx' ? chalk.bold.cyan(ctxH.padEnd(W_CTX)) : colorFirst(ctxH, W_CTX)
@@ -707,9 +769,10 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     : mode === 'opencode-desktop'
       ? chalk.rgb(0, 200, 255)('Enter→OpenDesktop')
       : chalk.rgb(0, 200, 255)('Enter→OpenCode')
-  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  R/Y/O/M/L/A/S/C/H/V/U Sort  •  W↓/X↑ Interval (${intervalSec}s)  •  T Filter tier  •  Z Mode  •  `) + chalk.yellow('P') + chalk.dim(` Settings  •  Ctrl+C Exit`))
+  lines.push(chalk.dim(`  ↑↓ Navigate  •  `) + actionHint + chalk.dim(`  •  R/Y/O/M/L/A/S/C/H/V/U Sort  •  T Tier  •  N Origin  •  W↓/X↑ (${intervalSec}s)  •  Z Mode  •  `) + chalk.yellow('P') + chalk.dim(` Settings  •  `) + chalk.yellow('K') + chalk.dim(` Help  •  Ctrl+C Exit`))
   lines.push('')
   lines.push(chalk.dim('  Made with ') + '💖 & ☕' + chalk.dim(' by ') + '\x1b]8;;https://github.com/vava-nessa\x1b\\vava-nessa\x1b]8;;\x1b\\' + chalk.dim('  •  ') + '🫂 ' + chalk.cyanBright('\x1b]8;;https://discord.gg/5MbTnDC3Md\x1b\\Join our Discord!\x1b]8;;\x1b\\') + chalk.dim('  •  ') + '⭐ ' + '\x1b]8;;https://github.com/vava-nessa/free-coding-models\x1b\\Read the docs on GitHub\x1b]8;;\x1b\\')
+  lines.push(chalk.dim('  💬 Discord: ') + chalk.cyanBright('https://discord.gg/5MbTnDC3Md'))
   lines.push('')
   // 📖 Append \x1b[K (erase to EOL) to each line so leftover chars from previous
   // 📖 frames are cleared. Then pad with blank cleared lines to fill the terminal,
@@ -758,6 +821,35 @@ const isWindows = process.platform === 'win32'
 const isMac = process.platform === 'darwin'
 const isLinux = process.platform === 'linux'
 
+// ─── OpenCode model ID mapping ─────────────────────────────────────────────────
+// 📖 Source model IDs -> OpenCode built-in model IDs (only where they differ)
+// 📖 Groq's API aliases short names to full names, but OpenCode does exact ID matching
+// 📖 against its built-in model list. Unmapped models pass through as-is.
+const OPENCODE_MODEL_MAP = {
+  groq: {
+    'moonshotai/kimi-k2-instruct': 'moonshotai/kimi-k2-instruct-0905',
+    'meta-llama/llama-4-scout-17b-16e-preview': 'meta-llama/llama-4-scout-17b-16e-instruct',
+    'meta-llama/llama-4-maverick-17b-128e-preview': 'meta-llama/llama-4-maverick-17b-128e-instruct',
+  }
+}
+
+function getOpenCodeModelId(providerKey, modelId) {
+  return OPENCODE_MODEL_MAP[providerKey]?.[modelId] || modelId
+}
+
+// 📖 Env var names per provider -- used for passing resolved keys to child processes
+const ENV_VAR_NAMES = {
+  nvidia:     'NVIDIA_API_KEY',
+  groq:       'GROQ_API_KEY',
+  cerebras:   'CEREBRAS_API_KEY',
+  sambanova:  'SAMBANOVA_API_KEY',
+  openrouter: 'OPENROUTER_API_KEY',
+  codestral:  'CODESTRAL_API_KEY',
+  hyperbolic: 'HYPERBOLIC_API_KEY',
+  scaleway:   'SCALEWAY_API_KEY',
+  googleai:   'GOOGLE_API_KEY',
+}
+
 // 📖 OpenCode config location varies by platform
 // 📖 Windows: %APPDATA%\opencode\opencode.json (or sometimes ~/.config/opencode)
 // 📖 macOS/Linux: ~/.config/opencode/opencode.json
@@ -809,16 +901,50 @@ function checkNvidiaNimConfig() {
   )
 }
 
+// ─── Shared OpenCode spawn helper ──────────────────────────────────────────────
+// 📖 Resolves the actual API key from config/env and passes it as an env var
+// 📖 to the child process so OpenCode's {env:GROQ_API_KEY} references work
+// 📖 even when the key is only in ~/.free-coding-models.json (not in shell env).
+async function spawnOpenCode(args, providerKey, fcmConfig) {
+  const envVarName = ENV_VAR_NAMES[providerKey]
+  const resolvedKey = getApiKey(fcmConfig, providerKey)
+  const childEnv = { ...process.env }
+  if (envVarName && resolvedKey) childEnv[envVarName] = resolvedKey
+
+  const { spawn } = await import('child_process')
+  const child = spawn('opencode', args, {
+    stdio: 'inherit',
+    shell: true,
+    detached: false,
+    env: childEnv
+  })
+
+  return new Promise((resolve, reject) => {
+    child.on('exit', resolve)
+    child.on('error', (err) => {
+      if (err.code === 'ENOENT') {
+        console.error(chalk.red('\n  X Could not find "opencode" -- is it installed and in your PATH?'))
+        console.error(chalk.dim('    Install: npm i -g opencode   or see https://opencode.ai'))
+        resolve(1)
+      } else {
+        reject(err)
+      }
+    })
+  })
+}
+
 // ─── Start OpenCode ────────────────────────────────────────────────────────────
 // 📖 Launches OpenCode with the selected model.
 // 📖 Handles all 3 providers: nvidia (needs custom provider config), groq & cerebras (built-in in OpenCode).
 // 📖 For nvidia: checks if NIM is configured, sets provider.models entry, spawns with nvidia/model-id.
-// 📖 For groq/cerebras: OpenCode has built-in support — just sets model in config and spawns.
+// 📖 For groq/cerebras: OpenCode has built-in support -- just sets model in config and spawns.
 // 📖 Model format: { modelId, label, tier, providerKey }
-async function startOpenCode(model) {
+// 📖 fcmConfig: the free-coding-models config (for resolving API keys)
+async function startOpenCode(model, fcmConfig) {
   const providerKey = model.providerKey ?? 'nvidia'
-  // 📖 Full model reference string used in OpenCode config and --model flag
-  const modelRef = `${providerKey}/${model.modelId}`
+  // 📖 Map model ID to OpenCode's built-in ID if it differs from our source ID
+  const ocModelId = getOpenCodeModelId(providerKey, model.modelId)
+  const modelRef = `${providerKey}/${ocModelId}`
 
   if (providerKey === 'nvidia') {
     // 📖 NVIDIA NIM needs a custom provider block in OpenCode config (not built-in)
@@ -840,11 +966,9 @@ async function startOpenCode(model) {
       config.model = modelRef
 
       // 📖 Register the model in the nvidia provider's models section
-      // 📖 OpenCode requires models to be explicitly listed in provider.models
-      // 📖 to recognize them — without this, it falls back to the previous default
       if (config.provider?.nvidia) {
         if (!config.provider.nvidia.models) config.provider.nvidia.models = {}
-        config.provider.nvidia.models[model.modelId] = { name: model.label }
+        config.provider.nvidia.models[ocModelId] = { name: model.label }
       }
 
       saveOpenCodeConfig(config)
@@ -863,27 +987,9 @@ async function startOpenCode(model) {
       console.log(chalk.dim('  Starting OpenCode…'))
       console.log()
 
-      const { spawn } = await import('child_process')
-      const child = spawn('opencode', ['--model', modelRef], {
-        stdio: 'inherit',
-        shell: true,
-        detached: false
-      })
-
-      await new Promise((resolve, reject) => {
-        child.on('exit', resolve)
-        child.on('error', (err) => {
-          if (err.code === 'ENOENT') {
-            console.error(chalk.red('\n  ✗ Could not find "opencode" — is it installed and in your PATH?'))
-            console.error(chalk.dim('    Install: npm i -g opencode   or see https://opencode.ai'))
-            resolve(1)
-          } else {
-            reject(err)
-          }
-        })
-      })
+      await spawnOpenCode(['--model', modelRef], providerKey, fcmConfig)
     } else {
-      // 📖 NVIDIA NIM not configured — show install prompt
+      // 📖 NVIDIA NIM not configured -- show install prompt
       console.log(chalk.yellow('  ⚠ NVIDIA NIM not configured in OpenCode'))
       console.log()
       console.log(chalk.dim('  Starting OpenCode with installation prompt…'))
@@ -914,29 +1020,11 @@ After installation, you can use: opencode --model ${modelRef}`
       console.log(chalk.dim('  Starting OpenCode…'))
       console.log()
 
-      const { spawn } = await import('child_process')
-      const child = spawn('opencode', [], {
-        stdio: 'inherit',
-        shell: true,
-        detached: false
-      })
-
-      await new Promise((resolve, reject) => {
-        child.on('exit', resolve)
-        child.on('error', (err) => {
-          if (err.code === 'ENOENT') {
-            console.error(chalk.red('\n  ✗ Could not find "opencode" — is it installed and in your PATH?'))
-            console.error(chalk.dim('    Install: npm i -g opencode   or see https://opencode.ai'))
-            resolve(1)
-          } else {
-            reject(err)
-          }
-        })
-      })
+      await spawnOpenCode([], providerKey, fcmConfig)
     }
   } else {
-    // 📖 Groq: built-in OpenCode provider — needs provider block with apiKey in opencode.json.
-    // 📖 Cerebras: NOT built-in — needs @ai-sdk/openai-compatible + baseURL, like NVIDIA.
+    // 📖 Groq: built-in OpenCode provider -- needs provider block with apiKey in opencode.json.
+    // 📖 Cerebras: NOT built-in -- needs @ai-sdk/openai-compatible + baseURL, like NVIDIA.
     // 📖 Both need the model registered in provider.<key>.models so OpenCode can find it.
     console.log(chalk.green(`  🚀 Setting ${chalk.bold(model.label)} as default…`))
     console.log(chalk.dim(`  Model: ${modelRef}`))
@@ -970,13 +1058,77 @@ After installation, you can use: opencode --model ${modelRef}`
           },
           models: {}
         }
+      } else if (providerKey === 'sambanova') {
+        // 📖 SambaNova is OpenAI-compatible — uses @ai-sdk/openai-compatible with their base URL
+        config.provider.sambanova = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'SambaNova',
+          options: {
+            baseURL: 'https://api.sambanova.ai/v1',
+            apiKey: '{env:SAMBANOVA_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'openrouter') {
+        config.provider.openrouter = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'OpenRouter',
+          options: {
+            baseURL: 'https://openrouter.ai/api/v1',
+            apiKey: '{env:OPENROUTER_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'codestral') {
+        config.provider.codestral = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Mistral Codestral',
+          options: {
+            baseURL: 'https://codestral.mistral.ai/v1',
+            apiKey: '{env:CODESTRAL_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'hyperbolic') {
+        config.provider.hyperbolic = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Hyperbolic',
+          options: {
+            baseURL: 'https://api.hyperbolic.xyz/v1',
+            apiKey: '{env:HYPERBOLIC_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'scaleway') {
+        config.provider.scaleway = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Scaleway',
+          options: {
+            baseURL: 'https://api.scaleway.ai/v1',
+            apiKey: '{env:SCALEWAY_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'googleai') {
+        config.provider.googleai = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Google AI Studio',
+          options: {
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai',
+            apiKey: '{env:GOOGLE_API_KEY}'
+          },
+          models: {}
+        }
       }
     }
 
     // 📖 Register the model in the provider's models section
-    // 📖 OpenCode requires models to be explicitly listed to recognize them
-    if (!config.provider[providerKey].models) config.provider[providerKey].models = {}
-    config.provider[providerKey].models[model.modelId] = { name: model.label }
+    // 📖 Only register custom models -- skip if the model maps to a built-in OpenCode ID
+    const isBuiltinMapped = OPENCODE_MODEL_MAP[providerKey]?.[model.modelId]
+    if (!isBuiltinMapped) {
+      if (!config.provider[providerKey].models) config.provider[providerKey].models = {}
+      config.provider[providerKey].models[ocModelId] = { name: model.label }
+    }
 
     config.model = modelRef
     saveOpenCodeConfig(config)
@@ -995,25 +1147,7 @@ After installation, you can use: opencode --model ${modelRef}`
     console.log(chalk.dim('  Starting OpenCode…'))
     console.log()
 
-    const { spawn } = await import('child_process')
-    const child = spawn('opencode', ['--model', modelRef], {
-      stdio: 'inherit',
-      shell: true,
-      detached: false
-    })
-
-    await new Promise((resolve, reject) => {
-      child.on('exit', resolve)
-      child.on('error', (err) => {
-        if (err.code === 'ENOENT') {
-          console.error(chalk.red('\n  ✗ Could not find "opencode" — is it installed and in your PATH?'))
-          console.error(chalk.dim('    Install: npm i -g opencode   or see https://opencode.ai'))
-          resolve(1)
-        } else {
-          reject(err)
-        }
-      })
-    })
+    await spawnOpenCode(['--model', modelRef], providerKey, fcmConfig)
   }
 }
 
@@ -1022,10 +1156,11 @@ After installation, you can use: opencode --model ${modelRef}`
 // 📖 OpenCode Desktop shares config at the same location as CLI.
 // 📖 Handles all 3 providers: nvidia (needs custom provider config), groq & cerebras (built-in).
 // 📖 No need to wait for exit — Desktop app stays open independently.
-async function startOpenCodeDesktop(model) {
+async function startOpenCodeDesktop(model, fcmConfig) {
   const providerKey = model.providerKey ?? 'nvidia'
-  // 📖 Full model reference string used in OpenCode config and --model flag
-  const modelRef = `${providerKey}/${model.modelId}`
+  // 📖 Map model ID to OpenCode's built-in ID if it differs from our source ID
+  const ocModelId = getOpenCodeModelId(providerKey, model.modelId)
+  const modelRef = `${providerKey}/${ocModelId}`
 
   // 📖 Helper to open the Desktop app based on platform
   const launchDesktop = async () => {
@@ -1074,7 +1209,7 @@ async function startOpenCodeDesktop(model) {
 
       if (config.provider?.nvidia) {
         if (!config.provider.nvidia.models) config.provider.nvidia.models = {}
-        config.provider.nvidia.models[model.modelId] = { name: model.label }
+        config.provider.nvidia.models[ocModelId] = { name: model.label }
       }
 
       saveOpenCodeConfig(config)
@@ -1153,12 +1288,77 @@ ${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_k
           },
           models: {}
         }
+      } else if (providerKey === 'sambanova') {
+        // 📖 SambaNova is OpenAI-compatible — uses @ai-sdk/openai-compatible with their base URL
+        config.provider.sambanova = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'SambaNova',
+          options: {
+            baseURL: 'https://api.sambanova.ai/v1',
+            apiKey: '{env:SAMBANOVA_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'openrouter') {
+        config.provider.openrouter = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'OpenRouter',
+          options: {
+            baseURL: 'https://openrouter.ai/api/v1',
+            apiKey: '{env:OPENROUTER_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'codestral') {
+        config.provider.codestral = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Mistral Codestral',
+          options: {
+            baseURL: 'https://codestral.mistral.ai/v1',
+            apiKey: '{env:CODESTRAL_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'hyperbolic') {
+        config.provider.hyperbolic = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Hyperbolic',
+          options: {
+            baseURL: 'https://api.hyperbolic.xyz/v1',
+            apiKey: '{env:HYPERBOLIC_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'scaleway') {
+        config.provider.scaleway = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Scaleway',
+          options: {
+            baseURL: 'https://api.scaleway.ai/v1',
+            apiKey: '{env:SCALEWAY_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'googleai') {
+        config.provider.googleai = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Google AI Studio',
+          options: {
+            baseURL: 'https://generativelanguage.googleapis.com/v1beta/openai',
+            apiKey: '{env:GOOGLE_API_KEY}'
+          },
+          models: {}
+        }
       }
     }
 
     // 📖 Register the model in the provider's models section
-    if (!config.provider[providerKey].models) config.provider[providerKey].models = {}
-    config.provider[providerKey].models[model.modelId] = { name: model.label }
+    // 📖 Only register custom models -- skip if the model maps to a built-in OpenCode ID
+    const isBuiltinMapped = OPENCODE_MODEL_MAP[providerKey]?.[model.modelId]
+    if (!isBuiltinMapped) {
+      if (!config.provider[providerKey].models) config.provider[providerKey].models = {}
+      config.provider[providerKey].models[ocModelId] = { name: model.label }
+    }
 
     config.model = modelRef
     saveOpenCodeConfig(config)
@@ -1243,9 +1443,14 @@ async function startOpenClaw(model, apiKey) {
     config.models.providers.nvidia = {
       baseUrl: 'https://integrate.api.nvidia.com/v1',
       api: 'openai-completions',
+      models: [],
     }
     console.log(chalk.dim('  ➕ Added nvidia provider block to OpenClaw config (models.providers.nvidia)'))
   }
+  // 📖 Ensure models array exists even if the provider block was created by an older version
+  if (!Array.isArray(config.models.providers.nvidia.models)) {
+    config.models.providers.nvidia.models = []
+  }
 
   // 📖 Store API key in the root "env" section so OpenClaw can read it as NVIDIA_API_KEY env var.
   // 📖 Only writes if not already set to avoid overwriting an existing key.
@@ -1450,7 +1655,7 @@ async function main() {
   // 📖 Clamp scrollOffset so cursor is always within the visible viewport window.
   // 📖 Called after every cursor move, sort change, and terminal resize.
   const adjustScrollOffset = (st) => {
-    const total = st.results.length
+    const total = st.visibleSorted ? st.visibleSorted.length : st.results.filter(r => !r.hidden).length
     let maxSlots = st.terminalRows - 10  // 5 header + 5 footer
     if (maxSlots < 1) maxSlots = 1
     if (total <= maxSlots) { st.scrollOffset = 0; return }
@@ -1497,6 +1702,8 @@ async function main() {
     settingsEditBuffer: '',       // 📖 Typed characters for the API key being edited
     settingsTestResults: {},      // 📖 { providerKey: 'pending'|'ok'|'fail'|null }
     config,                       // 📖 Live reference to the config object (updated on save)
+    visibleSorted: [],            // 📖 Cached visible+sorted models — shared between render loop and key handlers
+    helpVisible: false,           // 📖 Whether the help overlay (K key) is active
   }
 
   // 📖 Re-clamp viewport on terminal resize
@@ -1522,10 +1729,19 @@ async function main() {
   // 📖 0=All, 1=S+, 2=S, 3=A+, 4=A, 5=A-, 6=B+, 7=B, 8=C
   const TIER_CYCLE = [null, 'S+', 'S', 'A+', 'A', 'A-', 'B+', 'B', 'C']
   let tierFilterMode = 0
+
+  // 📖 originFilterMode: index into ORIGIN_CYCLE, 0=All, then each provider key in order
+  const ORIGIN_CYCLE = [null, ...Object.keys(sources)]
+  let originFilterMode = 0
+
   function applyTierFilter() {
     const activeTier = TIER_CYCLE[tierFilterMode]
+    const activeOrigin = ORIGIN_CYCLE[originFilterMode]
     state.results.forEach(r => {
-      r.hidden = activeTier !== null && r.tier !== activeTier
+      // 📖 Apply both tier and origin filters — model is hidden if it fails either
+      const tierHide = activeTier !== null && r.tier !== activeTier
+      const originHide = activeOrigin !== null && r.providerKey !== activeOrigin
+      r.hidden = tierHide || originHide
     })
     return state.results
   }
@@ -1595,6 +1811,42 @@ async function main() {
     return cleared.join('\n')
   }
 
+  // ─── Help overlay renderer ────────────────────────────────────────────────
+  // 📖 renderHelp: Draw the help overlay listing all key bindings.
+  // 📖 Toggled with K key. Gives users a quick reference without leaving the TUI.
+  function renderHelp() {
+    const EL = '\x1b[K'
+    const lines = []
+    lines.push('')
+    lines.push(`  ${chalk.bold('❓ Keyboard Shortcuts')}  ${chalk.dim('— press K or Esc to close')}`)
+    lines.push('')
+    lines.push(`  ${chalk.bold('Navigation')}`)
+    lines.push(`  ${chalk.yellow('↑↓')}           Navigate rows`)
+    lines.push(`  ${chalk.yellow('Enter')}        Select model and launch`)
+    lines.push('')
+    lines.push(`  ${chalk.bold('Sorting')}`)
+    lines.push(`  ${chalk.yellow('R')} Rank  ${chalk.yellow('Y')} Tier  ${chalk.yellow('O')} Origin  ${chalk.yellow('M')} Model`)
+    lines.push(`  ${chalk.yellow('L')} Latest ping  ${chalk.yellow('A')} Avg ping  ${chalk.yellow('S')} SWE-bench score`)
+    lines.push(`  ${chalk.yellow('C')} Context window  ${chalk.yellow('H')} Health  ${chalk.yellow('V')} Verdict  ${chalk.yellow('U')} Uptime`)
+    lines.push('')
+    lines.push(`  ${chalk.bold('Filters')}`)
+    lines.push(`  ${chalk.yellow('T')}  Cycle tier filter  ${chalk.dim('(All → S+ → S → A+ → A → A- → B+ → B → C → All)')}`)
+    lines.push(`  ${chalk.yellow('N')}  Cycle origin filter  ${chalk.dim('(All → NIM → Groq → Cerebras → ... each provider → All)')}`)
+    lines.push('')
+    lines.push(`  ${chalk.bold('Controls')}`)
+    lines.push(`  ${chalk.yellow('W')}  Decrease ping interval (faster)`)
+    lines.push(`  ${chalk.yellow('X')}  Increase ping interval (slower)`)
+    lines.push(`  ${chalk.yellow('Z')}  Cycle launch mode  ${chalk.dim('(OpenCode CLI → OpenCode Desktop → OpenClaw)')}`)
+    lines.push(`  ${chalk.yellow('P')}  Open settings  ${chalk.dim('(manage API keys per provider, enable/disable, test)')}`)
+    lines.push(`  ${chalk.yellow('K')} / ${chalk.yellow('Esc')}  Show/hide this help`)
+    lines.push(`  ${chalk.yellow('Ctrl+C')}  Exit`)
+    lines.push('')
+    const cleared = lines.map(l => l + EL)
+    const remaining = state.terminalRows > 0 ? Math.max(0, state.terminalRows - cleared.length) : 0
+    for (let i = 0; i < remaining; i++) cleared.push(EL)
+    return cleared.join('\n')
+  }
+
   // ─── Settings key test helper ───────────────────────────────────────────────
   // 📖 Fires a single ping to the selected provider to verify the API key works.
   async function testProviderKey(providerKey) {
@@ -1630,6 +1882,12 @@ async function main() {
   const onKeyPress = async (str, key) => {
     if (!key) return
 
+    // 📖 Help overlay: Esc or K closes it — handle before everything else so Esc isn't swallowed elsewhere
+    if (state.helpVisible && (key.name === 'escape' || key.name === 'k')) {
+      state.helpVisible = false
+      return
+    }
+
     // ─── Settings overlay keyboard handling ───────────────────────────────────
     if (state.settingsOpen) {
       const providerKeys = Object.keys(sources)
@@ -1737,11 +1995,12 @@ async function main() {
       return
     }
 
-    // 📖 Sorting keys: R=rank, Y=tier, O=origin, M=model, L=latest ping, A=avg ping, S=SWE-bench, N=context, H=health, V=verdict, U=uptime
+    // 📖 Sorting keys: R=rank, Y=tier, O=origin, M=model, L=latest ping, A=avg ping, S=SWE-bench, C=context, H=health, V=verdict, U=uptime
     // 📖 T is reserved for tier filter cycling — tier sort moved to Y
+    // 📖 N is now reserved for origin filter cycling
     const sortKeys = {
       'r': 'rank', 'y': 'tier', 'o': 'origin', 'm': 'model',
-      'l': 'ping', 'a': 'avg', 's': 'swe', 'n': 'ctx', 'h': 'condition', 'v': 'verdict', 'u': 'uptime'
+      'l': 'ping', 'a': 'avg', 's': 'swe', 'c': 'ctx', 'h': 'condition', 'v': 'verdict', 'u': 'uptime'
     }
 
     if (sortKeys[key.name] && !key.ctrl) {
@@ -1753,7 +2012,11 @@ async function main() {
         state.sortColumn = col
         state.sortDirection = 'asc'
       }
-      adjustScrollOffset(state)
+      // 📖 Recompute visible sorted list and reset cursor to top to avoid stale index
+      const visible = state.results.filter(r => !r.hidden)
+      state.visibleSorted = sortResults(visible, state.sortColumn, state.sortDirection)
+      state.cursor = 0
+      state.scrollOffset = 0
       return
     }
 
@@ -1769,7 +2032,29 @@ async function main() {
     if (key.name === 't') {
       tierFilterMode = (tierFilterMode + 1) % TIER_CYCLE.length
       applyTierFilter()
-      adjustScrollOffset(state)
+      // 📖 Recompute visible sorted list and reset cursor to avoid stale index into new filtered set
+      const visible = state.results.filter(r => !r.hidden)
+      state.visibleSorted = sortResults(visible, state.sortColumn, state.sortDirection)
+      state.cursor = 0
+      state.scrollOffset = 0
+      return
+    }
+
+    // 📖 Origin filter key: N = cycle through each provider (All → NIM → Groq → ... → All)
+    if (key.name === 'n') {
+      originFilterMode = (originFilterMode + 1) % ORIGIN_CYCLE.length
+      applyTierFilter()
+      // 📖 Recompute visible sorted list and reset cursor to avoid stale index into new filtered set
+      const visible = state.results.filter(r => !r.hidden)
+      state.visibleSorted = sortResults(visible, state.sortColumn, state.sortDirection)
+      state.cursor = 0
+      state.scrollOffset = 0
+      return
+    }
+
+    // 📖 Help overlay key: K = toggle help overlay
+    if (key.name === 'k') {
+      state.helpVisible = !state.helpVisible
       return
     }
 
@@ -1796,7 +2081,7 @@ async function main() {
     }
 
     if (key.name === 'down') {
-      if (state.cursor < results.length - 1) {
+      if (state.cursor < state.visibleSorted.length - 1) {
         state.cursor++
         adjustScrollOffset(state)
       }
@@ -1809,9 +2094,9 @@ async function main() {
     }
 
     if (key.name === 'return') { // Enter
-      // 📖 Use the same sorting as the table display
-      const sorted = sortResults(results, state.sortColumn, state.sortDirection)
-      const selected = sorted[state.cursor]
+      // 📖 Use the cached visible+sorted array — guaranteed to match what's on screen
+      const selected = state.visibleSorted[state.cursor]
+      if (!selected) return // 📖 Guard: empty visible list (all filtered out)
       // 📖 Allow selecting ANY model (even timeout/down) - user knows what they're doing
       userSelected = { modelId: selected.modelId, label: selected.label, tier: selected.tier, providerKey: selected.providerKey }
 
@@ -1834,13 +2119,24 @@ async function main() {
       }
       console.log()
 
+      // 📖 Warn if no API key is configured for the selected model's provider
+      if (state.mode !== 'openclaw') {
+        const selectedApiKey = getApiKey(state.config, selected.providerKey)
+        if (!selectedApiKey) {
+          console.log(chalk.yellow(`  Warning: No API key configured for ${selected.providerKey}.`))
+          console.log(chalk.yellow(`  OpenCode may not be able to use ${selected.label}.`))
+          console.log(chalk.dim(`  Set ${ENV_VAR_NAMES[selected.providerKey] || selected.providerKey.toUpperCase() + '_API_KEY'} or configure via settings (P key).`))
+          console.log()
+        }
+      }
+
       // 📖 Dispatch to the correct integration based on active mode
       if (state.mode === 'openclaw') {
         await startOpenClaw(userSelected, apiKey)
       } else if (state.mode === 'opencode-desktop') {
-        await startOpenCodeDesktop(userSelected)
+        await startOpenCodeDesktop(userSelected, state.config)
       } else {
-        await startOpenCode(userSelected)
+        await startOpenCode(userSelected, state.config)
       }
       process.exit(0)
     }
@@ -1857,13 +2153,24 @@ async function main() {
   // 📖 Animation loop: render settings overlay OR main table based on state
   const ticker = setInterval(() => {
     state.frame++
+    // 📖 Cache visible+sorted models each frame so Enter handler always matches the display
+    if (!state.settingsOpen) {
+      const visible = state.results.filter(r => !r.hidden)
+      state.visibleSorted = sortResults(visible, state.sortColumn, state.sortDirection)
+    }
     const content = state.settingsOpen
       ? renderSettings()
-      : renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, tierFilterMode, state.scrollOffset, state.terminalRows)
+      : state.helpVisible
+        ? renderHelp()
+        : renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, tierFilterMode, state.scrollOffset, state.terminalRows, originFilterMode)
     process.stdout.write(ALT_HOME + content)
   }, Math.round(1000 / FPS))
 
-  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, tierFilterMode, state.scrollOffset, state.terminalRows))
+  // 📖 Populate visibleSorted before the first frame so Enter works immediately
+  const initialVisible = state.results.filter(r => !r.hidden)
+  state.visibleSorted = sortResults(initialVisible, state.sortColumn, state.sortDirection)
+
+  process.stdout.write(ALT_HOME + renderTable(state.results, state.pendingPings, state.frame, state.cursor, state.sortColumn, state.sortDirection, state.pingInterval, state.lastPingTime, state.mode, tierFilterMode, state.scrollOffset, state.terminalRows, originFilterMode))
 
   // ── Continuous ping loop — ping all models every N seconds forever ──────────
 

package/lib/config.js

@@ -12,14 +12,26 @@
  * 📖 Config JSON structure:
  *   {
  *     "apiKeys": {
- *       "nvidia":   "nvapi-xxx",
- *       "groq":     "gsk_xxx",
- *       "cerebras": "csk_xxx"
+ *       "nvidia":     "nvapi-xxx",
+ *       "groq":       "gsk_xxx",
+ *       "cerebras":   "csk_xxx",
+ *       "sambanova":  "sn-xxx",
+ *       "openrouter": "sk-or-xxx",
+ *       "codestral":  "csk-xxx",
+ *       "hyperbolic": "eyJ...",
+ *       "scaleway":   "scw-xxx",
+ *       "googleai":   "AIza..."
  *     },
  *     "providers": {
- *       "nvidia":   { "enabled": true },
- *       "groq":     { "enabled": true },
- *       "cerebras": { "enabled": true }
+ *       "nvidia":     { "enabled": true },
+ *       "groq":       { "enabled": true },
+ *       "cerebras":   { "enabled": true },
+ *       "sambanova":  { "enabled": true },
+ *       "openrouter": { "enabled": true },
+ *       "codestral":  { "enabled": true },
+ *       "hyperbolic": { "enabled": true },
+ *       "scaleway":   { "enabled": true },
+ *       "googleai":   { "enabled": true }
  *     }
  *   }
  *
@@ -52,9 +64,15 @@ const LEGACY_CONFIG_PATH = join(homedir(), '.free-coding-models')
 // 📖 Environment variable names per provider
 // 📖 These allow users to override config via env vars (useful for CI/headless setups)
 const ENV_VARS = {
-  nvidia:   'NVIDIA_API_KEY',
-  groq:     'GROQ_API_KEY',
-  cerebras: 'CEREBRAS_API_KEY',
+  nvidia:     'NVIDIA_API_KEY',
+  groq:       'GROQ_API_KEY',
+  cerebras:   'CEREBRAS_API_KEY',
+  sambanova:  'SAMBANOVA_API_KEY',
+  openrouter: 'OPENROUTER_API_KEY',
+  codestral:  'CODESTRAL_API_KEY',
+  hyperbolic: 'HYPERBOLIC_API_KEY',
+  scaleway:   'SCALEWAY_API_KEY',
+  googleai:   'GOOGLE_API_KEY',
 }
 
 /**

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.51",
-  "description": "Find the fastest coding LLM models in seconds — ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
+  "version": "0.1.54",
+  "description": "Find the fastest coding LLM models in seconds \u2014 ping free models from multiple providers, pick the best one for OpenCode, Cursor, or any AI coding assistant.",
   "keywords": [
     "nvidia",
     "nim",

package/sources.js

@@ -27,8 +27,8 @@
  *   📖 Secondary: https://swe-rebench.com (independent evals, scores are lower)
  *   📖 Leaderboard tracker: https://www.marc0.dev/en/leaderboard
  *
- *   @exports nvidiaNim, groq, cerebras — model arrays per provider
- *   @exports sources — map of { nvidia, groq, cerebras } each with { name, url, models }
+ *   @exports nvidiaNim, groq, cerebras, sambanova, openrouter, codestral, hyperbolic, scaleway, googleai — model arrays per provider
+ *   @exports sources — map of { nvidia, groq, cerebras, sambanova, openrouter, codestral, hyperbolic, scaleway, googleai } each with { name, url, models }
  *   @exports MODELS — flat array of [modelId, label, tier, sweScore, ctx, providerKey]
  *
  *   📖 MODELS now includes providerKey as 6th element so ping() knows which
@@ -100,6 +100,10 @@ export const groq = [
   ['deepseek-r1-distill-llama-70b',        'R1 Distill 70B',     'A',  '43.9%', '128k'],
   ['qwen-qwq-32b',                         'QwQ 32B',            'A+', '50.0%', '131k'],
   ['moonshotai/kimi-k2-instruct',          'Kimi K2 Instruct',   'S',  '65.8%', '131k'],
+  ['llama-3.1-8b-instant',                 'Llama 3.1 8B',       'B',  '28.8%', '128k'],
+  ['openai/gpt-oss-120b',                  'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['openai/gpt-oss-20b',                   'GPT OSS 20B',        'A',  '42.0%', '128k'],
+  ['qwen/qwen3-32b',                       'Qwen3 32B',          'A+', '50.0%', '131k'],
 ]
 
 // 📖 Cerebras source - https://cloud.cerebras.ai
@@ -108,6 +112,89 @@ export const cerebras = [
   ['llama3.3-70b',                         'Llama 3.3 70B',      'A-', '39.5%', '128k'],
   ['llama-4-scout-17b-16e-instruct',       'Llama 4 Scout',      'A',  '44.0%', '10M'],
   ['qwen-3-32b',                           'Qwen3 32B',          'A+', '50.0%', '128k'],
+  ['gpt-oss-120b',                         'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['qwen-3-235b-a22b',                     'Qwen3 235B',         'S+', '70.0%', '128k'],
+  ['llama3.1-8b',                          'Llama 3.1 8B',       'B',  '28.8%', '128k'],
+  ['glm-4.6',                              'GLM 4.6',            'A-', '38.0%', '128k'],
+]
+
+// 📖 SambaNova source - https://cloud.sambanova.ai
+// 📖 Free trial: $5 credits for 3 months — API keys at https://cloud.sambanova.ai/apis
+// 📖 OpenAI-compatible API, supports all major coding models including DeepSeek V3/R1, Qwen3, Llama 4
+export const sambanova = [
+  // ── S+ tier ──
+  ['Qwen3-235B-A22B-Instruct-2507',        'Qwen3 235B',         'S+', '70.0%', '128k'],
+  // ── S tier ──
+  ['DeepSeek-R1-0528',                     'DeepSeek R1 0528',   'S',  '61.0%', '128k'],
+  ['DeepSeek-V3.1',                        'DeepSeek V3.1',      'S',  '62.0%', '128k'],
+  ['DeepSeek-V3-0324',                     'DeepSeek V3 0324',   'S',  '62.0%', '128k'],
+  ['Llama-4-Maverick-17B-128E-Instruct',   'Llama 4 Maverick',   'S',  '62.0%', '1M'],
+  ['gpt-oss-120b',                         'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['deepseek-ai/DeepSeek-V3.1-Terminus',   'DeepSeek V3.1 Term', 'S',  '68.4%', '128k'],
+  // ── A+ tier ──
+  ['Qwen3-32B',                            'Qwen3 32B',          'A+', '50.0%', '128k'],
+  // ── A tier ──
+  ['DeepSeek-R1-Distill-Llama-70B',        'R1 Distill 70B',     'A',  '43.9%', '128k'],
+  // ── A- tier ──
+  ['Meta-Llama-3.3-70B-Instruct',          'Llama 3.3 70B',      'A-', '39.5%', '128k'],
+  // ── B tier ──
+  ['Meta-Llama-3.1-8B-Instruct',           'Llama 3.1 8B',       'B',  '28.8%', '128k'],
+]
+
+// 📖 OpenRouter source - https://openrouter.ai
+// 📖 Free :free models with shared quota — 50 free req/day
+// 📖 API keys at https://openrouter.ai/settings/keys
+export const openrouter = [
+  ['qwen/qwen3-coder:free',                    'Qwen3 Coder',        'S+', '70.6%', '256k'],
+  ['stepfun/step-3.5-flash:free',              'Step 3.5 Flash',     'S+', '74.4%', '256k'],
+  ['deepseek/deepseek-r1-0528:free',           'DeepSeek R1 0528',   'S',  '61.0%', '128k'],
+  ['qwen/qwen3-next-80b-a3b-instruct:free',    'Qwen3 80B Instruct', 'S',  '65.0%', '128k'],
+  ['openai/gpt-oss-120b:free',                 'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['openai/gpt-oss-20b:free',                  'GPT OSS 20B',        'A',  '42.0%', '128k'],
+  ['nvidia/nemotron-3-nano-30b-a3b:free',      'Nemotron Nano 30B',  'A',  '43.0%', '128k'],
+  ['meta-llama/llama-3.3-70b-instruct:free',   'Llama 3.3 70B',      'A-', '39.5%', '128k'],
+]
+
+// 📖 Mistral Codestral source - https://codestral.mistral.ai
+// 📖 Free coding model — 30 req/min, 2000/day (phone number required for key)
+// 📖 API keys at https://codestral.mistral.ai
+export const codestral = [
+  ['codestral-latest',                         'Codestral',          'B+', '34.0%', '256k'],
+]
+
+// 📖 Hyperbolic source - https://app.hyperbolic.ai
+// 📖 $1 free trial credits — API keys at https://app.hyperbolic.xyz/settings
+export const hyperbolic = [
+  ['qwen/qwen3-coder-480b-a35b-instruct',      'Qwen3 Coder 480B',   'S+', '70.6%', '256k'],
+  ['deepseek-ai/DeepSeek-R1-0528',             'DeepSeek R1 0528',   'S',  '61.0%', '128k'],
+  ['moonshotai/Kimi-K2-Instruct',              'Kimi K2 Instruct',   'S',  '65.8%', '131k'],
+  ['openai/gpt-oss-120b',                      'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['Qwen/Qwen3-235B-A22B',                     'Qwen3 235B',         'S+', '70.0%', '128k'],
+  ['qwen/qwen3-next-80b-a3b-instruct',         'Qwen3 80B Instruct', 'S',  '65.0%', '128k'],
+  ['deepseek-ai/DeepSeek-V3-0324',             'DeepSeek V3 0324',   'S',  '62.0%', '128k'],
+  ['Qwen/Qwen2.5-Coder-32B-Instruct',          'Qwen2.5 Coder 32B',  'A',  '46.0%', '32k'],
+  ['meta-llama/Llama-3.3-70B-Instruct',        'Llama 3.3 70B',      'A-', '39.5%', '128k'],
+  ['meta-llama/Meta-Llama-3.1-405B-Instruct',  'Llama 3.1 405B',     'A',  '44.0%', '128k'],
+]
+
+// 📖 Scaleway source - https://console.scaleway.com
+// 📖 1M free tokens — API keys at https://console.scaleway.com/iam/api-keys
+export const scaleway = [
+  ['devstral-2-123b-instruct-2512',            'Devstral 2 123B',    'S+', '72.2%', '256k'],
+  ['qwen3-235b-a22b-instruct-2507',            'Qwen3 235B',         'S+', '70.0%', '128k'],
+  ['gpt-oss-120b',                             'GPT OSS 120B',       'S',  '60.0%', '128k'],
+  ['qwen3-coder-30b-a3b-instruct',             'Qwen3 Coder 30B',    'A+', '55.0%', '32k'],
+  ['llama-3.3-70b-instruct',                   'Llama 3.3 70B',      'A-', '39.5%', '128k'],
+  ['deepseek-r1-distill-llama-70b',            'R1 Distill 70B',     'A',  '43.9%', '128k'],
+  ['mistral-small-3.2-24b-instruct-2506',      'Mistral Small 3.2',  'B+', '30.0%', '128k'],
+]
+
+// 📖 Google AI Studio source - https://aistudio.google.com
+// 📖 Free Gemma models — 14.4K req/day, API keys at https://aistudio.google.com/apikey
+export const googleai = [
+  ['gemma-3-27b-it',                           'Gemma 3 27B',        'B',  '22.0%', '128k'],
+  ['gemma-3-12b-it',                           'Gemma 3 12B',        'C',  '15.0%', '128k'],
+  ['gemma-3-4b-it',                            'Gemma 3 4B',         'C',  '10.0%', '128k'],
 ]
 
 // 📖 All sources combined - used by the main script
@@ -128,6 +215,36 @@ export const sources = {
     url: 'https://api.cerebras.ai/v1/chat/completions',
     models: cerebras,
   },
+  sambanova: {
+    name: 'SambaNova',
+    url: 'https://api.sambanova.ai/v1/chat/completions',
+    models: sambanova,
+  },
+  openrouter: {
+    name: 'OpenRouter',
+    url: 'https://openrouter.ai/api/v1/chat/completions',
+    models: openrouter,
+  },
+  codestral: {
+    name: 'Codestral',
+    url: 'https://codestral.mistral.ai/v1/chat/completions',
+    models: codestral,
+  },
+  hyperbolic: {
+    name: 'Hyperbolic',
+    url: 'https://api.hyperbolic.xyz/v1/chat/completions',
+    models: hyperbolic,
+  },
+  scaleway: {
+    name: 'Scaleway',
+    url: 'https://api.scaleway.ai/v1/chat/completions',
+    models: scaleway,
+  },
+  googleai: {
+    name: 'Google AI',
+    url: 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions',
+    models: googleai,
+  },
 }
 
 // 📖 Flatten all models from all sources — each entry includes providerKey as 6th element