free-coding-models 0.1.63 → 0.1.64

package/README.md

@@ -2,8 +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/models-101-76b900?logo=nvidia" alt="models count">
-  <img src="https://img.shields.io/badge/providers-9-blue" alt="providers count">
+  <img src="https://img.shields.io/badge/models-111-76b900?logo=nvidia" alt="models count">
+  <img src="https://img.shields.io/badge/providers-13-blue" alt="providers count">
 </p>
 
 <h1 align="center">free-coding-models</h1>
@@ -15,7 +15,7 @@
 <p align="center">
 
 ```
-1. Create a free API key (NVIDIA, Groq, or Cerebras)
+1. Create a free API key (NVIDIA, OpenRouter, Hugging Face, etc.)
 2. npm i -g free-coding-models
 3. free-coding-models
 ```
@@ -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, Cerebras, and SambaNova in real-time — pick the best one for OpenCode, OpenClaw, or any AI coding assistant</sub>
+  <sub>Ping free coding models from 13 providers 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** — 101 models from NVIDIA NIM, Groq, Cerebras, SambaNova, OpenRouter, Codestral, Hyperbolic, Scaleway, and Google AI — all free to use
+- **🌐 Multi-provider** — 111 models from NVIDIA NIM, Groq, Cerebras, SambaNova, OpenRouter, Hugging Face Inference, Replicate, DeepInfra, Fireworks AI, 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
@@ -77,8 +77,12 @@ 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)
+   - **SambaNova** — [sambanova.ai/developers](https://sambanova.ai/developers) → Developers portal → API key (dev tier generous)
+   - **OpenRouter** — [openrouter.ai/keys](https://openrouter.ai/keys) → Create key (50 req/day, 20/min on `:free`)
+   - **Hugging Face Inference** — [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens) → Access Tokens (free monthly credits)
+   - **Replicate** — [replicate.com/account/api-tokens](https://replicate.com/account/api-tokens) → Create token (dev quota)
+   - **DeepInfra** — [deepinfra.com/login](https://deepinfra.com/login) → Login → API key (free dev tier)
+   - **Fireworks AI** — [fireworks.ai](https://fireworks.ai) → Settings → Access Tokens ($1 free credits)
    - **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)
@@ -86,7 +90,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 nine 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 thirteen 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.
 
 ---
 
@@ -167,13 +171,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 101 across 9 providers)
+1. **Ping phase** — All enabled models are pinged in parallel (up to 111 across 13 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 9 providers):
+Setup wizard (first run — walks through all 13 providers):
 
 ```
   🔑 First-time setup — API keys
@@ -203,7 +207,7 @@ Setup wizard (first run — walks through all 9 providers):
   You can add or change keys anytime with the P key in the TUI.
 ```
 
-You don't need all nine — skip any provider by pressing Enter. At least one key is required.
+You don't need all thirteen — skip any provider by pressing Enter. At least one key is required.
 
 ### Adding or changing keys later
 
@@ -214,9 +218,14 @@ Press **`P`** to open the Settings screen at any time:
 
   Providers
 
-  ❯ [ ✅ ] NIM         nvapi-••••••••••••3f9a  [Test ✅]
-    [ ✅ ] Groq        (no key set)            [Test —]
-    [ ✅ ] Cerebras    (no key set)            [Test —]
+  ❯ [ ✅ ] NVIDIA NIM              nvapi-••••••••••••3f9a  [Test ✅]  Free tier (provider quota by model)
+    [ ✅ ] OpenRouter              (no key set)            [Test —]   50 req/day, 20/min (:free shared quota)
+    [ ✅ ] Hugging Face Inference  (no key set)            [Test —]   Free monthly credits (~$0.10)
+
+  Setup Instructions — NVIDIA NIM
+  1) Create a NVIDIA NIM account: https://build.nvidia.com
+  2) Profile → API Keys → Generate
+  3) Press T to test your key
 
   ↑↓ Navigate  •  Enter Edit key  •  Space Toggle enabled  •  T Test key  •  Esc Close
 ```
@@ -239,6 +248,11 @@ Env vars always take priority over the config file:
 NVIDIA_API_KEY=nvapi-xxx free-coding-models
 GROQ_API_KEY=gsk_xxx free-coding-models
 CEREBRAS_API_KEY=csk_xxx free-coding-models
+OPENROUTER_API_KEY=sk-or-xxx free-coding-models
+HUGGINGFACE_API_KEY=hf_xxx free-coding-models
+REPLICATE_API_TOKEN=r8_xxx free-coding-models
+DEEPINFRA_API_KEY=di_xxx free-coding-models
+FIREWORKS_API_KEY=fw_xxx free-coding-models
 FREE_CODING_MODELS_TELEMETRY=0 free-coding-models
 ```
 
