free-coding-models 0.5.77 → 0.5.79

package/changelog/v0.5.78.md

@@ -0,0 +1,17 @@
+# Changelog v0.5.78 - 2026-08-23
+
+### Fixed
+- **Router forwards `prompt_cache_key` to NVIDIA -> HTTP 400 (fixes #160).** Clients using OpenAI JS SDK (pi agent) set `prompt_cache_key` to session UUID for prompt caching; NVIDIA rejects it with `Unsupported parameter(s): prompt_cache_key`. Added `prompt_cache_key` to `STRIP_PARAMS` in `src/core/schema-normalizer.js` and added `nvidia: normalizeNvidia` (strip + orphan tool drop) to `PROVIDER_NORMALIZERS` so `normalizeRequestBody(body, 'nvidia')` now strips the hint before forwarding. Verified with direct replay against `integrate.api.nvidia.com` and `pnpm test` 813/813. Thanks @pelvity.
+
+- **Config `pingInterval` not respected at startup (fixes #155).** TUI always started in speed mode (2s) ignoring `settings.pingInterval` and `--ping-interval`. Now `src/tui/tui-state.js` `createTuiState()` derives `initialInterval` from `config.settings.pingInterval` (already merged from CLI in `src/tui/app.js:283`) and maps to mode via `intervalToPingMode` (30000 -> slow, 10000 -> normal, 4000 -> forced, <=3000 -> speed). Sets `pingModeSource` to `config` vs `startup` and only sets `speedModeUntil` when initial mode is speed. Users with 30s interval no longer burn quota on startup burst. Thanks @BetterToAutomateTheWorld.
+
+- **jcode configuration option for CLI and web (fixes #145).** CLI Z cycle already had `jcode` but launch hung (stdin left in raw mode, REPL appeared frozen) and web had no jcode option at all.
+  - CLI hang: `src/tui/key-handler.js` `launchSelectedModel` now calls `stopUi({ resetRawMode: true })` (was `stopUi()` with raw mode still enabled) and `src/core/tool-launchers.js` `spawnCommand` defensively resets `stdin.setRawMode(false)` before handing TTY to child.
+  - Web: Added `jcode` to `INSTALL_TARGET_MODES` in `src/core/endpoint-installer.js` (now 15 targets, `jcode` after `pi` to match `TOOL_MODE_ORDER` order) with env-based installer (`~/.fcm-jcode-env`), mirrored in `web/src/utils/m3.js` `INSTALL_ENDPOINT_TOOL_MODES`, and fixed `web/src/hooks/useToolMode.js` cycle bug (`TOOL_MODE_ORDER` -> `INSTALL_ENDPOINT_TOOL_MODES`). Web `/api/tool-mode` now accepts `jcode` without 422 and dropdown/cycle shows it. Thanks @plahakps.
+
+### Changed
+- `src/core/schema-normalizer.js` JSDoc now exports `normalizeNvidia` and clarifies per-provider normalization.
+- `web/src/utils/m3.js` and `src/core/endpoint-installer.js` tool order now matches CLI's `TOOL_MODE_ORDER` (opencode -> pi -> jcode -> opencode-desktop ...).
+
+### Tests
+- 813/813 passing. Updated `test/test.js` endpoint install target expectation to include `jcode`.

package/changelog/v0.5.79.md

@@ -0,0 +1,12 @@
+# Changelog v0.5.79 - 2026-08-23
+
+### Fixed
+- **Fast-coding pool malformed tool_calls hang (fixes #124).** Some providers returned `finish_reason: tool_calls` without a `tool_calls` array, causing pi and other OpenAI clients to wait forever. Router now normalizes such responses to `finish_reason: stop` in `src/core/router-daemon.js` (`normalizeToolCallsResponse`) before forwarding, making the response spec-compliant even when upstream is quirky. Thanks @stgreenb.
+
+- **Docker mandatory update EACCES crash (fixes #109).** Inside Docker the app lives at `/app` and runs as non-root `fcm`, so `npm i -g` always hit EACCES on `/usr/local/lib/node_modules` and showed "Mandatory update failed" then exited. Added `isRunningInDocker()` in `src/core/updater.js` (checks `/.dockerenv` and `/app` prefix) to skip mandatory startup updates in containers; rebuild the image to update. Thanks @karneaud.
+
+### Changed
+- Closed older user feature requests with concise responses: #51 Nix module (PR welcome), #30 oh-my-opencode (wrapper externe, pas de duplication), #27 Claude Code integration (now via router `fcm`). Only vava's own issues (75, 21, 18) remain open.
+
+### Tests
+- 813/813 passing. Router now re-stringifies normalized JSON only when needed.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.5.77",
+  "version": "0.5.79",
   "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/src/core/endpoint-installer.js

@@ -53,8 +53,8 @@ import { ensureDir, readJson as sharedReadJson } from './shared-helpers.js'
 // 📖 zai and opencode-zen ARE OpenAI-compatible and CAN be installed into any tool.
 const DIRECT_INSTALL_UNSUPPORTED_PROVIDERS = new Set(['replicate'])
 // 📖 Install Endpoints only lists tools whose persisted config shape is actually supported here.
-// 📖 Launch-only tools stay out: the Web dashboard configures endpoints, it never starts CLIs.
-const INSTALL_TARGET_MODES = ['opencode', 'opencode-desktop', 'opencode-web', 'openclaw', 'crush', 'goose', 'pi', 'aider', 'qwen', 'openhands', 'amp', 'forgecode', 'fcm_router', 'zcode']
+// 📖 jcode is CLI-only and uses an env-file helper (same as openhands) — selectable in both CLI and Web.
+const INSTALL_TARGET_MODES = ['opencode', 'pi', 'jcode', 'opencode-desktop', 'opencode-web', 'openclaw', 'crush', 'goose', 'aider', 'qwen', 'openhands', 'amp', 'forgecode', 'fcm_router', 'zcode']
 
 function getDefaultPaths() {
   const home = homedir()
@@ -839,6 +839,8 @@ export function installProviderEndpoints(config, providerKey, toolMode, options
     installResult = installIntoAmp(providerKey, models, apiKey, paths)
   } else if (canonicalToolMode === 'qwen') {
     installResult = installIntoQwen(providerKey, models, apiKey, paths)
+  } else if (canonicalToolMode === 'jcode') {
+    installResult = installIntoEnvBasedTool(providerKey, models, apiKey, canonicalToolMode, paths)
   } else if (canonicalToolMode === 'openhands') {
     installResult = installIntoEnvBasedTool(providerKey, models, apiKey, canonicalToolMode, paths)
   } else if (canonicalToolMode === 'fcm_router') {

package/src/core/router-daemon.js

@@ -118,6 +118,32 @@ const __dirname = dirname(fileURLToPath(import.meta.url))
 const CLI_ENTRY_PATH = join(__dirname, '..', '..', 'bin', 'free-coding-models.js')
 const LOCAL_VERSION = JSON.parse(readFileSync(join(__dirname, '..', '..', 'package.json'), 'utf8')).version
 const MAX_BODY_BYTES = 10 * 1024 * 1024
+/**
+ * 📖 normalizeToolCallsResponse — fix malformed tool_calls from upstream.
+ * Some providers return finish_reason: "tool_calls" but message has no tool_calls array,
+ * which hangs OpenAI-compatible clients (pi agent waits for tool_calls that never arrives).
+ * Normalize to finish_reason: "stop" when tool_calls is missing/empty per OpenAI spec.
+ * This is defensive: it makes the router spec-compliant regardless of upstream quirks.
+ * @param {object} data - parsed JSON response object
+ * @returns {boolean} true if mutated
+ */
+function normalizeToolCallsResponse(data) {
+  if (!data || typeof data !== 'object' || !Array.isArray(data.choices)) return false
+  let mutated = false
+  for (const choice of data.choices) {
+    if (!choice || typeof choice !== 'object') continue
+    if (choice.finish_reason !== 'tool_calls') continue
+    const msg = choice.message
+    if (!msg || typeof msg !== 'object') continue
+    const tc = msg.tool_calls
+    if (!Array.isArray(tc) || tc.length === 0) {
+      choice.finish_reason = 'stop'
+      mutated = true
+    }
+  }
+  return mutated
+}
+
 const MAX_REQUEST_LOG = 200
 const MAX_SSE_CLIENTS = 10
 const MAX_CONCURRENT_REQUESTS = 50
@@ -2226,13 +2252,20 @@ class RouterRuntime {
           failover: attemptIndex > 0,
         })
         this.logger.info(`Routed to ${key} - ${latencyMs}ms`, { request_id: requestId, status: response.status })
+        // 📖 Fix #124: normalize malformed tool_calls (finish_reason tool_calls without tool_calls array)
+        let responseText = text
+        try {
+          if (normalizeToolCallsResponse(parsed.value)) {
+            responseText = JSON.stringify(parsed.value)
+          }
+        } catch {}
         if (!res.writableEnded) {
           res.writeHead(response.status, {
             ...headerEntries(response.headers),
             'x-fcm-router-model': key,
             'x-request-id': requestId,
           })
-          res.end(text)
+          res.end(responseText)
         }
         return { done: true }
       }

package/src/core/schema-normalizer.js

@@ -30,8 +30,9 @@
  *   → `clampTemperature` — clamps `temperature` to the provider's accepted range
  *   → `normalizeZai` — for `zai` (GLM) provider
  *   → `normalizeMistral` — for `mistral` and `codestral` providers
+ *   → `normalizeNvidia` — for `nvidia` provider (strips unsupported params like prompt_cache_key)
  *
- * @exports normalizeRequestBody, normalizeZai, normalizeMistral, PROVIDER_NORMALIZERS
+ * @exports normalizeRequestBody, normalizeZai, normalizeMistral, normalizeNvidia, PROVIDER_NORMALIZERS
  *
  * @see src/core/router-daemon.js — calls `normalizeRequestBody` before forwarding upstream
  */
@@ -48,6 +49,7 @@ const STRIP_PARAMS = [
   'echo',                 // not in OpenAI spec
   'user',                 // PII risk; not used by FCM
   'metadata',             // not always supported
+  'prompt_cache_key',     // OpenAI prompt-caching hint; NVIDIA rejects with 400
   'store',                // GLM rejects
 ]
 
@@ -146,6 +148,20 @@ export function normalizeMistral(body) {
   return result
 }
 
+/**
+ * 📖 `normalizeNvidia` — transforms a request body for the `nvidia` provider.
+ *
+ *   1. Strips parameters NVIDIA rejects with 400 (e.g. prompt_cache_key)
+ *   2. Removes orphan `tool` messages that lack a matching assistant tool_call
+ *   3. Strips `stream_options` when not streaming
+ */
+export function normalizeNvidia(body) {
+  if (!body || typeof body !== 'object') return body
+  let result = stripUnsupportedParams(body)
+  result = dropOrphanToolMessages(result)
+  return result
+}
+
 // 📖 Map of provider key → normalizer function. Providers that don't need
 // 📖 any tweak (most OpenAI-compat ones like Groq, Cerebras, etc.) are not
 // 📖 listed and pass through `normalizeRequestBody` unchanged.
@@ -153,6 +169,7 @@ export const PROVIDER_NORMALIZERS = {
   zai: normalizeZai,
   mistral: normalizeMistral,
   codestral: normalizeMistral,
+  nvidia: normalizeNvidia,
 }
 
 /**

package/src/core/tool-launchers.js

@@ -209,6 +209,12 @@ const JCODE_NATIVE_PROVIDERS = {
 }
 
 function spawnCommand(command, args, env) {
+  // 📖 Defensive: ensure stdin is back in cooked mode before handing the TTY to
+  // 📖 an interactive child (jcode REPL etc). The TUI leaves raw mode enabled;
+  // 📖 if the caller forgot to reset it the child will appear to hang.
+  try {
+    if (process.stdin.isTTY && process.stdin.isRaw) process.stdin.setRawMode(false)
+  } catch {}
   return new Promise((resolve, reject) => {
     const child = spawn(command, args, {
       stdio: 'inherit',

package/src/core/updater.js

@@ -110,6 +110,25 @@ export function isPackageDevMode() {
   return process.env.FCM_DEV === '1' || existsSync(join(PACKAGE_ROOT, '.git'))
 }
 
+/**
+ * 📖 isRunningInDocker: detect Docker/container environment where global npm writes fail.
+ * In Docker the app lives at /app (not /usr/local/lib/node_modules) and runs as non-root `fcm`.
+ * Mandatory updates would always EACCES, so we skip them gracefully.
+ * @returns {boolean}
+ */
+export function isRunningInDocker() {
+  // 📖 Standard Docker marker file, plus explicit env override for testing
+  if (process.env.FCM_DOCKER === '1' || process.env.DOCKER_CONTAINER === '1') return true
+  try {
+    if (existsSync('/.dockerenv')) return true
+  } catch {}
+  // 📖 Fallback: check if package is at /app (Docker COPY) vs global prefix
+  try {
+    if (String(PACKAGE_ROOT) === '/app' || String(PACKAGE_ROOT).startsWith('/app/')) return true
+  } catch {}
+  return false
+}
+
 /**
  * 📖 getUpdateInstallFailureCount: sanitized persistent failure counter.
  * @param {object} config
@@ -265,6 +284,11 @@ export async function enforceMandatoryStartupUpdate(config, options = {}) {
   }
 
   if (devMode) return base
+  if (isRunningInDocker()) {
+    // 📖 In Docker, global npm install as non-root always EACCES. Skip mandatory update
+    // 📖 and let the container run with the baked-in version. User can rebuild image for updates.
+    return base
+  }
 
   const { latestVersion, error } = await checkForUpdateDetailed()
   base.checked = true

package/src/tui/key-handler.js

@@ -278,9 +278,7 @@ export function createKeyHandler(ctx) {
     userSelected = { modelId: selected.modelId, label: selected.label, tier: selected.tier, providerKey: selected.providerKey, ctx: selected.ctx }
 
     if (!uiAlreadyStopped) {
-      readline.emitKeypressEvents(process.stdin)
-      if (process.stdin.isTTY) process.stdin.setRawMode(true)
-      stopUi()
+      stopUi({ resetRawMode: true })
     }
 
     // 📖 If router is enabled, push [selected, ...favorites] to daemon as the active set

package/src/tui/tui-state.js

@@ -89,6 +89,13 @@ export function createTuiState({
 
   // 📖 Dynamic normal interval from config (default 10s)
   const normalInterval = config.settings?.pingInterval ?? PING_MODE_INTERVALS.normal
+  // 📖 Respect config.settings.pingInterval at startup (issue #155).
+  // 📖 CLI override is already merged into config.settings.pingInterval in app.js.
+  const configuredInterval = config.settings?.pingInterval
+  const hasConfiguredInterval =
+    typeof configuredInterval === 'number' && Number.isFinite(configuredInterval) && configuredInterval > 0
+  const initialInterval = hasConfiguredInterval ? configuredInterval : PING_MODE_INTERVALS.speed
+  const initialMode = intervalToPingMode(initialInterval)
 
   return {
     // 📖 Core data: model results (mutated in-place by ping loop)
@@ -107,14 +114,14 @@ export function createTuiState({
     sortDirection: (config.settings?.sortAsc ?? true) ? 'asc' : 'desc',
 
     // 📖 Ping cadence — drives the interval between background ping cycles
-    pingInterval: PING_MODE_INTERVALS.speed,
-    pingMode: 'speed',
-    pingModeSource: 'startup',
+    pingInterval: initialInterval,
+    pingMode: initialMode,
+    pingModeSource: hasConfiguredInterval ? 'config' : 'startup',
     pingModeIntervals: {
       ...PING_MODE_INTERVALS,
       normal: normalInterval,
     },
-    speedModeUntil: now + SPEED_MODE_DURATION_MS,
+    speedModeUntil: initialMode === 'speed' ? now + SPEED_MODE_DURATION_MS : null,
     lastPingTime: now,
     lastUserActivityAt: now,
     resumeSpeedOnActivity: false,