free-coding-models 0.1.4 → 0.1.12

package/README.md

@@ -313,6 +313,9 @@ Or run without flags and choose **OpenClaw** from the startup menu.
     "defaults": {
       "model": {
         "primary": "nvidia/deepseek-ai/deepseek-v3.2"
+      },
+      "models": {
+        "nvidia/deepseek-ai/deepseek-v3.2": {}
       }
     }
   }
@@ -321,6 +324,8 @@ Or run without flags and choose **OpenClaw** from the startup menu.
 
 > ⚠️ **Note:** `providers` must be nested under `models.providers` — not at the config root. A root-level `providers` key is ignored by OpenClaw.
 
+> ⚠️ **Note:** The model must also be listed in `agents.defaults.models` (the allowlist). Without this entry, OpenClaw rejects the model with *"not allowed"* even if it is set as primary.
+
 ### After updating OpenClaw config
 
 OpenClaw's gateway **auto-reloads** config file changes (depending on `gateway.reload.mode`). To apply manually:
@@ -337,6 +342,43 @@ openclaw configure
 
 > 💡 **Why use remote NIM models with OpenClaw?** NVIDIA NIM serves models via a fast API — no local GPU required, no VRAM limits, free credits for developers. You get frontier-class coding models (DeepSeek V3, Kimi K2, Qwen3 Coder) without downloading anything.
 
+### Patching OpenClaw for full NVIDIA model support
+
+**Problem:** By default, OpenClaw only allows a few specific NVIDIA models in its allowlist. If you try to use a model that's not in the list, you'll get this error:
+
+```
+Model "nvidia/mistralai/devstral-2-123b-instruct-2512" is not allowed. Use /models to list providers, or /models <provider> to list models.
+```
+
+**Solution:** Patch OpenClaw's configuration to add ALL 47 NVIDIA models from `free-coding-models` to the allowlist:
+
+```bash
+# From the free-coding-models package directory
+node patch-openclaw.js
+```
+
+This script:
+- Backs up `~/.openclaw/agents/main/agent/models.json` and `~/.openclaw/openclaw.json`
+- Adds all 47 NVIDIA models with proper context window and token limits
+- Preserves existing models and configuration
+- Prints a summary of what was added
+
+**After patching:**
+
+1. Restart OpenClaw gateway:
+   ```bash
+   systemctl --user restart openclaw-gateway
+   ```
+
+2. Verify models are available:
+   ```bash
+   free-coding-models --openclaw
+   ```
+
+3. Select any model — no more "not allowed" errors!
+
+**Why this is needed:** OpenClaw uses a strict allowlist system to prevent typos and invalid models. The `patch-openclaw.js` script populates the allowlist with all known working NVIDIA models, so you can freely switch between them without manually editing config files.
+
 ---
 
 ## ⚙️ How it works

package/bin/free-coding-models.js

@@ -75,10 +75,44 @@ import { readFileSync, writeFileSync, existsSync, copyFileSync, mkdirSync } from
 import { homedir } from 'os'
 import { join } from 'path'
 import { MODELS } 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'
 
 const require = createRequire(import.meta.url)
 const readline = require('readline')
 
+// ─── Version check ────────────────────────────────────────────────────────────
+const pkg = require('../package.json')
+const LOCAL_VERSION = pkg.version
+
+async function checkForUpdate() {
+  try {
+    const res = await fetch('https://registry.npmjs.org/free-coding-models/latest', { signal: AbortSignal.timeout(5000) })
+    if (!res.ok) return null
+    const data = await res.json()
+    if (data.version && data.version !== LOCAL_VERSION) return data.version
+  } catch {}
+  return null
+}
+
+function runUpdate() {
+  const { execSync } = require('child_process')
+  console.log()
+  console.log(chalk.bold.cyan('  ⬆ Updating free-coding-models...'))
+  console.log()
+  try {
+    execSync('npm i -g free-coding-models', { stdio: 'inherit' })
+    console.log()
+    console.log(chalk.green('  ✅ Update complete! Please restart free-coding-models.'))
+    console.log()
+  } catch {
+    console.log()
+    console.log(chalk.red('  ✖ Update failed. Try manually: npm i -g free-coding-models'))
+    console.log()
+  }
+  process.exit(0)
+}
+
 // ─── Config path ──────────────────────────────────────────────────────────────
 const CONFIG_PATH = join(homedir(), '.free-coding-models')
 