@@ -268,13 +282,33 @@ When enabled, telemetry events include: event name, app version, selected mode,
 1. Sign up at [cloud.cerebras.ai](https://cloud.cerebras.ai)
 2. Go to API Keys → Create
 
-> 💡 **Free credits** — All three providers offer free tiers for developers.
+**OpenRouter** (`:free` models):
+1. Sign up at [openrouter.ai/keys](https://openrouter.ai/keys)
+2. Create API key (`sk-or-...`)
+
+**Hugging Face Inference**:
+1. Sign up at [huggingface.co/settings/tokens](https://huggingface.co/settings/tokens)
+2. Create Access Token (`hf_...`)
+
+**Replicate**:
+1. Sign up at [replicate.com/account/api-tokens](https://replicate.com/account/api-tokens)
+2. Create API token (`r8_...`)
+
+**DeepInfra**:
+1. Sign up at [deepinfra.com/login](https://deepinfra.com/login)
+2. Create API key from your account dashboard
+
+**Fireworks AI**:
+1. Sign up at [fireworks.ai](https://fireworks.ai)
+2. Open Settings → Access Tokens and create a token
+
+> 💡 **Free tiers** — each provider exposes a dev/free tier with its own quotas.
 
 ---
 
 ## 🤖 Coding Models
 
-**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.
+**111 coding models** across 13 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)
 
@@ -347,6 +381,19 @@ Current tier filter is shown in the header badge (e.g., `[Tier S]`)
    - Sets your selected model as default in `~/.config/opencode/opencode.json`
    - Launches OpenCode with the model ready to use
 
+### tmux sub-agent panes
+
+When launched from an existing `tmux` session, `free-coding-models` now auto-adds an OpenCode `--port` argument so OpenCode/oh-my-opencode can spawn sub-agents in panes.
+
+- Priority 1: reuse `OPENCODE_PORT` if it is valid and free
+- Priority 2: auto-pick the first free port in `4096-5095`
+
+You can force a specific port:
+
+```bash
+OPENCODE_PORT=4098 free-coding-models --opencode
+```
+
 ### Manual OpenCode Setup (Optional)
 
 Create or edit `~/.config/opencode/opencode.json`:
@@ -522,6 +569,15 @@ This script:
 | `NVIDIA_API_KEY` | NVIDIA NIM key |
 | `GROQ_API_KEY` | Groq key |
 | `CEREBRAS_API_KEY` | Cerebras key |
+| `SAMBANOVA_API_KEY` | SambaNova key |
+| `OPENROUTER_API_KEY` | OpenRouter key |
+| `HUGGINGFACE_API_KEY` / `HF_TOKEN` | Hugging Face token |
+| `REPLICATE_API_TOKEN` | Replicate token |
+| `DEEPINFRA_API_KEY` / `DEEPINFRA_TOKEN` | DeepInfra key |
+| `CODESTRAL_API_KEY` | Mistral Codestral key |
+| `HYPERBOLIC_API_KEY` | Hyperbolic key |
+| `SCALEWAY_API_KEY` | Scaleway key |
+| `GOOGLE_API_KEY` | Google AI Studio key |
 | `FREE_CODING_MODELS_TELEMETRY` | `0` disables analytics, `1` enables analytics |
 | `FREE_CODING_MODELS_POSTHOG_KEY` | PostHog project API key used for anonymous event capture |
 | `FREE_CODING_MODELS_POSTHOG_HOST` | Optional PostHog ingest host (`https://eu.i.posthog.com` default) |
@@ -533,12 +589,20 @@ This script:
   "apiKeys": {
     "nvidia":   "nvapi-xxx",
     "groq":     "gsk_xxx",
-    "cerebras": "csk_xxx"
+    "cerebras": "csk_xxx",
+    "openrouter": "sk-or-xxx",
+    "huggingface": "hf_xxx",
+    "replicate": "r8_xxx",
+    "deepinfra": "di_xxx"
   },
   "providers": {
     "nvidia":   { "enabled": true },
     "groq":     { "enabled": true },
-    "cerebras": { "enabled": true }
+    "cerebras": { "enabled": true },
+    "openrouter": { "enabled": true },
+    "huggingface": { "enabled": true },
+    "replicate": { "enabled": true },
+    "deepinfra": { "enabled": true }
   },
   "telemetry": {
     "enabled": true,

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 (3 providers: NIM, Groq, Cerebras)
+ *   - Parallel pings across all models with animated real-time updates (multi-provider)
  *   - Continuous monitoring with 2-second ping intervals (never stops)
  *   - Rolling averages calculated from ALL successful pings since start
  *   - Best-per-tier highlighting with medals (🥇🥈🥉)
@@ -19,7 +19,7 @@
  *   - Startup mode menu (OpenCode CLI vs OpenCode Desktop vs OpenClaw) when no flag is given
  *   - Automatic config detection and model setup for both tools
  *   - JSON config stored in ~/.free-coding-models.json (auto-migrates from old plain-text)
- *   - Multi-provider support via sources.js (NIM, Groq, Cerebras — extensible)
+ *   - Multi-provider support via sources.js (NIM/Groq/Cerebras/OpenRouter/Hugging Face/Replicate/DeepInfra/... — 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/Y/O/M/L/A/S/N/H/V/U keys)
@@ -32,15 +32,16 @@
  *   - `getTelemetryTerminal`: Infer terminal family (Terminal.app, iTerm2, kitty, etc.)
  *   - `isTelemetryDebugEnabled` / `telemetryDebug`: Optional runtime telemetry diagnostics via env
  *   - `sendUsageTelemetry`: Fire-and-forget anonymous app-start event
- *   - `promptApiKey`: Interactive wizard for first-time NVIDIA API key setup
+ *   - `promptApiKey`: Interactive wizard for first-time multi-provider API key setup
  *   - `promptModeSelection`: Startup menu to choose OpenCode vs OpenClaw
- *   - `ping`: Perform HTTP request to NIM endpoint with timeout handling
+ *   - `buildPingRequest` / `ping`: Build provider-specific probe requests and measure latency
  *   - `renderTable`: Generate ASCII table with colored latency indicators and status emojis
  *   - `getAvg`: Calculate average latency from all successful pings
  *   - `getVerdict`: Determine verdict string based on average latency (Overloaded for 429)
  *   - `getUptime`: Calculate uptime percentage from ping history
  *   - `sortResults`: Sort models by various columns
  *   - `checkNvidiaNimConfig`: Check if NVIDIA NIM provider is configured in OpenCode
+ *   - `isTcpPortAvailable` / `resolveOpenCodeTmuxPort`: Pick a safe OpenCode port when running in tmux
  *   - `startOpenCode`: Launch OpenCode CLI with selected model (configures if needed)
  *   - `startOpenCodeDesktop`: Set model in shared config & open OpenCode Desktop app
  *   - `loadOpenClawConfig` / `saveOpenClawConfig`: Manage ~/.openclaw/openclaw.json
@@ -57,8 +58,8 @@
  *   ⚙️ Configuration:
  *   - 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
+ *   - Env vars override config: NVIDIA_API_KEY, GROQ_API_KEY, CEREBRAS_API_KEY, OPENROUTER_API_KEY, HUGGINGFACE_API_KEY/HF_TOKEN, REPLICATE_API_TOKEN, DEEPINFRA_API_KEY/DEEPINFRA_TOKEN, FIREWORKS_API_KEY, etc.
+ *   - Models loaded from sources.js — all provider/model definitions are centralized there
  *   - OpenCode config: ~/.config/opencode/opencode.json
  *   - OpenClaw config: ~/.openclaw/openclaw.json
  *   - Ping timeout: 15s per attempt
@@ -86,6 +87,7 @@ import { readFileSync, writeFileSync, existsSync, copyFileSync, mkdirSync } from
 import { randomUUID } from 'crypto'
 import { homedir } from 'os'
 import { join, dirname } from 'path'
+import { createServer } from 'net'
 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'
@@ -486,7 +488,7 @@ function runUpdate(latestVersion) {
 
 // ─── First-run wizard ─────────────────────────────────────────────────────────
 // 📖 Shown when NO provider has a key configured yet.
-// 📖 Steps through all 3 providers sequentially — each is optional (Enter to skip).
+// 📖 Steps through all configured 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) {
@@ -495,81 +497,17 @@ async function promptApiKey(config) {
   console.log(chalk.dim('  Enter keys for any provider you want to use. Press Enter to skip one.'))
   console.log()
 
-  // 📖 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_',
-    },
-    {
-      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',
-    },
-  ]
+  // 📖 Build providers from sources to keep setup in sync with actual supported providers.
+  const providers = Object.keys(sources).map((key) => {
+    const meta = PROVIDER_METADATA[key] || {}
+    return {
+      key,
+      label: meta.label || sources[key]?.name || key,
+      color: meta.color || chalk.white,
+      url: meta.signupUrl || 'https://example.com',
+      hint: meta.signupHint || 'Create API key',
+    }
+  })
 
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
 
@@ -1121,23 +1059,50 @@ function renderTable(results, pendingPings, frame, cursor = null, sortColumn = '
 // ─── HTTP ping ────────────────────────────────────────────────────────────────
 
 // 📖 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).
+// 📖 providerKey and url determine provider-specific request format.
 // 📖 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) {
+function buildPingRequest(apiKey, modelId, providerKey, url) {
+  if (providerKey === 'replicate') {
+    // 📖 Replicate uses /v1/predictions with a different payload than OpenAI chat-completions.
+    const replicateHeaders = { 'Content-Type': 'application/json', Prefer: 'wait=4' }
+    if (apiKey) replicateHeaders.Authorization = `Token ${apiKey}`
+    return {
+      url,
+      headers: replicateHeaders,
+      body: { version: modelId, input: { prompt: 'hi' } },
+    }
+  }
+
+  const headers = { 'Content-Type': 'application/json' }
+  if (apiKey) headers.Authorization = `Bearer ${apiKey}`
+  if (providerKey === 'openrouter') {
+    // 📖 OpenRouter recommends optional app identification headers.
+    headers['HTTP-Referer'] = 'https://github.com/vava-nessa/free-coding-models'
+    headers['X-Title'] = 'free-coding-models'
+  }
+
+  return {
+    url,
+    headers,
+    body: { model: modelId, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 },
+  }
+}
+
+async function ping(apiKey, modelId, providerKey, 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, {
+    const req = buildPingRequest(apiKey, modelId, providerKey, url)
+    const resp = await fetch(req.url, {
       method: 'POST', signal: ctrl.signal,
-      headers,
-      body: JSON.stringify({ model: modelId, messages: [{ role: 'user', content: 'hi' }], max_tokens: 1 }),
+      headers: req.headers,
+      body: JSON.stringify(req.body),
     })
-    return { code: String(resp.status), ms: Math.round(performance.now() - t0) }
+    // 📖 Normalize all HTTP 2xx statuses to "200" so existing verdict/avg logic still works.
+    const code = resp.status >= 200 && resp.status < 300 ? '200' : String(resp.status)
+    return { code, ms: Math.round(performance.now() - t0) }
   } catch (err) {
     const isTimeout = err.name === 'AbortError'
     return {
@@ -1178,12 +1143,112 @@ const ENV_VAR_NAMES = {
   cerebras:   'CEREBRAS_API_KEY',
   sambanova:  'SAMBANOVA_API_KEY',
   openrouter: 'OPENROUTER_API_KEY',
+  huggingface:'HUGGINGFACE_API_KEY',
+  replicate:  'REPLICATE_API_TOKEN',
+  deepinfra:  'DEEPINFRA_API_KEY',
+  fireworks:  'FIREWORKS_API_KEY',
   codestral:  'CODESTRAL_API_KEY',
   hyperbolic: 'HYPERBOLIC_API_KEY',
   scaleway:   'SCALEWAY_API_KEY',
   googleai:   'GOOGLE_API_KEY',
 }
 
+// 📖 Provider metadata used by the setup wizard and Settings details panel.
+// 📖 Keeps signup links + rate limits centralized so UI stays consistent.
+const PROVIDER_METADATA = {
+  nvidia: {
+    label: 'NVIDIA NIM',
+    color: chalk.rgb(118, 185, 0),
+    signupUrl: 'https://build.nvidia.com',
+    signupHint: 'Profile → API Keys → Generate',
+    rateLimits: 'Free tier (provider quota by model)',
+  },
+  groq: {
+    label: 'Groq',
+    color: chalk.rgb(249, 103, 20),
+    signupUrl: 'https://console.groq.com/keys',
+    signupHint: 'API Keys → Create API Key',
+    rateLimits: 'Free dev tier (provider quota)',
+  },
+  cerebras: {
+    label: 'Cerebras',
+    color: chalk.rgb(0, 180, 255),
+    signupUrl: 'https://cloud.cerebras.ai',
+    signupHint: 'API Keys → Create',
+    rateLimits: 'Free dev tier (provider quota)',
+  },
+  sambanova: {
+    label: 'SambaNova',
+    color: chalk.rgb(255, 165, 0),
+    signupUrl: 'https://sambanova.ai/developers',
+    signupHint: 'Developers portal → Create API key',
+    rateLimits: 'Dev tier generous quota',
+  },
+  openrouter: {
+    label: 'OpenRouter',
+    color: chalk.rgb(120, 80, 255),
+    signupUrl: 'https://openrouter.ai/keys',
+    signupHint: 'API Keys → Create',
+    rateLimits: '50 req/day, 20/min (:free shared quota)',
+  },
+  huggingface: {
+    label: 'Hugging Face Inference',
+    color: chalk.rgb(255, 182, 0),
+    signupUrl: 'https://huggingface.co/settings/tokens',
+    signupHint: 'Settings → Access Tokens',
+    rateLimits: 'Free monthly credits (~$0.10)',
+  },
+  replicate: {
+    label: 'Replicate',
+    color: chalk.rgb(120, 160, 255),
+    signupUrl: 'https://replicate.com/account/api-tokens',
+    signupHint: 'Account → API Tokens',
+    rateLimits: 'Developer free quota',
+  },
+  deepinfra: {
+    label: 'DeepInfra',
+    color: chalk.rgb(0, 180, 140),
+    signupUrl: 'https://deepinfra.com/login',
+    signupHint: 'Login → API keys',
+    rateLimits: 'Free dev tier (low-latency quota)',
+  },
+  fireworks: {
+    label: 'Fireworks AI',
+    color: chalk.rgb(255, 80, 50),
+    signupUrl: 'https://fireworks.ai',
+    signupHint: 'Create account → Generate API key',
+    rateLimits: '$1 free credits (new dev accounts)',
+  },
+  codestral: {
+    label: 'Mistral Codestral',
+    color: chalk.rgb(255, 100, 100),
+    signupUrl: 'https://codestral.mistral.ai',
+    signupHint: 'API Keys → Create',
+    rateLimits: '30 req/min, 2000/day',
+  },
+  hyperbolic: {
+    label: 'Hyperbolic',
+    color: chalk.rgb(0, 200, 150),
+    signupUrl: 'https://app.hyperbolic.ai/settings',
+    signupHint: 'Settings → API Keys',
+    rateLimits: '$1 free trial credits',
+  },
+  scaleway: {
+    label: 'Scaleway',
+    color: chalk.rgb(130, 0, 250),
+    signupUrl: 'https://console.scaleway.com/iam/api-keys',
+    signupHint: 'IAM → API Keys',
+    rateLimits: '1M free tokens',
+  },
+  googleai: {
+    label: 'Google AI Studio',
+    color: chalk.rgb(66, 133, 244),
+    signupUrl: 'https://aistudio.google.com/apikey',
+    signupHint: 'Get API key',
+    rateLimits: '14.4K req/day, 30/min',
+  },
+}
+
 // 📖 OpenCode config location varies by platform
 // 📖 Windows: %APPDATA%\opencode\opencode.json (or sometimes ~/.config/opencode)
 // 📖 macOS/Linux: ~/.config/opencode/opencode.json
@@ -1193,6 +1258,45 @@ const OPENCODE_CONFIG = isWindows
 
 // 📖 Fallback to .config on Windows if AppData doesn't exist
 const OPENCODE_CONFIG_FALLBACK = join(homedir(), '.config', 'opencode', 'opencode.json')
+const OPENCODE_PORT_RANGE_START = 4096
+const OPENCODE_PORT_RANGE_END = 5096
+
+// 📖 isTcpPortAvailable: checks if a local TCP port is free for OpenCode.
+// 📖 Used to avoid tmux sub-agent port conflicts when multiple projects run in parallel.
+function isTcpPortAvailable(port) {
+  return new Promise((resolve) => {
+    const server = createServer()
+    server.once('error', () => resolve(false))
+    server.once('listening', () => {
+      server.close(() => resolve(true))
+    })
+    server.listen(port)
+  })
+}
+
+// 📖 resolveOpenCodeTmuxPort: selects a safe port for OpenCode when inside tmux.
+// 📖 Priority:
+// 📖 1) OPENCODE_PORT from env (if valid and available)
+// 📖 2) First available port in 4096-5095
+async function resolveOpenCodeTmuxPort() {
+  const envPortRaw = process.env.OPENCODE_PORT
+  const envPort = Number.parseInt(envPortRaw || '', 10)
+
+  if (Number.isInteger(envPort) && envPort > 0 && envPort <= 65535) {
+    if (await isTcpPortAvailable(envPort)) {
+      return { port: envPort, source: 'env' }
+    }
+    console.log(chalk.yellow(`  ⚠ OPENCODE_PORT=${envPort} is already in use; selecting another port for this run.`))
+  }
+
+  for (let port = OPENCODE_PORT_RANGE_START; port < OPENCODE_PORT_RANGE_END; port++) {
+    if (await isTcpPortAvailable(port)) {
+      return { port, source: 'auto' }
+    }
+  }
+
+  return null
+}
 
 function getOpenCodeConfigPath() {
   if (existsSync(OPENCODE_CONFIG)) return OPENCODE_CONFIG
@@ -1243,10 +1347,30 @@ async function spawnOpenCode(args, providerKey, fcmConfig) {
   const envVarName = ENV_VAR_NAMES[providerKey]
   const resolvedKey = getApiKey(fcmConfig, providerKey)
   const childEnv = { ...process.env }
+  const finalArgs = [...args]
+  const hasExplicitPortArg = finalArgs.includes('--port')
   if (envVarName && resolvedKey) childEnv[envVarName] = resolvedKey
 
+  // 📖 In tmux, OpenCode sub-agents need a listening port to open extra panes.
+  // 📖 We auto-pick one if the user did not provide --port explicitly.
+  if (process.env.TMUX && !hasExplicitPortArg) {
+    const tmuxPort = await resolveOpenCodeTmuxPort()
+    if (tmuxPort) {
+      const portValue = String(tmuxPort.port)
+      childEnv.OPENCODE_PORT = portValue
+      finalArgs.push('--port', portValue)
+      if (tmuxPort.source === 'env') {
+        console.log(chalk.dim(`  📺 tmux detected — using OPENCODE_PORT=${portValue}.`))
+      } else {
+        console.log(chalk.dim(`  📺 tmux detected — using OpenCode port ${portValue} for sub-agent panes.`))
+      }
+    } else {
+      console.log(chalk.yellow(`  ⚠ tmux detected but no free OpenCode port found in ${OPENCODE_PORT_RANGE_START}-${OPENCODE_PORT_RANGE_END - 1}; launching without --port.`))
+    }
+  }
+
   const { spawn } = await import('child_process')
-  const child = spawn('opencode', args, {
+  const child = spawn('opencode', finalArgs, {
     stdio: 'inherit',
     shell: true,
     detached: false,
@@ -1269,7 +1393,7 @@ async function spawnOpenCode(args, providerKey, fcmConfig) {
 
 // ─── Start OpenCode ────────────────────────────────────────────────────────────
 // 📖 Launches OpenCode with the selected model.
-// 📖 Handles all 3 providers: nvidia (needs custom provider config), groq & cerebras (built-in in OpenCode).
+// 📖 Handles nvidia + all OpenAI-compatible providers defined in sources.js.
 // 📖 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 }
@@ -1357,6 +1481,14 @@ After installation, you can use: opencode --model ${modelRef}`
       await spawnOpenCode([], providerKey, fcmConfig)
     }
   } else {
+    if (providerKey === 'replicate') {
+      console.log(chalk.yellow('  ⚠ Replicate models are monitor-only for now in OpenCode mode.'))
+      console.log(chalk.dim('    Reason: Replicate uses /v1/predictions instead of OpenAI chat-completions.'))
+      console.log(chalk.dim('    You can still benchmark this model in the TUI and use other providers for OpenCode launch.'))
+      console.log()
+      return
+    }
+
     // 📖 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.
@@ -1413,6 +1545,36 @@ After installation, you can use: opencode --model ${modelRef}`
           },
           models: {}
         }
+      } else if (providerKey === 'huggingface') {
+        config.provider.huggingface = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Hugging Face Inference',
+          options: {
+            baseURL: 'https://router.huggingface.co/v1',
+            apiKey: '{env:HUGGINGFACE_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'deepinfra') {
+        config.provider.deepinfra = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'DeepInfra',
+          options: {
+            baseURL: 'https://api.deepinfra.com/v1/openai',
+            apiKey: '{env:DEEPINFRA_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'fireworks') {
+        config.provider.fireworks = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Fireworks AI',
+          options: {
+            baseURL: 'https://api.fireworks.ai/inference/v1',
+            apiKey: '{env:FIREWORKS_API_KEY}'
+          },
+          models: {}
+        }
       } else if (providerKey === 'codestral') {
         config.provider.codestral = {
           npm: '@ai-sdk/openai-compatible',
@@ -1488,7 +1650,7 @@ After installation, you can use: opencode --model ${modelRef}`
 // ─── 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).
+// 📖 Handles nvidia + all OpenAI-compatible providers defined in sources.js.
 // 📖 No need to wait for exit — Desktop app stays open independently.
 async function startOpenCodeDesktop(model, fcmConfig) {
   const providerKey = model.providerKey ?? 'nvidia'
@@ -1589,6 +1751,14 @@ ${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_k
       console.log()
     }
   } else {
+    if (providerKey === 'replicate') {
+      console.log(chalk.yellow('  ⚠ Replicate models are monitor-only for now in OpenCode Desktop mode.'))
+      console.log(chalk.dim('    Reason: Replicate uses /v1/predictions instead of OpenAI chat-completions.'))
+      console.log(chalk.dim('    You can still benchmark this model in the TUI and use other providers for Desktop launch.'))
+      console.log()
+      return
+    }
+
     // 📖 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.
@@ -1643,6 +1813,36 @@ ${isWindows ? 'set NVIDIA_API_KEY=your_key_here' : 'export NVIDIA_API_KEY=your_k
           },
           models: {}
         }
+      } else if (providerKey === 'huggingface') {
+        config.provider.huggingface = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Hugging Face Inference',
+          options: {
+            baseURL: 'https://router.huggingface.co/v1',
+            apiKey: '{env:HUGGINGFACE_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'deepinfra') {
+        config.provider.deepinfra = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'DeepInfra',
+          options: {
+            baseURL: 'https://api.deepinfra.com/v1/openai',
+            apiKey: '{env:DEEPINFRA_API_KEY}'
+          },
+          models: {}
+        }
+      } else if (providerKey === 'fireworks') {
+        config.provider.fireworks = {
+          npm: '@ai-sdk/openai-compatible',
+          name: 'Fireworks AI',
+          options: {
+            baseURL: 'https://api.fireworks.ai/inference/v1',
+            apiKey: '{env:FIREWORKS_API_KEY}'
+          },
+          models: {}
+        }
       } else if (providerKey === 'codestral') {
         config.provider.codestral = {
           npm: '@ai-sdk/openai-compatible',
@@ -1854,7 +2054,7 @@ async function runFiableMode(config) {
   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 }) => {
+    return ping(rApiKey, r.modelId, r.providerKey, url).then(({ code, ms }) => {
       r.pings.push({ ms, code })
       if (code === '200') {
         r.status = 'up'
@@ -2111,12 +2311,14 @@ async function main() {
     lines.push('')
     lines.push(`  ${chalk.bold('⚙  Settings')}  ${chalk.dim('— free-coding-models v' + LOCAL_VERSION)}`)
     lines.push('')
-    lines.push(`  ${chalk.bold('Providers')}`)
+    lines.push(`  ${chalk.bold('🧩 Providers')}`)
+    lines.push(`  ${chalk.dim('  ' + '─'.repeat(112))}`)
     lines.push('')
 
     for (let i = 0; i < providerKeys.length; i++) {
       const pk = providerKeys[i]
       const src = sources[pk]
+      const meta = PROVIDER_METADATA[pk] || {}
       const isCursor = i === state.settingsCursor
       const enabled = isProviderEnabled(state.config, pk)
       const keyVal = state.config.apiKeys?.[pk] ?? ''
@@ -2140,22 +2342,37 @@ async function main() {
       if (testResult === 'pending') testBadge = chalk.yellow('[Testing…]')
       else if (testResult === 'ok')   testBadge = chalk.greenBright('[Test ✅]')
       else if (testResult === 'fail') testBadge = chalk.red('[Test ❌]')
+      const rateSummary = chalk.dim((meta.rateLimits || 'No limit info').slice(0, 36))
 
-      const enabledBadge = enabled ? chalk.greenBright('✅') : chalk.dim('⬜')
-      const providerName = chalk.bold(src.name.padEnd(10))
+      const enabledBadge = enabled ? chalk.greenBright('✅') : chalk.redBright('❌')
+      const providerName = chalk.bold((meta.label || src.name || pk).slice(0, 22).padEnd(22))
       const bullet = isCursor ? chalk.bold.cyan('  ❯ ') : chalk.dim('    ')
 
-      const row = `${bullet}[ ${enabledBadge} ] ${providerName}  ${keyDisplay.padEnd(30)}  ${testBadge}`
+      const row = `${bullet}[ ${enabledBadge} ] ${providerName}  ${keyDisplay.padEnd(30)}  ${testBadge}  ${rateSummary}`
       lines.push(isCursor ? chalk.bgRgb(30, 30, 60)(row) : row)
     }
 
     lines.push('')
-    lines.push(`  ${chalk.bold('Analytics')}`)
+    const selectedProviderKey = providerKeys[Math.min(state.settingsCursor, providerKeys.length - 1)]
+    const selectedSource = sources[selectedProviderKey]
+    const selectedMeta = PROVIDER_METADATA[selectedProviderKey] || {}
+    if (selectedSource && state.settingsCursor < telemetryRowIdx) {
+      const selectedKey = getApiKey(state.config, selectedProviderKey)
+      const setupStatus = selectedKey ? chalk.green('API key detected ✅') : chalk.yellow('API key missing ⚠')
+      lines.push(`  ${chalk.bold('Setup Instructions')} — ${selectedMeta.label || selectedSource.name || selectedProviderKey}`)
+      lines.push(chalk.dim(`  1) Create a ${selectedMeta.label || selectedSource.name} account: ${selectedMeta.signupUrl || 'signup link missing'}`))
+      lines.push(chalk.dim(`  2) ${selectedMeta.signupHint || 'Generate an API key and paste it with Enter on this row'}`))
+      lines.push(chalk.dim(`  3) Press ${chalk.yellow('T')} to test your key. Status: ${setupStatus}`))
+      lines.push('')
+    }
+
+    lines.push(`  ${chalk.bold('📊 Analytics')}`)
+    lines.push(`  ${chalk.dim('  ' + '─'.repeat(112))}`)
     lines.push('')
 
     const telemetryCursor = state.settingsCursor === telemetryRowIdx
     const telemetryEnabled = state.config.telemetry?.enabled === true
-    const telemetryStatus = telemetryEnabled ? chalk.greenBright('✅ Enabled') : chalk.dim('⬜ Disabled')
+    const telemetryStatus = telemetryEnabled ? chalk.greenBright('✅ Enabled') : chalk.redBright('❌ Disabled')
     const telemetryRowBullet = telemetryCursor ? chalk.bold.cyan('  ❯ ') : chalk.dim('    ')
     const telemetryEnv = parseTelemetryEnv(process.env.FREE_CODING_MODELS_TELEMETRY)
     const telemetrySource = telemetryEnv === null
@@ -2227,7 +2444,7 @@ async function main() {
     if (!testModel) { state.settingsTestResults[providerKey] = 'fail'; return }
 
     state.settingsTestResults[providerKey] = 'pending'
-    const { code } = await ping(testKey, testModel, src.url)
+    const { code } = await ping(testKey, testModel, providerKey, src.url)
     state.settingsTestResults[providerKey] = code === '200' ? 'ok' : 'fail'
   }
 
@@ -2566,7 +2783,7 @@ async function main() {
   const pingModel = async (r) => {
     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)
+    const { code, ms } = await ping(providerApiKey, r.modelId, r.providerKey, providerUrl)
 
     // 📖 Store ping result as object with ms and code
     // 📖 ms = actual response time (even for errors like 429)

package/lib/config.js

@@ -17,6 +17,10 @@
  *       "cerebras":   "csk_xxx",
  *       "sambanova":  "sn-xxx",
  *       "openrouter": "sk-or-xxx",
+ *       "huggingface":"hf_xxx",
+ *       "replicate":  "r8_xxx",
+ *       "deepinfra":  "di_xxx",
+ *       "fireworks":  "fw_xxx",
  *       "codestral":  "csk-xxx",
  *       "hyperbolic": "eyJ...",
  *       "scaleway":   "scw-xxx",
@@ -28,6 +32,10 @@
  *       "cerebras":   { "enabled": true },
  *       "sambanova":  { "enabled": true },
  *       "openrouter": { "enabled": true },
+ *       "huggingface":{ "enabled": true },
+ *       "replicate":  { "enabled": true },
+ *       "deepinfra":  { "enabled": true },
+ *       "fireworks":  { "enabled": true },
  *       "codestral":  { "enabled": true },
  *       "hyperbolic": { "enabled": true },
  *       "scaleway":   { "enabled": true },
@@ -74,6 +82,10 @@ const ENV_VARS = {
   cerebras:   'CEREBRAS_API_KEY',
   sambanova:  'SAMBANOVA_API_KEY',
   openrouter: 'OPENROUTER_API_KEY',
+  huggingface:['HUGGINGFACE_API_KEY', 'HF_TOKEN'],
+  replicate:  'REPLICATE_API_TOKEN',
+  deepinfra:  ['DEEPINFRA_API_KEY', 'DEEPINFRA_TOKEN'],
+  fireworks:  'FIREWORKS_API_KEY',
   codestral:  'CODESTRAL_API_KEY',
   hyperbolic: 'HYPERBOLIC_API_KEY',
   scaleway:   'SCALEWAY_API_KEY',
@@ -163,7 +175,10 @@ export function saveConfig(config) {
 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]
+  const envCandidates = Array.isArray(envVar) ? envVar : [envVar]
+  for (const candidate of envCandidates) {
+    if (candidate && process.env[candidate]) return process.env[candidate]
+  }
 
   // 📖 Config file value
   const key = config?.apiKeys?.[providerKey]

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.63",
+  "version": "0.1.64",
   "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,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, 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 nvidiaNim, groq, cerebras, sambanova, openrouter, huggingface, replicate, deepinfra, fireworks, codestral, hyperbolic, scaleway, googleai — model arrays per provider
+ *   @exports sources — map of { nvidia, groq, cerebras, sambanova, openrouter, huggingface, replicate, deepinfra, fireworks, 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
@@ -139,13 +139,17 @@ export const sambanova = [
   ['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'],
+  // ── A tier — requested Llama3-Groq coding tuned family ──
+  ['Llama-3-Groq-70B-Tool-Use',            'Llama3-Groq 70B',    'A',  '43.0%', '128k'],
 ]
 
 // 📖 OpenRouter source - https://openrouter.ai
 // 📖 Free :free models with shared quota — 50 free req/day
-// 📖 API keys at https://openrouter.ai/settings/keys
+// 📖 API keys at https://openrouter.ai/keys
 export const openrouter = [
-  ['qwen/qwen3-coder:free',                    'Qwen3 Coder',        'S+', '70.6%', '256k'],
+  ['qwen/qwen3-coder:480b-free',               'Qwen3 Coder 480B',   'S+', '70.6%', '256k'],
+  ['mistralai/devstral-2-free',                'Devstral 2',         'S+', '72.2%', '256k'],
+  ['mimo-v2-flash-free',                       'Mimo V2 Flash',      'A',  '45.0%', '128k'],
   ['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'],
@@ -155,6 +159,35 @@ export const openrouter = [
   ['meta-llama/llama-3.3-70b-instruct:free',   'Llama 3.3 70B',      'A-', '39.5%', '128k'],
 ]
 
+// 📖 Hugging Face Inference source - https://huggingface.co
+// 📖 OpenAI-compatible endpoint via router.huggingface.co/v1
+// 📖 Free monthly credits on developer accounts (~$0.10) — token at https://huggingface.co/settings/tokens
+export const huggingface = [
+  ['deepseek-ai/DeepSeek-V3-Coder',            'DeepSeek V3 Coder',  'S',  '62.0%', '128k'],
+  ['bigcode/starcoder2-15b',                   'StarCoder2 15B',     'B',  '25.0%', '16k'],
+]
+
+// 📖 Replicate source - https://replicate.com
+// 📖 Uses predictions endpoint (not OpenAI chat-completions) with token auth
+export const replicate = [
+  ['codellama/CodeLlama-70b-Instruct-hf',      'CodeLlama 70B',      'A-', '39.0%', '16k'],
+]
+
+// 📖 DeepInfra source - https://deepinfra.com
+// 📖 OpenAI-compatible endpoint: https://api.deepinfra.com/v1/openai/chat/completions
+export const deepinfra = [
+  ['mistralai/Mixtral-8x22B-Instruct-v0.1',    'Mixtral Code',       'B+', '32.0%', '64k'],
+  ['meta-llama/Meta-Llama-3.1-70B-Instruct',   'Llama 3.1 70B',      'A-', '39.5%', '128k'],
+]
+
+// 📖 Fireworks AI source - https://fireworks.ai
+// 📖 OpenAI-compatible endpoint: https://api.fireworks.ai/inference/v1/chat/completions
+// 📖 Free trial credits: $1 for new developers
+export const fireworks = [
+  ['accounts/fireworks/models/deepseek-v3',    'DeepSeek V3',        'S',  '62.0%', '128k'],
+  ['accounts/fireworks/models/deepseek-r1',    'DeepSeek R1',        'S',  '61.0%', '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
@@ -225,6 +258,26 @@ export const sources = {
     url: 'https://openrouter.ai/api/v1/chat/completions',
     models: openrouter,
   },
+  huggingface: {
+    name: 'Hugging Face',
+    url: 'https://router.huggingface.co/v1/chat/completions',
+    models: huggingface,
+  },
+  replicate: {
+    name: 'Replicate',
+    url: 'https://api.replicate.com/v1/predictions',
+    models: replicate,
+  },
+  deepinfra: {
+    name: 'DeepInfra',
+    url: 'https://api.deepinfra.com/v1/openai/chat/completions',
+    models: deepinfra,
+  },
+  fireworks: {
+    name: 'Fireworks',
+    url: 'https://api.fireworks.ai/inference/v1/chat/completions',
+    models: fireworks,
+  },
   codestral: {
     name: 'Codestral',
     url: 'https://codestral.mistral.ai/v1/chat/completions',