free-coding-models 0.1.42 → 0.1.44

package/README.md

@@ -2,7 +2,8 @@
   <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/nvidia%20nim%20models-44-76b900?logo=nvidia" alt="models count">
+  <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">
 </p>
 
 <h1 align="center">free-coding-models</h1>
@@ -14,7 +15,7 @@
 <p align="center">
 
 ```
-1. Create a free API key on NVIDIA → https://build.nvidia.com
+1. Create a free API key (NVIDIA, Groq, or Cerebras)
 2. npm i -g free-coding-models
 3. free-coding-models
 ```
@@ -23,7 +24,7 @@
 
 <p align="center">
   <strong>Find the fastest coding LLM models in seconds</strong><br>
-  <sub>Ping free NVIDIA NIM models in real-time — pick the best one for OpenCode, OpenClaw, or any AI coding assistant</sub>
+  <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>
 </p>
 
 <p align="center">
@@ -46,7 +47,9 @@
 ## ✨ Features
 
 - **🎯 Coding-focused** — Only LLM models optimized for code generation, not chat or vision
-- **🚀 Parallel pings** — All 44 models tested simultaneously via native `fetch`
+- **🌐 Multi-provider** — 53 models from NVIDIA NIM, Groq, and Cerebras — 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
 - **🏆 Smart ranking** — Top 3 fastest models highlighted with medals 🥇🥈🥉
 - **⏱ Continuous monitoring** — Pings all models every 2 seconds forever, never stops
@@ -59,8 +62,7 @@
 - **🦞 OpenClaw integration** — Sets selected model as default provider in `~/.openclaw/openclaw.json`
 - **🎨 Clean output** — Zero scrollback pollution, interface stays open until Ctrl+C
 - **📶 Status indicators** — UP ✅ · Timeout ⏳ · Overloaded 🔥 · Not Found 🚫
-- **🔧 Multi-source support** — Extensible architecture via `sources.js` (add new providers easily)
-- **🏷 Tier filtering** — Filter models by tier letter (S, A, B, C) with `--tier` flag or dynamically with E/D keys
+- **🏷 Tier filtering** — Filter models by tier letter (S, A, B, C) with `--tier` flag or dynamically with `T` key
 
 ---
 
@@ -69,12 +71,14 @@
 Before using `free-coding-models`, make sure you have:
 
 1. **Node.js 18+** — Required for native `fetch` API
