free-coding-models 0.1.48 → 0.1.50

package/README.md

@@ -61,7 +61,8 @@
 - **💻 OpenCode integration** — Auto-detects NIM setup, sets model as default, launches OpenCode
 - **🦞 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 🚫
+- **📶 Status indicators** — UP ✅ · No Key 🔑 · Timeout ⏳ · Overloaded 🔥 · Not Found 🚫
+- **🔍 Keyless latency** — Models are pinged even without an API key — a `🔑 NO KEY` status confirms the server is reachable with real latency shown, so you can compare providers before committing to a key
 - **🏷 Tier filtering** — Filter models by tier letter (S, A, B, C) with `--tier` flag or dynamically with `T` key
 
 ---
@@ -78,7 +79,7 @@ Before using `free-coding-models`, make sure you have:
 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).
+> 💡 **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.
 
 ---
 

package/bin/free-coding-models.js

@@ -574,7 +574,7 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
       : chalk.dim(ctxRaw.padEnd(W_CTX))
 
     // 📖 Latest ping - pings are objects: { ms, code }
-    // 📖 Only show response time for successful pings, "—" for errors (error code is in Status column)
+    // 📖 Show response time for 200 (success) and 401 (no-auth but server is reachable)
     const latestPing = r.pings.length > 0 ? r.pings[r.pings.length - 1] : null
     let pingCell
     if (!latestPing) {
@@ -583,6 +583,9 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
       // 📖 Success - show response time
       const str = String(latestPing.ms).padEnd(W_PING)
       pingCell = latestPing.ms < 500 ? chalk.greenBright(str) : latestPing.ms < 1500 ? chalk.yellow(str) : chalk.red(str)
+    } else if (latestPing.code === '401') {
+      // 📖 401 = no API key but server IS reachable — still show latency in dim
+      pingCell = chalk.dim(String(latestPing.ms).padEnd(W_PING))
     } else {
       // 📖 Error or timeout - show "—" (error code is already in Status column)
       pingCell = chalk.dim('—'.padEnd(W_PING))
@@ -601,7 +604,11 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
     // 📖 Status column - build plain text with emoji, pad, then colorize
     // 📖 Different emojis for different error codes
     let statusText, statusColor
-    if (r.status === 'pending') {
+    if (r.status === 'noauth') {
+      // 📖 Server responded but needs an API key — shown dimly since it IS reachable
+      statusText = `🔑 NO KEY`
+      statusColor = (s) => chalk.dim(s)
+    } else if (r.status === 'pending') {
       statusText = `${FRAMES[frame % FRAMES.length]} wait`
       statusColor = (s) => chalk.dim.yellow(s)
     } else if (r.status === 'up') {
@@ -718,14 +725,19 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
 
 // 📖 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).
+// 📖 apiKey can be null — in that case no Authorization header is sent.
+// 📖 A 401 response still tells us the server is UP and gives us real latency.
 async function ping(apiKey, modelId, url) {
   const ctrl  = new AbortController()
   const timer = setTimeout(() => ctrl.abort(), PING_TIMEOUT)
   const t0    = performance.now()
   try {
+    // 📖 Only attach Authorization header when a key is available
+    const headers = { 'Content-Type': 'application/json' }
+    if (apiKey) headers['Authorization'] = `Bearer ${apiKey}`
     const resp = await fetch(url, {
       method: 'POST', signal: ctrl.signal,
-      headers: { 'Authorization': `Bearer ${apiKey}`, 'Content-Type': 'application/json' },
+      headers,
       body: JSON.stringify({ model: modelId, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
     })
     return { code: String(resp.status), ms: Math.round(performance.now() - t0) }
@@ -798,88 +810,87 @@ function checkNvidiaNimConfig() {
 }
 
 // ─── Start OpenCode ────────────────────────────────────────────────────────────
-// 📖 Launches OpenCode with the selected NVIDIA NIM model
-// 📖 If NVIDIA NIM is configured, use --model flag, otherwise show install prompt
-// 📖 Model format: { modelId, label, tier }
+// 📖 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.
+// 📖 Model format: { modelId, label, tier, providerKey }
 async function startOpenCode(model) {
-  const hasNim = checkNvidiaNimConfig()
+  const providerKey = model.providerKey ?? 'nvidia'
+  // 📖 Full model reference string used in OpenCode config and --model flag
+  const modelRef = `${providerKey}/${model.modelId}`
 
-  if (hasNim) {
-    // 📖 NVIDIA NIM already configured - launch with model flag
-    console.log(chalk.green(`  🚀 Setting ${chalk.bold(model.label)} as default…`))
-    console.log(chalk.dim(`  Model: nvidia/${model.modelId}`))
-    console.log()
+  if (providerKey === 'nvidia') {
+    // 📖 NVIDIA NIM needs a custom provider block in OpenCode config (not built-in)
+    const hasNim = checkNvidiaNimConfig()
 
-    const config = loadOpenCodeConfig()
-    const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
+    if (hasNim) {
+      console.log(chalk.green(`  🚀 Setting ${chalk.bold(model.label)} as default…`))
+      console.log(chalk.dim(`  Model: ${modelRef}`))
+      console.log()
 
-    // 📖 Backup current config
-    if (existsSync(getOpenCodeConfigPath())) {
-      copyFileSync(getOpenCodeConfigPath(), backupPath)
-      console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
-    }
+      const config = loadOpenCodeConfig()
+      const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
+
+      if (existsSync(getOpenCodeConfigPath())) {
+        copyFileSync(getOpenCodeConfigPath(), backupPath)
+        console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
+      }
 
-    // 📖 Update default model to nvidia/model_id
-    config.model = `nvidia/${model.modelId}`
+      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,
+      // 📖 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 }
       }
-    }
 
-    saveOpenCodeConfig(config)
+      saveOpenCodeConfig(config)
 
-    // 📖 Verify config was saved correctly
-    const savedConfig = loadOpenCodeConfig()
-    console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
-    console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
-    console.log()
-    
-    if (savedConfig.model === config.model) {
-      console.log(chalk.green(`  ✓ Default model set to: nvidia/${model.modelId}`))
-    } else {
-      console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
-    }
-    console.log()
-    console.log(chalk.dim('  Starting OpenCode…'))
-    console.log()
+      const savedConfig = loadOpenCodeConfig()
+      console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
+      console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
+      console.log()
 
-    // 📖 Launch OpenCode and wait for it
-    // 📖 Use --model flag to ensure the model is selected
-    const { spawn } = await import('child_process')
-    const child = spawn('opencode', ['--model', `nvidia/${model.modelId}`], {
-      stdio: 'inherit',
-      shell: true,
-      detached: false
-    })
+      if (savedConfig.model === config.model) {
+        console.log(chalk.green(`  ✓ Default model set to: ${modelRef}`))
+      } else {
+        console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
+      }
+      console.log()
+      console.log(chalk.dim('  Starting OpenCode…'))
+      console.log()
 
-    // 📖 Wait for OpenCode to exit
-    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)
-        }
+      const { spawn } = await import('child_process')
+      const child = spawn('opencode', ['--model', modelRef], {
+        stdio: 'inherit',
+        shell: true,
+        detached: false
       })
-    })
-  } else {
-    // 📖 NVIDIA NIM not configured - show install prompt and launch
-    console.log(chalk.yellow('  ⚠ NVIDIA NIM not configured in OpenCode'))
-    console.log()
-    console.log(chalk.dim('  Starting OpenCode with installation prompt…'))
-    console.log()
 
-    const configPath = getOpenCodeConfigPath()
-    const installPrompt = `Please install NVIDIA NIM provider in OpenCode by adding this to ${configPath}:
+      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)
+          }
+        })
+      })
+    } else {
+      // 📖 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…'))
+      console.log()
+
+      const configPath = getOpenCodeConfigPath()
+      const installPrompt = `Please install NVIDIA NIM provider in OpenCode by adding this to ${configPath}:
 
 {
   "provider": {
@@ -896,21 +907,73 @@ async function startOpenCode(model) {
 
 ${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_key_here'}
 
-After installation, you can use: opencode --model nvidia/${model.modelId}`
+After installation, you can use: opencode --model ${modelRef}`
+
+      console.log(chalk.cyan(installPrompt))
+      console.log()
+      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)
+          }
+        })
+      })
+    }
+  } else {
+    // 📖 Groq and Cerebras are built-in OpenCode providers — no custom provider config needed.
+    // 📖 OpenCode discovers them via GROQ_API_KEY / CEREBRAS_API_KEY env vars automatically.
+    // 📖 Just set the model in config and launch with --model groq/model-id.
+    console.log(chalk.green(`  🚀 Setting ${chalk.bold(model.label)} as default…`))
+    console.log(chalk.dim(`  Model: ${modelRef}`))
+    console.log()
+
+    const config = loadOpenCodeConfig()
+    const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
+
+    if (existsSync(getOpenCodeConfigPath())) {
+      copyFileSync(getOpenCodeConfigPath(), backupPath)
+      console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
+    }
+
+    config.model = modelRef
+    saveOpenCodeConfig(config)
 
-    console.log(chalk.cyan(installPrompt))
+    const savedConfig = loadOpenCodeConfig()
+    console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
+    console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
+    console.log()
+
+    if (savedConfig.model === config.model) {
+      console.log(chalk.green(`  ✓ Default model set to: ${modelRef}`))
+    } else {
+      console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
+    }
     console.log()
     console.log(chalk.dim('  Starting OpenCode…'))
     console.log()
 
     const { spawn } = await import('child_process')
-    const child = spawn('opencode', [], {
+    const child = spawn('opencode', ['--model', modelRef], {
       stdio: 'inherit',
       shell: true,
       detached: false
     })
 
-    // 📖 Wait for OpenCode to exit
     await new Promise((resolve, reject) => {
       child.on('exit', resolve)
       child.on('error', (err) => {
@@ -929,67 +992,25 @@ After installation, you can use: opencode --model nvidia/${model.modelId}`
 // ─── Start OpenCode Desktop ─────────────────────────────────────────────────────
 // 📖 startOpenCodeDesktop: Same config logic as startOpenCode, but opens the Desktop app.
 // 📖 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) {
-  const hasNim = checkNvidiaNimConfig()
+  const providerKey = model.providerKey ?? 'nvidia'
+  // 📖 Full model reference string used in OpenCode config and --model flag
+  const modelRef = `${providerKey}/${model.modelId}`
 
-  if (hasNim) {
-    console.log(chalk.green(`  🖥 Setting ${chalk.bold(model.label)} as default for OpenCode Desktop…`))
-    console.log(chalk.dim(`  Model: nvidia/${model.modelId}`))
-    console.log()
-
-    const config = loadOpenCodeConfig()
-    const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
-
-    if (existsSync(getOpenCodeConfigPath())) {
-      copyFileSync(getOpenCodeConfigPath(), backupPath)
-      console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
-    }
-
-    config.model = `nvidia/${model.modelId}`
-
-    if (config.provider?.nvidia) {
-      if (!config.provider.nvidia.models) config.provider.nvidia.models = {}
-      config.provider.nvidia.models[model.modelId] = {
-        name: model.label,
-      }
-    }
-
-    saveOpenCodeConfig(config)
-
-    // 📖 Verify config was saved correctly
-    const savedConfig = loadOpenCodeConfig()
-    console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
-    console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
-    console.log()
-    
-    if (savedConfig.model === config.model) {
-      console.log(chalk.green(`  ✓ Default model set to: nvidia/${model.modelId}`))
-    } else {
-      console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
-    }
-    console.log()
-    console.log(chalk.dim('  Opening OpenCode Desktop…'))
-    console.log()
-
-    // 📖 Launch Desktop app based on platform
+  // 📖 Helper to open the Desktop app based on platform
+  const launchDesktop = async () => {
     const { exec } = await import('child_process')
-    
     let command
     if (isMac) {
       command = 'open -a OpenCode'
     } else if (isWindows) {
-      // 📖 On Windows, try common installation paths
-      // 📖 User installation: %LOCALAPPDATA%\Programs\OpenCode\OpenCode.exe
-      // 📖 System installation: C:\Program Files\OpenCode\OpenCode.exe
       command = 'start "" "%LOCALAPPDATA%\\Programs\\OpenCode\\OpenCode.exe" 2>nul || start "" "%PROGRAMFILES%\\OpenCode\\OpenCode.exe" 2>nul || start OpenCode'
     } else if (isLinux) {
-      // 📖 On Linux, try different methods with model flag
-      // 📖 Check if opencode-desktop exists, otherwise try xdg-open
-      command = `opencode-desktop --model nvidia/${model.modelId} 2>/dev/null || flatpak run ai.opencode.OpenCode --model nvidia/${model.modelId} 2>/dev/null || snap run opencode --model nvidia/${model.modelId} 2>/dev/null || xdg-open /usr/share/applications/opencode.desktop 2>/dev/null || echo "OpenCode not found"`
+      command = `opencode-desktop --model ${modelRef} 2>/dev/null || flatpak run ai.opencode.OpenCode --model ${modelRef} 2>/dev/null || snap run opencode --model ${modelRef} 2>/dev/null || xdg-open /usr/share/applications/opencode.desktop 2>/dev/null || echo "OpenCode not found"`
     }
-
-    exec(command, (err, stdout, stderr) => {
+    exec(command, (err) => {
       if (err) {
         console.error(chalk.red('  ✗ Could not open OpenCode Desktop'))
         if (isWindows) {
@@ -1002,13 +1023,56 @@ async function startOpenCodeDesktop(model) {
         }
       }
     })
-  } else {
-    console.log(chalk.yellow('  ⚠ NVIDIA NIM not configured in OpenCode'))
-    console.log(chalk.dim('  Please configure it first. Config is shared between CLI and Desktop.'))
-    console.log()
-    
-    const configPath = getOpenCodeConfigPath()
-    const installPrompt = `Add this to ${configPath}:
+  }
+
+  if (providerKey === 'nvidia') {
+    // 📖 NVIDIA NIM needs a custom provider block in OpenCode config (not built-in)
+    const hasNim = checkNvidiaNimConfig()
+
+    if (hasNim) {
+      console.log(chalk.green(`  🖥 Setting ${chalk.bold(model.label)} as default for OpenCode Desktop…`))
+      console.log(chalk.dim(`  Model: ${modelRef}`))
+      console.log()
+
+      const config = loadOpenCodeConfig()
+      const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
+
+      if (existsSync(getOpenCodeConfigPath())) {
+        copyFileSync(getOpenCodeConfigPath(), backupPath)
+        console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
+      }
+
+      config.model = modelRef
+
+      if (config.provider?.nvidia) {
+        if (!config.provider.nvidia.models) config.provider.nvidia.models = {}
+        config.provider.nvidia.models[model.modelId] = { name: model.label }
+      }
+
+      saveOpenCodeConfig(config)
+
+      const savedConfig = loadOpenCodeConfig()
+      console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
+      console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
+      console.log()
+
+      if (savedConfig.model === config.model) {
+        console.log(chalk.green(`  ✓ Default model set to: ${modelRef}`))
+      } else {
+        console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
+      }
+      console.log()
+      console.log(chalk.dim('  Opening OpenCode Desktop…'))
+      console.log()
+
+      await launchDesktop()
+    } else {
+      console.log(chalk.yellow('  ⚠ NVIDIA NIM not configured in OpenCode'))
+      console.log(chalk.dim('  Please configure it first. Config is shared between CLI and Desktop.'))
+      console.log()
+
+      const configPath = getOpenCodeConfigPath()
+      const installPrompt = `Add this to ${configPath}:
 
 {
   "provider": {
@@ -1024,8 +1088,41 @@ async function startOpenCodeDesktop(model) {
 }
 
 ${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_key_here'}`
-    console.log(chalk.cyan(installPrompt))
+      console.log(chalk.cyan(installPrompt))
+      console.log()
+    }
+  } else {
+    // 📖 Groq and Cerebras are built-in OpenCode providers — just set model and open Desktop.
+    console.log(chalk.green(`  🖥 Setting ${chalk.bold(model.label)} as default for OpenCode Desktop…`))
+    console.log(chalk.dim(`  Model: ${modelRef}`))
+    console.log()
+
+    const config = loadOpenCodeConfig()
+    const backupPath = `${getOpenCodeConfigPath()}.backup-${Date.now()}`
+
+    if (existsSync(getOpenCodeConfigPath())) {
+      copyFileSync(getOpenCodeConfigPath(), backupPath)
+      console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
+    }
+
+    config.model = modelRef
+    saveOpenCodeConfig(config)
+
+    const savedConfig = loadOpenCodeConfig()
+    console.log(chalk.dim(`  📝 Config saved to: ${getOpenCodeConfigPath()}`))
+    console.log(chalk.dim(`  📝 Default model in config: ${savedConfig.model || 'NOT SET'}`))
+    console.log()
+
+    if (savedConfig.model === config.model) {
+      console.log(chalk.green(`  ✓ Default model set to: ${modelRef}`))
+    } else {
+      console.log(chalk.yellow(`  ⚠ Config might not have been saved correctly`))
+    }
     console.log()
+    console.log(chalk.dim('  Opening OpenCode Desktop…'))
+    console.log()
+
+    await launchDesktop()
   }
 }
 
@@ -1524,6 +1621,16 @@ async function main() {
         results.forEach((r, i) => { r.idx = i + 1 })
         state.results = results
         adjustScrollOffset(state)
+        // 📖 Re-ping all models that were 'noauth' (got 401 without key) but now have a key
+        // 📖 This makes the TUI react immediately when a user adds an API key in settings
+        state.results.forEach(r => {
+          if (r.status === 'noauth' && getApiKey(state.config, r.providerKey)) {
+            r.status = 'pending'
+            r.pings = []
+            r.httpCode = null
+            pingModel(r).catch(() => {})
+          }
+        })
         return
       }
 
@@ -1651,7 +1758,7 @@ async function main() {
       const sorted = sortResults(results, state.sortColumn, state.sortDirection)
       const selected = sorted[state.cursor]
       // 📖 Allow selecting ANY model (even timeout/down) - user knows what they're doing
-      userSelected = { modelId: selected.modelId, label: selected.label, tier: selected.tier }
+      userSelected = { modelId: selected.modelId, label: selected.label, tier: selected.tier, providerKey: selected.providerKey }
 
       // 📖 Stop everything and act on selection immediately
       clearInterval(ticker)
@@ -1707,8 +1814,9 @@ async function main() {
 
   // 📖 Single ping function that updates result
   // 📖 Uses per-provider API key and URL from sources.js
+  // 📖 If no API key is configured, pings without auth — a 401 still tells us latency + server is up
   const pingModel = async (r) => {
-    const providerApiKey = getApiKey(state.config, r.providerKey) ?? apiKey
+    const providerApiKey = getApiKey(state.config, r.providerKey) ?? null
     const providerUrl = sources[r.providerKey]?.url ?? sources.nvidia.url
     const { code, ms } = await ping(providerApiKey, r.modelId, providerUrl)
 
@@ -1722,6 +1830,11 @@ async function main() {
       r.status = 'up'
     } else if (code === '000') {
       r.status = 'timeout'
+    } else if (code === '401') {
+      // 📖 401 = server is reachable but no API key set (or wrong key)
+      // 📖 Treated as 'noauth' — server is UP, latency is real, just needs a key
+      r.status = 'noauth'
+      r.httpCode = code
     } else {
       r.status = 'down'
       r.httpCode = code

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.48",
+  "version": "0.1.50",
   "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",