@@ -128,8 +162,8 @@ async function promptApiKey() {
 // ─── Startup mode selection menu ──────────────────────────────────────────────
 // 📖 Shown at startup when neither --opencode nor --openclaw flag is given.
 // 📖 Simple arrow-key selector in normal terminal (not alt screen).
-// 📖 Returns 'opencode' or 'openclaw'.
-async function promptModeSelection() {
+// 📖 Returns 'opencode', 'openclaw', or 'update'.
+async function promptModeSelection(latestVersion) {
   const options = [
     {
       label: 'OpenCode',
@@ -143,6 +177,14 @@ async function promptModeSelection() {
     },
   ]
 
+  if (latestVersion) {
+    options.push({
+      label: 'Update now',
+      icon: '⬆',
+      description: `Update free-coding-models to v${latestVersion}`,
+    })
+  }
+
   return new Promise((resolve) => {
     let selected = 0
 
@@ -150,6 +192,10 @@ async function promptModeSelection() {
     const render = () => {
       process.stdout.write('\x1b[2J\x1b[H') // clear screen + cursor home
       console.log()
+      if (latestVersion) {
+        console.log(chalk.red(`  ⚠ New version available (v${latestVersion}), please run npm i -g free-coding-models to install`))
+        console.log()
+      }
       console.log(chalk.bold('  ⚡ Free Coding Models') + chalk.dim(' — Choose your tool'))
       console.log()
       for (let i = 0; i < options.length; i++) {
@@ -189,7 +235,9 @@ async function promptModeSelection() {
         if (process.stdin.isTTY) process.stdin.setRawMode(false)
         process.stdin.removeListener('keypress', onKey)
         process.stdin.pause()
-        resolve(selected === 0 ? 'opencode' : 'openclaw')
+        const choices = ['opencode', 'openclaw']
+        if (latestVersion) choices.push('update')
+        resolve(choices[selected])
       }
     }
 
@@ -252,90 +300,8 @@ const spinCell = (f, o = 0) => chalk.dim.yellow(FRAMES[(f + o) % FRAMES.length].
 
 // ─── Table renderer ───────────────────────────────────────────────────────────
 
-const TIER_ORDER = ['S+', 'S', 'A+', 'A', 'A-', 'B+', 'B', 'C']
-const getAvg = r => {
-  // 📖 Calculate average only from successful pings (code 200)
-  // 📖 pings are objects: { ms, code }
-  const successfulPings = (r.pings || []).filter(p => p.code === '200')
-  if (successfulPings.length === 0) return Infinity
-  return Math.round(successfulPings.reduce((a, b) => a + b.ms, 0) / successfulPings.length)
-}
-
-// 📖 Verdict order for sorting
-const VERDICT_ORDER = ['Perfect', 'Normal', 'Slow', 'Very Slow', 'Overloaded', 'Unstable', 'Not Active', 'Pending']
-
-// 📖 Get verdict for a model result
-const getVerdict = (r) => {
-  const avg = getAvg(r)
-  const wasUpBefore = r.pings.length > 0 && r.pings.some(p => p.code === '200')
-
-  // 📖 429 = rate limited = Overloaded
-  if (r.httpCode === '429') return 'Overloaded'
-  if ((r.status === 'timeout' || r.status === 'down') && wasUpBefore) return 'Unstable'
-  if (r.status === 'timeout' || r.status === 'down') return 'Not Active'
-  if (avg === Infinity) return 'Pending'
-  if (avg < 400) return 'Perfect'
-  if (avg < 1000) return 'Normal'
-  if (avg < 3000) return 'Slow'
-  if (avg < 5000) return 'Very Slow'
-  if (avg < 10000) return 'Unstable'
-  return 'Unstable'
-}
-
-// 📖 Calculate uptime percentage (successful pings / total pings)
-// 📖 Only count code 200 responses
-const getUptime = (r) => {
-  if (r.pings.length === 0) return 0
-  const successful = r.pings.filter(p => p.code === '200').length
-  return Math.round((successful / r.pings.length) * 100)
-}
-
-// 📖 Sort results using the same logic as renderTable - used for both display and selection
-const sortResults = (results, sortColumn, sortDirection) => {
-  return [...results].sort((a, b) => {
-    let cmp = 0
-
-    switch (sortColumn) {
-      case 'rank':
-        cmp = a.idx - b.idx
-        break
-      case 'tier':
-        cmp = TIER_ORDER.indexOf(a.tier) - TIER_ORDER.indexOf(b.tier)
-        break
-      case 'origin':
-        cmp = 'NVIDIA NIM'.localeCompare('NVIDIA NIM') // All same for now
-        break
-      case 'model':
-        cmp = a.label.localeCompare(b.label)
-        break
-      case 'ping': {
-        const aLast = a.pings.length > 0 ? a.pings[a.pings.length - 1] : null
-        const bLast = b.pings.length > 0 ? b.pings[b.pings.length - 1] : null
-        const aPing = aLast?.code === '200' ? aLast.ms : Infinity
-        const bPing = bLast?.code === '200' ? bLast.ms : Infinity
-        cmp = aPing - bPing
-        break
-      }
-      case 'avg':
-        cmp = getAvg(a) - getAvg(b)
-        break
-      case 'status':
-        cmp = a.status.localeCompare(b.status)
-        break
-      case 'verdict': {
-        const aVerdict = getVerdict(a)
-        const bVerdict = getVerdict(b)
-        cmp = VERDICT_ORDER.indexOf(aVerdict) - VERDICT_ORDER.indexOf(bVerdict)
-        break
-      }
-      case 'uptime':
-        cmp = getUptime(a) - getUptime(b)
-        break
-    }
-
-    return sortDirection === 'asc' ? cmp : -cmp
-  })
-}
+// 📖 Core logic functions (getAvg, getVerdict, getUptime, sortResults, etc.)
+// 📖 are imported from lib/utils.js for testability
 
 // 📖 renderTable: mode param controls footer hint text (opencode vs openclaw)
 function renderTable(results, pendingPings, frame, cursor = null, sortColumn = 'avg', sortDirection = 'asc', pingInterval = PING_INTERVAL, lastPingTime = Date.now(), mode = 'opencode') {
@@ -660,13 +626,21 @@ async function startOpenCode(model) {
     const { spawn } = await import('child_process')
     const child = spawn('opencode', [], {
       stdio: 'inherit',
-      shell: false
+      shell: true
     })
 
     // 📖 Wait for OpenCode to exit
     await new Promise((resolve, reject) => {
       child.on('exit', resolve)
-      child.on('error', reject)
+      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 and launch
@@ -702,13 +676,21 @@ After installation, you can use: opencode --model nvidia/${model.modelId}`
     const { spawn } = await import('child_process')
     const child = spawn('opencode', [], {
       stdio: 'inherit',
-      shell: false
+      shell: true
     })
 
     // 📖 Wait for OpenCode to exit
     await new Promise((resolve, reject) => {
       child.on('exit', resolve)
-      child.on('error', reject)
+      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)
+        }
+      })
     })
   }
 }
@@ -755,6 +737,15 @@ async function startOpenClaw(model, apiKey) {
     console.log(chalk.dim(`  💾 Backup: ${backupPath}`))
   }
 
+  // 📖 Patch models.json to add all NVIDIA models (fixes "not allowed" errors)
+  const patchResult = patchOpenClawModelsJson()
+  if (patchResult.wasPatched) {
+    console.log(chalk.dim(`  ✨ Added ${patchResult.added} NVIDIA models to allowlist (${patchResult.total} total)`))
+    if (patchResult.backup) {
+      console.log(chalk.dim(`  💾 models.json backup: ${patchResult.backup}`))
+    }
+  }
+
   // 📖 Ensure models.providers section exists with nvidia NIM block.
   // 📖 Per OpenClaw docs (docs.openclaw.ai/providers/nvidia), providers MUST be nested under
   // 📖 "models.providers", NOT at the config root. Root-level "providers" is ignored by OpenClaw.
@@ -781,6 +772,8 @@ async function startOpenClaw(model, apiKey) {
     }
   }
 
+  // 📖 Set as the default primary model for all agents.
+  // 📖 Format: "provider/model-id" — e.g. "nvidia/deepseek-ai/deepseek-v3.2"
   // 📖 Set as the default primary model for all agents.
   // 📖 Format: "provider/model-id" — e.g. "nvidia/deepseek-ai/deepseek-v3.2"
   if (!config.agents) config.agents = {}
@@ -788,6 +781,12 @@ async function startOpenClaw(model, apiKey) {
   if (!config.agents.defaults.model) config.agents.defaults.model = {}
   config.agents.defaults.model.primary = `nvidia/${model.modelId}`
 
+  // 📖 REQUIRED: OpenClaw requires the model to be explicitly listed in agents.defaults.models
+  // 📖 (the allowlist). Without this entry, OpenClaw rejects the model with "not allowed".
+  // 📖 See: https://docs.openclaw.ai/gateway/configuration-reference
+  if (!config.agents.defaults.models) config.agents.defaults.models = {}
+  config.agents.defaults.models[`nvidia/${model.modelId}`] = {}
+
   saveOpenClawConfig(config)
 
   console.log(chalk.rgb(255, 140, 0)(`  ✓ Default model set to: nvidia/${model.modelId}`))
@@ -804,27 +803,7 @@ async function startOpenClaw(model, apiKey) {
 }
 
 // ─── Helper function to find best model after analysis ────────────────────────
-function findBestModel(results) {
-  // 📖 Sort by avg ping (fastest first), then by uptime percentage (most reliable)
-  const sorted = [...results].sort((a, b) => {
-    const avgA = getAvg(a)
-    const avgB = getAvg(b)
-    const uptimeA = getUptime(a)
-    const uptimeB = getUptime(b)
-
-    // 📖 Priority 1: Models that are up (status === 'up')
-    if (a.status === 'up' && b.status !== 'up') return -1
-    if (a.status !== 'up' && b.status === 'up') return 1
-
-    // 📖 Priority 2: Fastest average ping
-    if (avgA !== avgB) return avgA - avgB
-
-    // 📖 Priority 3: Highest uptime percentage
-    return uptimeB - uptimeA
-  })
-
-  return sorted.length > 0 ? sorted[0] : null
-}
+// 📖 findBestModel is imported from lib/utils.js
 
 // ─── Function to run in fiable mode (10-second analysis then output best model) ──
 async function runFiableMode(apiKey) {
@@ -883,64 +862,28 @@ async function runFiableMode(apiKey) {
   process.exit(0)
 }
 
-// ─── Tier filter helper ────────────────────────────────────────────────────────
-// 📖 Maps a single tier letter (S, A, B, C) to the full set of matching tier strings.
-// 📖 --tier S → includes S+ and S
-// 📖 --tier A → includes A+, A, A-
-// 📖 --tier B → includes B+, B
-// 📖 --tier C → includes C only
-const TIER_LETTER_MAP = {
-  'S': ['S+', 'S'],
-  'A': ['A+', 'A', 'A-'],
-  'B': ['B+', 'B'],
-  'C': ['C'],
-}
-
-function filterByTier(results, tierLetter) {
-  const letter = tierLetter.toUpperCase()
-  const allowed = TIER_LETTER_MAP[letter]
-  if (!allowed) {
+// 📖 filterByTier and TIER_LETTER_MAP are imported from lib/utils.js
+// 📖 Wrapper that exits on invalid tier (utils version returns null instead)
+function filterByTierOrExit(results, tierLetter) {
+  const filtered = filterByTier(results, tierLetter)
+  if (filtered === null) {
     console.error(chalk.red(`  ✖ Unknown tier "${tierLetter}". Valid tiers: S, A, B, C`))
     process.exit(1)
   }
-  return results.filter(r => allowed.includes(r.tier))
+  return filtered
 }
 
 async function main() {
-  // 📖 Parse CLI arguments properly
-  const args = process.argv.slice(2)
-
-  // 📖 Extract API key (first non-flag argument) and flags
-  let apiKey = null
-  const flags = []
-
-  for (const arg of args) {
-    if (arg.startsWith('--')) {
-      flags.push(arg.toLowerCase())
-    } else if (!apiKey) {
-      apiKey = arg
-    }
-  }
+  // 📖 Parse CLI arguments using shared parseArgs utility
+  const parsed = parseArgs(process.argv)
+  let apiKey = parsed.apiKey
+  const { bestMode, fiableMode, openCodeMode, openClawMode, tierFilter } = parsed
 
   // 📖 Priority: CLI arg > env var > saved config > wizard
   if (!apiKey) {
     apiKey = process.env.NVIDIA_API_KEY || loadApiKey()
   }
 
-  // 📖 Check for CLI flags
-  const bestMode    = flags.includes('--best')
-  const fiableMode  = flags.includes('--fiable')
-  const openCodeMode  = flags.includes('--opencode')
-  const openClawMode  = flags.includes('--openclaw')
-
-  // 📖 Parse --tier X flag (e.g. --tier S, --tier A)
-  // 📖 Find "--tier" in flags array, then get the next raw arg as the tier value
-  let tierFilter = null
-  const tierIdx = args.findIndex(a => a.toLowerCase() === '--tier')
-  if (tierIdx !== -1 && args[tierIdx + 1] && !args[tierIdx + 1].startsWith('--')) {
-    tierFilter = args[tierIdx + 1].toUpperCase()
-  }
-
   if (!apiKey) {
     apiKey = await promptApiKey()
     if (!apiKey) {
@@ -957,6 +900,9 @@ async function main() {
     await runFiableMode(apiKey)
   }
 
+  // 📖 Check for available update (non-blocking, 5s timeout)
+  const latestVersion = await checkForUpdate()
+
   // 📖 Determine active mode:
   //   --opencode → opencode
   //   --openclaw → openclaw
@@ -968,7 +914,18 @@ async function main() {
     mode = 'opencode'
   } else {
     // 📖 No mode flag given — ask user with the startup menu
-    mode = await promptModeSelection()
+    mode = await promptModeSelection(latestVersion)
+  }
+
+  // 📖 Handle "update now" selection from the menu
+  if (mode === 'update') {
+    runUpdate()
+  }
+
+  // 📖 When using flags (--opencode/--openclaw), show update warning in terminal
+  if (latestVersion && (openCodeMode || openClawMode)) {
+    console.log(chalk.red(`  ⚠ New version available (v${latestVersion}), please run npm i -g free-coding-models to install`))
+    console.log()
   }
 
   // 📖 Filter models to only show top tiers if BEST mode is active
@@ -985,7 +942,7 @@ async function main() {
 
   // 📖 Apply tier letter filter if --tier X was given
   if (tierFilter) {
-    results = filterByTier(results, tierFilter)
+    results = filterByTierOrExit(results, tierFilter)
   }
 
   // 📖 Add interactive selection state - cursor index and user's choice

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.4",
+  "version": "0.1.12",
   "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",
@@ -41,11 +41,14 @@
   "files": [
     "bin/",
     "sources.js",
+    "patch-openclaw.js",
+    "patch-openclaw-models.js",
     "README.md",
     "LICENSE"
   ],
   "scripts": {
-    "start": "node bin/free-coding-models.js"
+    "start": "node bin/free-coding-models.js",
+    "test": "node --test test/test.js"
   },
   "dependencies": {
     "chalk": "^5.4.1"

package/patch-openclaw-models.js

@@ -0,0 +1,111 @@
+#!/usr/bin/env node
+/**
+ * @file patch-openclaw-models.js
+ * @description Helper function to patch OpenClaw's models.json with all NVIDIA models
+ *
+ * This is imported by bin/free-coding-models.js and called automatically
+ * when setting a model in OpenClaw mode.
+ */
+
+import { readFileSync, writeFileSync, existsSync, copyFileSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { nvidiaNim } from './sources.js'
+
+const MODELS_JSON = join(homedir(), '.openclaw', 'agents', 'main', 'agent', 'models.json')
+
+/**
+ * Patch models.json to add all NVIDIA models from sources.js
+ * @returns {Object} { added: number, total: number, wasPatched: boolean }
+ */
+export function patchOpenClawModelsJson() {
+  // Read existing config
+  let modelsConfig
+  if (!existsSync(MODELS_JSON)) {
+    return { added: 0, total: 0, wasPatched: false, error: 'models.json not found' }
+  }
+
+  try {
+    modelsConfig = JSON.parse(readFileSync(MODELS_JSON, 'utf8'))
+  } catch (err) {
+    return { added: 0, total: 0, wasPatched: false, error: err.message }
+  }
+
+  // Ensure nvidia provider exists
+  if (!modelsConfig.providers) modelsConfig.providers = {}
+  if (!modelsConfig.providers.nvidia) {
+    modelsConfig.providers.nvidia = {
+      baseUrl: 'https://integrate.api.nvidia.com/v1',
+      api: 'openai-completions',
+      models: []
+    }
+  }
+
+  // Get existing model IDs
+  const existingModelIds = new Set(modelsConfig.providers.nvidia.models.map(m => m.id))
+
+  // Helper to get model config by tier
+  function getModelConfig(tier) {
+    if (tier === 'S+' || tier === 'S') {
+      return { contextWindow: 128000, maxTokens: 8192 }
+    }
+    if (tier === 'A+') {
+      return { contextWindow: 131072, maxTokens: 4096 }
+    }
+    if (tier === 'A' || tier === 'A-') {
+      return { contextWindow: 131072, maxTokens: 4096 }
+    }
+    return { contextWindow: 32768, maxTokens: 2048 }
+  }
+
+  // Add all models from sources.js
+  let addedCount = 0
+  for (const [modelId, label, tier] of nvidiaNim) {
+    if (existingModelIds.has(modelId)) {
+      continue // Skip already existing models
+    }
+
+    const config = getModelConfig(tier)
+    const isThinking = modelId.includes('thinking')
+
+    modelsConfig.providers.nvidia.models.push({
+      id: modelId,
+      name: label,
+      contextWindow: config.contextWindow,
+      maxTokens: config.maxTokens,
+      reasoning: isThinking,
+      input: ['text'],
+      cost: {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0
+      }
+    })
+
+    addedCount++
+  }
+
+  // Only write if we added something
+  if (addedCount > 0) {
+    // Backup
+    const backupPath = `${MODELS_JSON}.backup-${Date.now()}`
+    copyFileSync(MODELS_JSON, backupPath)
+
+    // Write updated config
+    writeFileSync(MODELS_JSON, JSON.stringify(modelsConfig, null, 2))
+
+    return {
+      added: addedCount,
+      total: modelsConfig.providers.nvidia.models.length,
+      wasPatched: true,
+      backup: backupPath
+    }
+  }
+
+  return {
+    added: 0,
+    total: modelsConfig.providers.nvidia.models.length,
+    wasPatched: false
+  }
+}

package/patch-openclaw.js

@@ -0,0 +1,172 @@
+#!/usr/bin/env node
+/**
+ * @file patch-openclaw.js
+ * @description Patch OpenClaw to allow all NVIDIA models from free-coding-models
+ *
+ * This script adds ALL models from sources.js to OpenClaw's allowlist
+ * so any NVIDIA model can be used without "not allowed" errors.
+ */
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from 'fs'
+import { homedir } from 'os'
+import { join } from 'path'
+import { nvidiaNim } from './sources.js'
+
+const MODELS_JSON = join(homedir(), '.openclaw', 'agents', 'main', 'agent', 'models.json')
+const OPENCLAW_JSON = join(homedir(), '.openclaw', 'openclaw.json')
+
+console.log('🦞 Patching OpenClaw for full NVIDIA model support...\n')
+
+// ─── Helper functions ───────────────────────────────────────────────────────────
+function getModelConfig(tier) {
+  // S+/S tier: largest context
+  if (tier === 'S+' || tier === 'S') {
+    return { contextWindow: 128000, maxTokens: 8192 }
+  }
+  // A+ tier
+  if (tier === 'A+') {
+    return { contextWindow: 131072, maxTokens: 4096 }
+  }
+  // A/A- tier
+  if (tier === 'A' || tier === 'A-') {
+    return { contextWindow: 131072, maxTokens: 4096 }
+  }
+  // B+/B/C tier: smaller context
+  return { contextWindow: 32768, maxTokens: 2048 }
+}
+
+// ─── Patch models.json ──────────────────────────────────────────────────────────
+console.log('📄 Patching models.json...')
+
+let modelsConfig
+if (existsSync(MODELS_JSON)) {
+  try {
+    modelsConfig = JSON.parse(readFileSync(MODELS_JSON, 'utf8'))
+  } catch (err) {
+    console.error('  ✖ Failed to parse models.json:', err.message)
+    process.exit(1)
+  }
+} else {
+  console.error('  ✖ models.json not found at:', MODELS_JSON)
+  process.exit(1)
+}
+
+// Backup
+const backupPath = `${MODELS_JSON}.backup-${Date.now()}`
+writeFileSync(backupPath, readFileSync(MODELS_JSON))
+console.log(`  💾 Backup: ${backupPath}`)
+
+// Ensure nvidia provider exists
+if (!modelsConfig.providers) modelsConfig.providers = {}
+if (!modelsConfig.providers.nvidia) {
+  modelsConfig.providers.nvidia = {
+    baseUrl: 'https://integrate.api.nvidia.com/v1',
+    api: 'openai-completions',
+    models: []
+  }
+}
+
+// Get existing model IDs
+const existingModelIds = new Set(modelsConfig.providers.nvidia.models.map(m => m.id))
+
+// Add all models from sources.js
+let addedCount = 0
+for (const [modelId, label, tier] of nvidiaNim) {
+  if (existingModelIds.has(modelId)) {
+    continue // Skip already existing models
+  }
+
+  const config = getModelConfig(tier)
+  const isThinking = modelId.includes('thinking')
+
+  modelsConfig.providers.nvidia.models.push({
+    id: modelId,
+    name: label,
+    contextWindow: config.contextWindow,
+    maxTokens: config.maxTokens,
+    reasoning: isThinking,
+    input: ['text'],
+    cost: {
+      input: 0,
+      output: 0,
+      cacheRead: 0,
+      cacheWrite: 0
+    }
+  })
+
+  addedCount++
+}
+
+// Write back
+writeFileSync(MODELS_JSON, JSON.stringify(modelsConfig, null, 2))
+console.log(`  ✅ Added ${addedCount} models to models.json`)
+console.log(`  📊 Total NVIDIA models: ${modelsConfig.providers.nvidia.models.length}`)
+
+// ─── Patch openclaw.json ────────────────────────────────────────────────────────
+console.log('\n📄 Patching openclaw.json...')
+
+let openclawConfig
+if (existsSync(OPENCLAW_JSON)) {
+  try {
+    openclawConfig = JSON.parse(readFileSync(OPENCLAW_JSON, 'utf8'))
+  } catch (err) {
+    console.error('  ✖ Failed to parse openclaw.json:', err.message)
+    process.exit(1)
+  }
+} else {
+  console.error('  ✖ openclaw.json not found at:', OPENCLAW_JSON)
+  process.exit(1)
+}
+
+// Backup
+const openclawBackupPath = `${OPENCLAW_JSON}.backup-${Date.now()}`
+writeFileSync(openclawBackupPath, readFileSync(OPENCLAW_JSON))
+console.log(`  💾 Backup: ${openclawBackupPath}`)
+
+// Ensure models.providers.nvidia exists
+if (!openclawConfig.models) openclawConfig.models = {}
+if (!openclawConfig.models.providers) openclawConfig.models.providers = {}
+if (!openclawConfig.models.providers.nvidia) {
+  openclawConfig.models.providers.nvidia = {
+    baseUrl: 'https://integrate.api.nvidia.com/v1',
+    api: 'openai-completions',
+    models: []
+  }
+}
+
+// Get existing model IDs in openclaw.json
+const existingOpenClawModelIds = new Set(
+  (openclawConfig.models.providers.nvidia.models || []).map(m => m.id)
+)
+
+// Add all models (simplified config for openclaw.json)
+let addedOpenClawCount = 0
+for (const [modelId, label, tier] of nvidiaNim) {
+  if (existingOpenClawModelIds.has(modelId)) {
+    continue
+  }
+
+  const config = getModelConfig(tier)
+
+  openclawConfig.models.providers.nvidia.models.push({
+    id: modelId,
+    name: label,
+    contextWindow: config.contextWindow,
+    maxTokens: config.maxTokens
+  })
+
+  addedOpenClawCount++
+}
+
+// Write back
+writeFileSync(OPENCLAW_JSON, JSON.stringify(openclawConfig, null, 2))
+console.log(`  ✅ Added ${addedOpenClawCount} models to openclaw.json`)
+console.log(`  📊 Total NVIDIA models: ${openclawConfig.models.providers.nvidia.models.length}`)
+
+// ─── Summary ────────────────────────────────────────────────────────────────────
+console.log('\n✨ Patch complete!')
+console.log('\n💡 Next steps:')
+console.log('   1. Restart OpenClaw gateway: systemctl --user restart openclaw-gateway')
+console.log('   2. Test with: free-coding-models --openclaw')
+console.log('   3. Select any model - no more "not allowed" errors!')
+console.log()