-2. **NVIDIA NIM account** — Free tier available at [build.nvidia.com](https://build.nvidia.com)
-3. **API key** — Generate one from Profile → API Keys → Generate API Key
-4. **OpenCode** *(optional)* — [Install OpenCode](https://github.com/opencode-ai/opencode) to use the OpenCode integration
-5. **OpenClaw** *(optional)* — [Install OpenClaw](https://openclaw.ai) to use the OpenClaw integration
+2. **At least one free API key** — pick any or all of:
+   - **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
+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:** Without OpenCode/OpenClaw installed, you can still benchmark models and get latency data.
+> 💡 **Tip:** You don't need all three providers. One key is enough to get started. Add more later via the Settings screen (`P` key).
 
 ---
 
@@ -152,54 +156,98 @@ 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 44 models are pinged in parallel
+1. **Ping phase** — All enabled models are pinged in parallel (up to 53 across 3 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:
+Setup wizard (first run — walks through all 3 providers):
 
 ```
-  🔑 Setup your NVIDIA API key
-  📝 Get a free key at: https://build.nvidia.com
-  💾 Key will be saved to ~/.free-coding-models
+  🔑 First-time setup — API keys
+  Enter keys for any provider you want to use. Press Enter to skip one.
+
+  ● NVIDIA NIM
+    Free key at: https://build.nvidia.com
+    Profile → API Keys → Generate
+  Enter key (or Enter to skip): nvapi-xxxx
+
+  ● Groq
+    Free key at: https://console.groq.com/keys
+    API Keys → Create API Key
+  Enter key (or Enter to skip): gsk_xxxx
+
+  ● Cerebras
+    Free key at: https://cloud.cerebras.ai
+    API Keys → Create
+  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.
 
-  Enter your API key: nvapi-xxxx-xxxx
+### Adding or changing keys later
+
+Press **`P`** to open the Settings screen at any time:
 
-  ✅ API key saved to ~/.free-coding-models
 ```
+  ⚙  Settings
 
-### Other ways to provide the key
+  Providers
 
-```bash
-# Pass directly
-free-coding-models nvapi-xxxx-your-key-here
+  ❯ [ ✅ ] NIM         nvapi-••••••••••••3f9a  [Test ✅]
+    [ ✅ ] Groq        (no key set)            [Test —]
+    [ ✅ ] Cerebras    (no key set)            [Test —]
 
-# Use environment variable
-NVIDIA_API_KEY=nvapi-xxx free-coding-models
+  ↑↓ Navigate  •  Enter Edit key  •  Space Toggle enabled  •  T Test key  •  Esc Close
+```
 
-# Or add to your shell profile
-export NVIDIA_API_KEY=nvapi-xxxx-your-key-here
-free-coding-models
+- **↑↓** — navigate providers
+- **Enter** — enter inline key edit mode (type your key, Enter to save, Esc to cancel)
+- **Space** — toggle provider enabled/disabled
+- **T** — fire a real test ping to verify the key works (shows ✅/❌)
+- **Esc** — close settings and reload models list
+
+Keys are saved to `~/.free-coding-models.json` (permissions `0600`).
+
+### Environment variable overrides
+
+Env vars always take priority over the config file:
+
+```bash
+NVIDIA_API_KEY=nvapi-xxx free-coding-models
+GROQ_API_KEY=gsk_xxx free-coding-models
+CEREBRAS_API_KEY=csk_xxx free-coding-models
 ```
 
-### Get your free API key
+### Get your free API keys
+
+**NVIDIA NIM** (44 models, S+ → C tier):
+1. Sign up at [build.nvidia.com](https://build.nvidia.com)
+2. Go to Profile → API Keys → Generate API Key
+3. Name it (e.g. "free-coding-models"), set expiry to "Never"
+4. Copy — shown only once!
+
+**Groq** (6 models, fast inference):
+1. Sign up at [console.groq.com](https://console.groq.com)
+2. Go to API Keys → Create API Key
 
-1. **Create NVIDIA Account** — Sign up at [build.nvidia.com](https://build.nvidia.com) with your email
-2. **Verify** — Confirm email, set privacy options, create NGC account, verify phone
-3. **Generate Key** — Go to Profile → API Keys → Generate API Key
-4. **Name it** — e.g., "free-coding-models" or "OpenCode-NIM"
-5. **Set expiration** — Choose "Never" for convenience
-6. **Copy securely** — Key is shown only once!
+**Cerebras** (3 models, ultra-fast silicon):
+1. Sign up at [cloud.cerebras.ai](https://cloud.cerebras.ai)
+2. Go to API Keys → Create
 
-> 💡 **Free credits** — NVIDIA offers free credits for NIM models via their API Catalog for developers.
+> 💡 **Free credits** — All three providers offer free tiers for developers.
 
 ---
 
 ## 🤖 Coding Models
 
-**44 coding models** across 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.
+**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.
+
+### NVIDIA NIM (44 models)
 
 | Tier | SWE-bench | Models |
 |------|-----------|--------|
@@ -212,6 +260,23 @@ free-coding-models
 | **B** 20–30% | R1 Distill 8B (28.2%), R1 Distill 7B (22.6%) |
 | **C** <20% | Gemma 2 9B (18.0%), Phi 4 Mini (14.0%), Phi 3.5 Mini (12.0%) |
 
+### Groq (6 models)
+
+| Tier | SWE-bench | Model |
+|------|-----------|-------|
+| **S** 60–70% | Kimi K2 Instruct (65.8%), Llama 4 Maverick (62.0%) |
+| **A+** 50–60% | QwQ 32B (50.0%) |
+| **A** 40–50% | Llama 4 Scout (44.0%), R1 Distill 70B (43.9%) |
+| **A-** 35–40% | Llama 3.3 70B (39.5%) |
+
+### Cerebras (3 models)
+
+| Tier | SWE-bench | Model |
+|------|-----------|-------|
+| **A+** 50–60% | Qwen3 32B (50.0%) |
+| **A** 40–50% | Llama 4 Scout (44.0%) |
+| **A-** 35–40% | Llama 3.3 70B (39.5%) |
+
 ### Tier scale
 
 - **S+/S** — Elite frontier coders (≥60% SWE-bench), best for complex real-world tasks and refactors
@@ -421,10 +486,30 @@ This script:
 
 ## 📋 API Reference
 
-| Parameter | Description |
-|-----------|-------------|
-| `NVIDIA_API_KEY` | Environment variable for API key |
-| `<api-key>` | First positional argument |
+**Environment variables (override config file):**
+
+| Variable | Provider |
+|----------|----------|
+| `NVIDIA_API_KEY` | NVIDIA NIM |
+| `GROQ_API_KEY` | Groq |
+| `CEREBRAS_API_KEY` | Cerebras |
+
+**Config file:** `~/.free-coding-models.json` (created automatically, permissions `0600`)
+
+```json
+{
+  "apiKeys": {
+    "nvidia":   "nvapi-xxx",
+    "groq":     "gsk_xxx",
+    "cerebras": "csk_xxx"
+  },
+  "providers": {
+    "nvidia":   { "enabled": true },
+    "groq":     { "enabled": true },
+    "cerebras": { "enabled": true }
+  }
+}
+```
 
 **Configuration:**
 - **Ping timeout**: 15 seconds per attempt (slow models get more time)
@@ -446,16 +531,24 @@ This script:
 | `--tier B` | Show only B+, B tier models |
 | `--tier C` | Show only C tier models |
 
-**Keyboard shortcuts:**
+**Keyboard shortcuts (main TUI):**
 - **↑↓** — Navigate models
 - **Enter** — Select model (launches OpenCode or sets OpenClaw default, depending on mode)
-- **R/T/O/M/P/A/S/V/U** — Sort by Rank/Tier/Origin/Model/Ping/Avg/Status/Verdict/Uptime
+- **R/Y/O/M/L/A/S/N/H/V/U** — Sort by Rank/Tier/Origin/Model/LatestPing/Avg/SWE/Ctx/Health/Verdict/Uptime
+- **T** — Cycle tier filter (All → S+ → S → A+ → A → A- → B+ → B → C → All)
+- **Z** — Cycle mode (OpenCode CLI → OpenCode Desktop → OpenClaw)
+- **P** — Open Settings (manage API keys, enable/disable providers)
 - **W** — Decrease ping interval (faster pings)
 - **X** — Increase ping interval (slower pings)
-- **E** — Elevate tier filter (show fewer, higher-tier models)
-- **D** — Descend tier filter (show more, lower-tier models)
 - **Ctrl+C** — Exit
 
+**Keyboard shortcuts (Settings screen — `P` key):**
+- **↑↓** — Navigate providers
+- **Enter** — Edit API key inline (type key, Enter to save, Esc to cancel)
+- **Space** — Toggle provider enabled/disabled
+- **T** — Test current provider's API key (fires a live ping)
+- **Esc** — Close settings and return to main TUI
+
 ---
 
 ## 🔧 Development

package/bin/free-coding-models.js

@@ -10,7 +10,7 @@
  *   During benchmarking, users can navigate with arrow keys and press Enter to act on the selected model.
  *
  *   🎯 Key features:
- *   - Parallel pings across all models with animated real-time updates
+ *   - Parallel pings across all models with animated real-time updates (3 providers: NIM, Groq, Cerebras)
  *   - Continuous monitoring with 2-second ping intervals (never stops)
  *   - Rolling averages calculated from ALL successful pings since start
  *   - Best-per-tier highlighting with medals (🥇🥈🥉)
@@ -18,15 +18,16 @@
  *   - Instant OpenCode OR OpenClaw action on Enter key press
  *   - Startup mode menu (OpenCode CLI vs OpenCode Desktop vs OpenClaw) when no flag is given
  *   - Automatic config detection and model setup for both tools
- *   - Persistent API key storage in ~/.free-coding-models
- *   - Multi-source support via sources.js (easily add new providers)
+ *   - JSON config stored in ~/.free-coding-models.json (auto-migrates from old plain-text)
+ *   - Multi-provider support via sources.js (NIM, Groq, Cerebras — extensible)
+ *   - Settings screen (P key) to manage API keys per provider, enable/disable, test keys
  *   - Uptime percentage tracking (successful pings / total pings)
- *   - Sortable columns (R/T/O/M/P/A/S/V/U keys)
- *   - Tier filtering via --tier S/A/B/C flags
+ *   - Sortable columns (R/Y/O/M/L/A/S/N/H/V/U keys)
+ *   - Tier filtering via T key (cycles S+→S→A+→A→A-→B+→B→C→All)
  *
  *   → Functions:
- *   - `loadApiKey` / `saveApiKey`: Manage persisted API key in ~/.free-coding-models
- *   - `promptApiKey`: Interactive wizard for first-time API key setup
+ *   - `loadConfig` / `saveConfig` / `getApiKey`: Multi-provider JSON config via lib/config.js
+ *   - `promptApiKey`: Interactive wizard for first-time NVIDIA API key setup
  *   - `promptModeSelection`: Startup menu to choose OpenCode vs OpenClaw
  *   - `ping`: Perform HTTP request to NIM endpoint with timeout handling
  *   - `renderTable`: Generate ASCII table with colored latency indicators and status emojis
@@ -49,8 +50,10 @@
  *   - sources.js: Model definitions from all providers
  *
  *   ⚙️ Configuration:
- *   - API key stored in ~/.free-coding-models
- *   - Models loaded from sources.js (extensible for new providers)
+ *   - API keys stored per-provider in ~/.free-coding-models.json (0600 perms)
+ *   - Old ~/.free-coding-models plain-text auto-migrated as nvidia key on first run
+ *   - Env vars override config: NVIDIA_API_KEY, GROQ_API_KEY, CEREBRAS_API_KEY
+ *   - Models loaded from sources.js — 53 models across NIM, Groq, Cerebras
  *   - OpenCode config: ~/.config/opencode/opencode.json
  *   - OpenClaw config: ~/.openclaw/openclaw.json
  *   - Ping timeout: 15s per attempt
@@ -76,9 +79,10 @@ import { createRequire } from 'module'
 import { readFileSync, writeFileSync, existsSync, copyFileSync, mkdirSync } from 'fs'
 import { homedir } from 'os'
 import { join, dirname } from 'path'
-import { MODELS } from '../sources.js'
+import { MODELS, sources } from '../sources.js'
 import { patchOpenClawModelsJson } from '../patch-openclaw-models.js'
 import { getAvg, getVerdict, getUptime, sortResults, filterByTier, findBestModel, parseArgs, TIER_ORDER, VERDICT_ORDER, TIER_LETTER_MAP } from '../lib/utils.js'
+import { loadConfig, saveConfig, getApiKey, isProviderEnabled } from '../lib/config.js'
 
 const require = createRequire(import.meta.url)
 const readline = require('readline')
@@ -154,50 +158,82 @@ function runUpdate(latestVersion) {
   process.exit(1)
 }
 
-// ─── Config path ──────────────────────────────────────────────────────────────
-const CONFIG_PATH = join(homedir(), '.free-coding-models')
-
-function loadApiKey() {
-  try {
-    if (existsSync(CONFIG_PATH)) {
-      return readFileSync(CONFIG_PATH, 'utf8').trim()
-    }
-  } catch {}
-  return null
-}
-
-function saveApiKey(key) {
-  try {
-    writeFileSync(CONFIG_PATH, key, { mode: 0o600 })
-  } catch {}
-}
+// 📖 Config is now managed via lib/config.js (JSON format ~/.free-coding-models.json)
+// 📖 loadConfig/saveConfig/getApiKey are imported above
 
 // ─── First-run wizard ─────────────────────────────────────────────────────────
-async function promptApiKey() {
+// 📖 Shown when NO provider has a key configured yet.
+// 📖 Steps through all 3 providers sequentially — each is optional (Enter to skip).
+// 📖 At least one key must be entered to proceed. Keys saved to ~/.free-coding-models.json.
+// 📖 Returns the nvidia key (or null) for backward-compat with the rest of main().
+async function promptApiKey(config) {
   console.log()
-  console.log(chalk.dim('  🔑 Setup your NVIDIA API key'))
-  console.log(chalk.dim('  📝 Get a free key at: ') + chalk.cyanBright('https://build.nvidia.com'))
-  console.log(chalk.dim('  💾 Key will be saved to ~/.free-coding-models'))
+  console.log(chalk.bold('  🔑 First-time setup — API keys'))
+  console.log(chalk.dim('  Enter keys for any provider you want to use. Press Enter to skip one.'))
   console.log()
 
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout,
-  })
+  // 📖 Provider definitions: label, key field, url for getting the key
+  const providers = [
+    {
+      key: 'nvidia',
+      label: 'NVIDIA NIM',
+      color: chalk.rgb(118, 185, 0),
+      url: 'https://build.nvidia.com',
+      hint: 'Profile → API Keys → Generate',
+      prefix: 'nvapi-',
+    },
+    {
+      key: 'groq',
+      label: 'Groq',
+      color: chalk.rgb(249, 103, 20),
+      url: 'https://console.groq.com/keys',
+      hint: 'API Keys → Create API Key',
+      prefix: 'gsk_',
+    },
+    {
+      key: 'cerebras',
+      label: 'Cerebras',
+      color: chalk.rgb(0, 180, 255),
+      url: 'https://cloud.cerebras.ai',
+      hint: 'API Keys → Create',
+      prefix: 'csk_ / cauth_',
+    },
+  ]
 
-  return new Promise((resolve) => {
-    rl.question(chalk.bold('  Enter your API key: '), (answer) => {
-      rl.close()
-      const key = answer.trim()
-      if (key) {
-        saveApiKey(key)
-        console.log()
-        console.log(chalk.green('  ✅ API key saved to ~/.free-coding-models'))
-        console.log()
-      }
-      resolve(key || null)
-    })
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+  // 📖 Ask a single question — returns trimmed string or '' for skip
+  const ask = (question) => new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()))
   })
+
+  for (const p of providers) {
+    console.log(`  ${p.color('●')} ${chalk.bold(p.label)}`)
+    console.log(chalk.dim(`    Free key at: `) + chalk.cyanBright(p.url))
+    console.log(chalk.dim(`    ${p.hint}`))
+    const answer = await ask(chalk.dim(`  Enter key (or Enter to skip): `))
+    console.log()
+    if (answer) {
+      config.apiKeys[p.key] = answer
+    }
+  }
+
+  rl.close()
+
+  // 📖 Check at least one key was entered
+  const anyKey = Object.values(config.apiKeys).some(v => v)
+  if (!anyKey) {
+    return null
+  }
+
+  saveConfig(config)
+  const savedCount = Object.values(config.apiKeys).filter(v => v).length
+  console.log(chalk.green(`  ✅ ${savedCount} key(s) saved to ~/.free-coding-models.json`))
+  console.log(chalk.dim('  You can add or change keys anytime with the ') + chalk.yellow('P') + chalk.dim(' key in the TUI.'))
+  console.log()
+
+  // 📖 Return nvidia key for backward-compat (main() checks it exists before continuing)
+  return config.apiKeys.nvidia || Object.values(config.apiKeys).find(v => v) || null
 }
 
 // ─── Update notification menu ──────────────────────────────────────────────
@@ -310,7 +346,6 @@ const ALT_HOME   = '\x1b[H'
 // 📖 Models are now loaded from sources.js to support multiple providers
 // 📖 This allows easy addition of new model sources beyond NVIDIA NIM
 
-const NIM_URL      = 'https://integrate.api.nvidia.com/v1/chat/completions'
 const PING_TIMEOUT  = 15_000   // 📖 15s per attempt before abort - slow models get more time
 const PING_INTERVAL = 2_000    // 📖 Ping all models every 2 seconds in continuous mode
 
@@ -519,7 +554,9 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     // 📖 Left-aligned columns - pad plain text first, then colorize
     const num = chalk.dim(String(r.idx).padEnd(W_RANK))
     const tier = tierFn(r.tier.padEnd(W_TIER))
-    const source = chalk.green('NIM'.padEnd(W_SOURCE))
+    // 📖 Show provider name from sources map (NIM / Groq / Cerebras)
+    const providerName = sources[r.providerKey]?.name ?? r.providerKey ?? 'NIM'
+    const source = chalk.green(providerName.padEnd(W_SOURCE))
     const name = r.label.slice(0, W_MODEL).padEnd(W_MODEL)
     const sweScore = r.sweScore ?? '—'
     const sweCell = sweScore !== '—' && parseFloat(sweScore) >= 50 
@@ -663,7 +700,7 @@ 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/T/O/M/L/A/S/C/H/V/U Sort  •  W↓/X↑ Interval (${intervalSec}s)  •  T Tier  •  Z Mode  •  Ctrl+C Exit`))
+  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('')
   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/WKA3TwYVuZ\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('')
@@ -679,12 +716,14 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
 
 // ─── HTTP ping ────────────────────────────────────────────────────────────────
 
-async function ping(apiKey, modelId) {
+// 📖 ping: Send a single chat completion request to measure model availability and latency.
+// 📖 url param is the provider's endpoint URL — differs per provider (NIM, Groq, Cerebras).
+async function ping(apiKey, modelId, url) {
   const ctrl  = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), PING_TIMEOUT)
   const t0    = performance.now()
   try {
-    const resp = await fetch(NIM_URL, {
+    const resp = await fetch(url, {
       method: 'POST', signal: ctrl.signal,
       headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
       body: JSON.stringify({ model: modelId, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
@@ -1101,32 +1140,41 @@ async function startOpenClaw(model, apiKey) {
 // 📖 findBestModel is imported from lib/utils.js
 
 // ─── Function to run in fiable mode (10-second analysis then output best model) ──
-async function runFiableMode(apiKey) {
+async function runFiableMode(config) {
   console.log(chalk.cyan('  ⚡ Analyzing models for reliability (10 seconds)...'))
   console.log()
 
-  let results = MODELS.map(([modelId, label, tier, sweScore, ctx], i) => ({
-    idx: i + 1, modelId, label, tier, sweScore, ctx,
-    status: 'pending',
-    pings: [],
-    httpCode: null,
-  }))
+  // 📖 Only include models from enabled providers that have API keys
+  let results = MODELS
+    .filter(([,,,,,providerKey]) => {
+      return isProviderEnabled(config, providerKey) && getApiKey(config, providerKey)
+    })
+    .map(([modelId, label, tier, sweScore, ctx, providerKey], i) => ({
+      idx: i + 1, modelId, label, tier, sweScore, ctx, providerKey,
+      status: 'pending',
+      pings: [],
+      httpCode: null,
+    }))
 
   const startTime = Date.now()
   const analysisDuration = 10000 // 10 seconds
 
-  // 📖 Run initial pings
-  const pingPromises = results.map(r => ping(apiKey, r.modelId).then(({ code, ms }) => {
-    r.pings.push({ ms, code })
-    if (code === '200') {
-      r.status = 'up'
-    } else if (code === '000') {
-      r.status = 'timeout'
-    } else {
-      r.status = 'down'
-      r.httpCode = code
-    }
-  }))
+  // 📖 Run initial pings using per-provider API key and URL
+  const pingPromises = results.map(r => {
+    const rApiKey = getApiKey(config, r.providerKey)
+    const url = sources[r.providerKey]?.url
+    return ping(rApiKey, r.modelId, url).then(({ code, ms }) => {
+      r.pings.push({ ms, code })
+      if (code === '200') {
+        r.status = 'up'
+      } else if (code === '000') {
+        r.status = 'timeout'
+      } else {
+        r.status = 'down'
+        r.httpCode = code
+      }
+    })
+  })
 
   await Promise.allSettled(pingPromises)
 
@@ -1144,10 +1192,10 @@ async function runFiableMode(apiKey) {
     process.exit(1)
   }
 
-  // 📖 Output in format: provider/name
-  const provider = 'nvidia' // Always NVIDIA NIM for now
+  // 📖 Output in format: providerName/modelId
+  const providerName = sources[best.providerKey]?.name ?? best.providerKey ?? 'nvidia'
   console.log(chalk.green(`  ✓ Most reliable model:`))
-  console.log(chalk.bold(`    ${provider}/${best.modelId}`))
+  console.log(chalk.bold(`    ${providerName}/${best.modelId}`))
   console.log()
   console.log(chalk.dim(`  📊 Stats:`))
   console.log(chalk.dim(`    Avg ping: ${getAvg(best)}ms`))
@@ -1169,20 +1217,26 @@ function filterByTierOrExit(results, tierLetter) {
 }
 
 async function main() {
-  // 📖 Simple CLI without flags - just API key handling
-  let apiKey = process.env.NVIDIA_API_KEY || loadApiKey()
+  // 📖 Load JSON config (auto-migrates old plain-text ~/.free-coding-models if needed)
+  const config = loadConfig()
 
-  if (!apiKey) {
-    apiKey = await promptApiKey()
-    if (!apiKey) {
+  // 📖 Check if any provider has a key — if not, run the first-time setup wizard
+  const hasAnyKey = Object.keys(sources).some(pk => !!getApiKey(config, pk))
+
+  if (!hasAnyKey) {
+    const result = await promptApiKey(config)
+    if (!result) {
       console.log()
       console.log(chalk.red('  ✖ No API key provided.'))
-      console.log(chalk.dim('  Run `free-coding-models` again or set NVIDIA_API_KEY env var.'))
+      console.log(chalk.dim('  Run `free-coding-models` again or set NVIDIA_API_KEY / GROQ_API_KEY / CEREBRAS_API_KEY.'))
       console.log()
       process.exit(1)
     }
   }
 
+  // 📖 Backward-compat: keep apiKey var for startOpenClaw() which still needs it
+  let apiKey = getApiKey(config, 'nvidia')
+
   // 📖 Check for updates in the background
   let latestVersion = null
   try {
@@ -1221,16 +1275,17 @@ async function main() {
     // If action is null (Continue without update) or changelogs, proceed to main app
   }
 
-  // 📖 Create results array with all models initially visible
-  let results = MODELS.map(([modelId, label, tier, sweScore, ctx], i) => ({
-    idx: i + 1, modelId, label, tier, sweScore, ctx,
-    status: 'pending',
-    pings: [],  // 📖 All ping results (ms or 'TIMEOUT')
-    httpCode: null,
-    hidden: false,  // 📖 Simple flag to hide/show models
-  }))
-
-  // 📖 No initial filters - all models visible by default
+  // 📖 Build results from MODELS — only include enabled providers
+  // 📖 Each result gets providerKey so ping() knows which URL + API key to use
+  let results = MODELS
+    .filter(([,,,,,providerKey]) => isProviderEnabled(config, providerKey))
+    .map(([modelId, label, tier, sweScore, ctx, providerKey], i) => ({
+      idx: i + 1, modelId, label, tier, sweScore, ctx, providerKey,
+      status: 'pending',
+      pings: [],  // 📖 All ping results (ms or 'TIMEOUT')
+      httpCode: null,
+      hidden: false,  // 📖 Simple flag to hide/show models
+    }))
 
   // 📖 Clamp scrollOffset so cursor is always within the visible viewport window.
   // 📖 Called after every cursor move, sort change, and terminal resize.
@@ -1275,6 +1330,13 @@ async function main() {
     mode,                         // 📖 'opencode' or 'openclaw' — controls Enter action
     scrollOffset: 0,              // 📖 First visible model index in viewport
     terminalRows: process.stdout.rows || 24,  // 📖 Current terminal height
+    // 📖 Settings screen state (P key opens it)
+    settingsOpen: false,          // 📖 Whether settings overlay is active
+    settingsCursor: 0,            // 📖 Which provider row is selected in settings
+    settingsEditMode: false,      // 📖 Whether we're in inline key editing mode
+    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)
   }
 
   // 📖 Re-clamp viewport on terminal resize
@@ -1308,6 +1370,88 @@ async function main() {
     return state.results
   }
 
+  // ─── Settings screen renderer ─────────────────────────────────────────────
+  // 📖 renderSettings: Draw the settings overlay in the alt screen buffer.
+  // 📖 Shows all providers with their API key (masked) + enabled state.
+  // 📖 When in edit mode (settingsEditMode=true), shows an inline input field.
+  // 📖 Key "T" in settings = test API key for selected provider.
+  function renderSettings() {
+    const providerKeys = Object.keys(sources)
+    const EL = '\x1b[K'
+    const lines = []
+
+    lines.push('')
+    lines.push(`  ${chalk.bold('⚙  Settings')}  ${chalk.dim('— free-coding-models v' + LOCAL_VERSION)}`)
+    lines.push('')
+    lines.push(`  ${chalk.bold('Providers')}`)
+    lines.push('')
+
+    for (let i = 0; i < providerKeys.length; i++) {
+      const pk = providerKeys[i]
+      const src = sources[pk]
+      const isCursor = i === state.settingsCursor
+      const enabled = isProviderEnabled(state.config, pk)
+      const keyVal = state.config.apiKeys?.[pk] ?? ''
+
+      // 📖 Build API key display — mask most chars, show last 4
+      let keyDisplay
+      if (state.settingsEditMode && isCursor) {
+        // 📖 Inline editing: show typed buffer with cursor indicator
+        keyDisplay = chalk.cyanBright(`${state.settingsEditBuffer || ''}▏`)
+      } else if (keyVal) {
+        const visible = keyVal.slice(-4)
+        const masked = '•'.repeat(Math.min(16, Math.max(4, keyVal.length - 4)))
+        keyDisplay = chalk.dim(masked + visible)
+      } else {
+        keyDisplay = chalk.dim('(no key set)')
+      }
+
+      // 📖 Test result badge
+      const testResult = state.settingsTestResults[pk]
+      let testBadge = chalk.dim('[Test —]')
+      if (testResult === 'pending') testBadge = chalk.yellow('[Testing…]')
+      else if (testResult === 'ok')   testBadge = chalk.greenBright('[Test ✅]')
+      else if (testResult === 'fail') testBadge = chalk.red('[Test ❌]')
+
+      const enabledBadge = enabled ? chalk.greenBright('✅') : chalk.dim('⬜')
+      const providerName = chalk.bold(src.name.padEnd(10))
+      const bullet = isCursor ? chalk.bold.cyan('  ❯ ') : chalk.dim('    ')
+
+      const row = `${bullet}[ ${enabledBadge} ] ${providerName}  ${keyDisplay.padEnd(30)}  ${testBadge}`
+      lines.push(isCursor ? chalk.bgRgb(30, 30, 60)(row) : row)
+    }
+
+    lines.push('')
+    if (state.settingsEditMode) {
+      lines.push(chalk.dim('  Type API key  •  Enter Save  •  Esc Cancel'))
+    } else {
+      lines.push(chalk.dim('  ↑↓ Navigate  •  Enter Edit key  •  Space Toggle enabled  •  T Test key  •  Esc Close'))
+    }
+    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) {
+    const src = sources[providerKey]
+    if (!src) return
+    const testKey = getApiKey(state.config, providerKey)
+    if (!testKey) { state.settingsTestResults[providerKey] = 'fail'; return }
+
+    // 📖 Use the first model in the provider's list for the test ping
+    const testModel = src.models[0]?.[0]
+    if (!testModel) { state.settingsTestResults[providerKey] = 'fail'; return }
+
+    state.settingsTestResults[providerKey] = 'pending'
+    const { code } = await ping(testKey, testModel, src.url)
+    state.settingsTestResults[providerKey] = code === '200' ? 'ok' : 'fail'
+  }
+
   // 📖 Setup keyboard input for interactive selection during pings
   // 📖 Use readline with keypress event for arrow key handling
   process.stdin.setEncoding('utf8')
@@ -1318,9 +1462,107 @@ async function main() {
   const onKeyPress = async (str, key) => {
     if (!key) return
 
-    // 📖 Sorting keys: R=rank, T=tier, O=origin, M=model, L=latest ping, A=avg ping, S=SWE-bench, N=context, H=health, V=verdict, U=uptime
+    // ─── Settings overlay keyboard handling ───────────────────────────────────
+    if (state.settingsOpen) {
+      const providerKeys = Object.keys(sources)
+
+      // 📖 Edit mode: capture typed characters for the API key
+      if (state.settingsEditMode) {
+        if (key.name === 'return') {
+          // 📖 Save the new key and exit edit mode
+          const pk = providerKeys[state.settingsCursor]
+          const newKey = state.settingsEditBuffer.trim()
+          if (newKey) {
+            state.config.apiKeys[pk] = newKey
+            saveConfig(state.config)
+          }
+          state.settingsEditMode = false
+          state.settingsEditBuffer = ''
+        } else if (key.name === 'escape') {
+          // 📖 Cancel without saving
+          state.settingsEditMode = false
+          state.settingsEditBuffer = ''
+        } else if (key.name === 'backspace') {
+          state.settingsEditBuffer = state.settingsEditBuffer.slice(0, -1)
+        } else if (str && !key.ctrl && !key.meta && str.length === 1) {
+          // 📖 Append printable character to buffer
+          state.settingsEditBuffer += str
+        }
+        return
+      }
+
+      // 📖 Normal settings navigation
+      if (key.name === 'escape') {
+        // 📖 Close settings — rebuild results to reflect provider changes
+        state.settingsOpen = false
+        // 📖 Rebuild results: add models from newly enabled providers, remove disabled
+        results = MODELS
+          .filter(([,,,,,pk]) => isProviderEnabled(state.config, pk))
+          .map(([modelId, label, tier, sweScore, ctx, providerKey], i) => {
+            // 📖 Try to reuse existing result to keep ping history
+            const existing = state.results.find(r => r.modelId === modelId && r.providerKey === providerKey)
+            if (existing) return existing
+            return { idx: i + 1, modelId, label, tier, sweScore, ctx, providerKey, status: 'pending', pings: [], httpCode: null, hidden: false }
+          })
+        // 📖 Re-index results
+        results.forEach((r, i) => { r.idx = i + 1 })
+        state.results = results
+        adjustScrollOffset(state)
+        return
+      }
+
+      if (key.name === 'up' && state.settingsCursor > 0) {
+        state.settingsCursor--
+        return
+      }
+
+      if (key.name === 'down' && state.settingsCursor < providerKeys.length - 1) {
+        state.settingsCursor++
+        return
+      }
+
+      if (key.name === 'return') {
+        // 📖 Enter edit mode for the selected provider's key
+        const pk = providerKeys[state.settingsCursor]
+        state.settingsEditBuffer = state.config.apiKeys?.[pk] ?? ''
+        state.settingsEditMode = true
+        return
+      }
+
+      if (key.name === 'space') {
+        // 📖 Toggle enabled/disabled for selected provider
+        const pk = providerKeys[state.settingsCursor]
+        if (!state.config.providers) state.config.providers = {}
+        if (!state.config.providers[pk]) state.config.providers[pk] = { enabled: true }
+        state.config.providers[pk].enabled = !isProviderEnabled(state.config, pk)
+        saveConfig(state.config)
+        return
+      }
+
+      if (key.name === 't') {
+        // 📖 Test the selected provider's key (fires a real ping)
+        const pk = providerKeys[state.settingsCursor]
+        testProviderKey(pk)
+        return
+      }
+
+      if (key.ctrl && key.name === 'c') { exit(0); return }
+      return // 📖 Swallow all other keys while settings is open
+    }
+
+    // 📖 P key: open settings screen
+    if (key.name === 'p') {
+      state.settingsOpen = true
+      state.settingsCursor = 0
+      state.settingsEditMode = false
+      state.settingsEditBuffer = ''
+      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
+    // 📖 T is reserved for tier filter cycling — tier sort moved to Y
     const sortKeys = {
-      'r': 'rank', 't': 'tier', 'o': 'origin', 'm': 'model',
+      'r': 'rank', 'y': 'tier', 'o': 'origin', 'm': 'model',
       'l': 'ping', 'a': 'avg', 's': 'swe', 'n': 'ctx', 'h': 'condition', 'v': 'verdict', 'u': 'uptime'
     }
 
@@ -1434,10 +1676,13 @@ async function main() {
 
   process.stdin.on('keypress', onKeyPress)
 
-  // 📖 Animation loop: clear alt screen + redraw table at FPS with cursor
+  // 📖 Animation loop: render settings overlay OR main table based on state
   const ticker = setInterval(() => {
     state.frame++
-    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))
+    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)
+    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))
@@ -1445,8 +1690,11 @@ async function main() {
   // ── Continuous ping loop — ping all models every N seconds forever ──────────
 
   // 📖 Single ping function that updates result
+  // 📖 Uses per-provider API key and URL from sources.js
   const pingModel = async (r) => {
-    const { code, ms } = await ping(apiKey, r.modelId)
+    const providerApiKey = getApiKey(state.config, r.providerKey) ?? apiKey
+    const providerUrl = sources[r.providerKey]?.url ?? sources.nvidia.url
+    const { code, ms } = await ping(providerApiKey, r.modelId, providerUrl)
 
     // 📖 Store ping result as object with ms and code
     // 📖 ms = actual response time (even for errors like 429)

package/lib/config.js

@@ -0,0 +1,170 @@
+/**
+ * @file lib/config.js
+ * @description JSON config management for free-coding-models multi-provider support.
+ *
+ * 📖 This module manages ~/.free-coding-models.json, the new config file that
+ *    stores API keys and per-provider enabled/disabled state for all providers
+ *    (NVIDIA NIM, Groq, Cerebras, etc.).
+ *
+ * 📖 Config file location: ~/.free-coding-models.json
+ * 📖 File permissions: 0o600 (user read/write only — contains API keys)
+ *
+ * 📖 Config JSON structure:
+ *   {
+ *     "apiKeys": {
+ *       "nvidia":   "nvapi-xxx",
+ *       "groq":     "gsk_xxx",
+ *       "cerebras": "csk_xxx"
+ *     },
+ *     "providers": {
+ *       "nvidia":   { "enabled": true },
+ *       "groq":     { "enabled": true },
+ *       "cerebras": { "enabled": true }
+ *     }
+ *   }
+ *
+ * 📖 Migration: On first run, if the old plain-text ~/.free-coding-models exists
+ *    and the new JSON file does not, the old key is auto-migrated as the nvidia key.
+ *    The old file is left in place (not deleted) for safety.
+ *
+ * @functions
+ *   → loadConfig() — Read ~/.free-coding-models.json; auto-migrate old plain-text config if needed
+ *   → saveConfig(config) — Write config to ~/.free-coding-models.json with 0o600 permissions
+ *   → getApiKey(config, providerKey) — Get effective API key (env var override > config > null)
+ *
+ * @exports loadConfig, saveConfig, getApiKey
+ * @exports CONFIG_PATH — path to the JSON config file
+ *
+ * @see bin/free-coding-models.js — main CLI that uses these functions
+ * @see sources.js — provider keys come from Object.keys(sources)
+ */
+
+import { readFileSync, writeFileSync, existsSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+
+// 📖 New JSON config path — stores all providers' API keys + enabled state
+export const CONFIG_PATH = join(homedir(), '.free-coding-models.json')
+
+// 📖 Old plain-text config path — used only for migration
+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',
+}
+
+/**
+ * 📖 loadConfig: Read the JSON config from disk.
+ *
+ * 📖 Fallback chain:
+ *   1. Try to read ~/.free-coding-models.json (new format)
+ *   2. If missing, check if ~/.free-coding-models (old plain-text) exists → migrate
+ *   3. If neither, return an empty default config
+ *
+ * 📖 The migration reads the old file as a plain nvidia API key and writes
+ *    a proper JSON config. The old file is NOT deleted (safety first).
+ *
+ * @returns {{ apiKeys: Record<string,string>, providers: Record<string,{enabled:boolean}> }}
+ */
+export function loadConfig() {
+  // 📖 Try new JSON config first
+  if (existsSync(CONFIG_PATH)) {
+    try {
+      const raw = readFileSync(CONFIG_PATH, 'utf8').trim()
+      const parsed = JSON.parse(raw)
+      // 📖 Ensure the shape is always complete — fill missing sections with defaults
+      if (!parsed.apiKeys) parsed.apiKeys = {}
+      if (!parsed.providers) parsed.providers = {}
+      return parsed
+    } catch {
+      // 📖 Corrupted JSON — return empty config (user will re-enter keys)
+      return _emptyConfig()
+    }
+  }
+
+  // 📖 Migration path: old plain-text file exists, new JSON doesn't
+  if (existsSync(LEGACY_CONFIG_PATH)) {
+    try {
+      const oldKey = readFileSync(LEGACY_CONFIG_PATH, 'utf8').trim()
+      if (oldKey) {
+        const config = _emptyConfig()
+        config.apiKeys.nvidia = oldKey
+        // 📖 Auto-save migrated config so next launch is fast
+        saveConfig(config)
+        return config
+      }
+    } catch {
+      // 📖 Can't read old file — proceed with empty config
+    }
+  }
+
+  return _emptyConfig()
+}
+
+/**
+ * 📖 saveConfig: Write the config object to ~/.free-coding-models.json.
+ *
+ * 📖 Uses mode 0o600 so the file is only readable by the owning user (API keys!).
+ * 📖 Pretty-prints JSON for human readability.
+ *
+ * @param {{ apiKeys: Record<string,string>, providers: Record<string,{enabled:boolean}> }} config
+ */
+export function saveConfig(config) {
+  try {
+    writeFileSync(CONFIG_PATH, JSON.stringify(config, null, 2), { mode: 0o600 })
+  } catch {
+    // 📖 Silently fail — the app is still usable, keys just won't persist
+  }
+}
+
+/**
+ * 📖 getApiKey: Get the effective API key for a provider.
+ *
+ * 📖 Priority order (first non-empty wins):
+ *   1. Environment variable (e.g. NVIDIA_API_KEY) — for CI/headless
+ *   2. Config file value — from ~/.free-coding-models.json
+ *   3. null — no key configured
+ *
+ * @param {{ apiKeys: Record<string,string> }} config
+ * @param {string} providerKey — e.g. 'nvidia', 'groq', 'cerebras'
+ * @returns {string|null}
+ */
+export function getApiKey(config, providerKey) {
+  // 📖 Env var override — takes precedence over everything
+  const envVar = ENV_VARS[providerKey]
+  if (envVar && process.env[envVar]) return process.env[envVar]
+
+  // 📖 Config file value
+  const key = config?.apiKeys?.[providerKey]
+  if (key) return key
+
+  return null
+}
+
+/**
+ * 📖 isProviderEnabled: Check if a provider is enabled in config.
+ *
+ * 📖 Providers are enabled by default if not explicitly set to false.
+ * 📖 A provider without an API key should still appear in settings (just can't ping).
+ *
+ * @param {{ providers: Record<string,{enabled:boolean}> }} config
+ * @param {string} providerKey
+ * @returns {boolean}
+ */
+export function isProviderEnabled(config, providerKey) {
+  const providerConfig = config?.providers?.[providerKey]
+  if (!providerConfig) return true // 📖 Default: enabled
+  return providerConfig.enabled !== false
+}
+
+// 📖 Internal helper: create a blank config with the right shape
+function _emptyConfig() {
+  return {
+    apiKeys: {},
+    providers: {},
+  }
+}

package/lib/utils.js

@@ -155,8 +155,8 @@ export const sortResults = (results, sortColumn, sortDirection) => {
         cmp = TIER_ORDER.indexOf(a.tier) - TIER_ORDER.indexOf(b.tier)
         break
       case 'origin':
-        // 📖 All models are NIM for now — this is future-proofed for multi-source
-        cmp = 'NIM'.localeCompare('NIM')
+        // 📖 Sort by providerKey (or fallback to modelId prefix) for multi-provider support
+        cmp = (a.providerKey ?? 'nvidia').localeCompare(b.providerKey ?? 'nvidia')
         break
       case 'model':
         cmp = a.label.localeCompare(b.label)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "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.",
   "keywords": [
     "nvidia",

package/sources.js

@@ -27,7 +27,12 @@
  *   📖 Secondary: https://swe-rebench.com (independent evals, scores are lower)
  *   📖 Leaderboard tracker: https://www.marc0.dev/en/leaderboard
  *
- *   @exports Object containing all sources and their models
+ *   @exports nvidiaNim, groq, cerebras — model arrays per provider
+ *   @exports sources — map of { nvidia, groq, cerebras } 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
+ *      API endpoint and API key to use for each model.
  */
 
 // 📖 NIM source - https://build.nvidia.com
@@ -86,18 +91,50 @@ export const nvidiaNim = [
   ['microsoft/phi-4-mini-instruct',                'Phi 4 Mini',          'C',  '14.0%', '128k'],
 ]
 
+// 📖 Groq source - https://console.groq.com
+// 📖 Free API keys available at https://console.groq.com/keys
+export const groq = [
+  ['llama-3.3-70b-versatile',              'Llama 3.3 70B',      'A-', '39.5%', '128k'],
+  ['meta-llama/llama-4-scout-17b-16e-preview', 'Llama 4 Scout',  'A',  '44.0%', '10M'],
+  ['meta-llama/llama-4-maverick-17b-128e-preview', 'Llama 4 Maverick', 'S', '62.0%', '1M'],
+  ['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'],
+]
+
+// 📖 Cerebras source - https://cloud.cerebras.ai
+// 📖 Free API keys available at https://cloud.cerebras.ai
+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'],
+]
+
 // 📖 All sources combined - used by the main script
+// 📖 Each source has: name (display), url (API endpoint), models (array of model tuples)
 export const sources = {
   nvidia: {
     name: 'NIM',
+    url: 'https://integrate.api.nvidia.com/v1/chat/completions',
     models: nvidiaNim,
   },
+  groq: {
+    name: 'Groq',
+    url: 'https://api.groq.com/openai/v1/chat/completions',
+    models: groq,
+  },
+  cerebras: {
+    name: 'Cerebras',
+    url: 'https://api.cerebras.ai/v1/chat/completions',
+    models: cerebras,
+  },
 }
 
-// 📖 Flatten all models from all sources for backward compatibility
+// 📖 Flatten all models from all sources — each entry includes providerKey as 6th element
+// 📖 providerKey lets the main CLI know which API key and URL to use per model
 export const MODELS = []
 for (const [sourceKey, sourceData] of Object.entries(sources)) {
   for (const [modelId, label, tier, sweScore, ctx] of sourceData.models) {
-    MODELS.push([modelId, label, tier, sweScore, ctx])
+    MODELS.push([modelId, label, tier, sweScore, ctx, sourceKey])
   }
 }