free-coding-models 0.3.1 → 0.3.2

package/CHANGELOG.md

@@ -2,6 +2,12 @@
 
 ---
 
+## 0.3.2
+
+### Fixed
+- **Claude Code model-family routing now mirrors `free-claude-code`**: The proxy remaps Claude's internal model ids like `claude-3-5-sonnet-*`, `claude-3-haiku-*`, `claude-3-opus-*`, `sonnet`, `haiku`, and `default` back to the selected FCM proxy model instead of rejecting them as missing.
+- **Claude Code helper/background requests stay on the selected model**: Launches now pin the Anthropic helper model env vars and encode the selected proxy model inside `ANTHROPIC_AUTH_TOKEN`, so Claude Code has a stable fallback even when it emits internal aliases.
+
 ## 0.3.1
 
 ### Added

package/README.md

@@ -182,13 +182,12 @@ bunx free-coding-models YOUR_API_KEY
 
 ### 🆕 What's New
 
-**Version 0.3.1 tightens the proxy/tooling path and ships the missing diagnostics:**
+**Version 0.3.2 hardens the Claude Code proxy path to match the routing strategy that works in `free-claude-code`:**
 
-- **Claude Code proxy launches are cleaner** — FCM now launches Claude Code with an Anthropic-only proxy contract (`ANTHROPIC_BASE_URL` + `ANTHROPIC_AUTH_TOKEN`) instead of mixing auth modes.
-- **Codex proxy launches now use the right API path** — Codex is forced into an explicit custom provider config and the proxy now implements `POST /v1/responses`.
-- **Gemini proxy launches fail fast when unsupported** — Older Gemini CLI builds and invalid local config are detected up front, with a clear message instead of a misleading broken launch.
-- **Proxy auto-sync follows the current tool** — The FCM Proxy V2 overlay no longer relies on a separate active-tool picker, and `Y` now lists only stable persisted-config install targets.
-- **Beta messaging is explicit** — The README and runtime launcher diagnostics now call out that proxy-backed external tool support is still stabilizing.
+- **Claude Code family-model routing is now proxy-side** — FCM remaps Claude's internal family ids such as `claude-3-5-sonnet-*`, `claude-3-haiku-*`, `claude-3-opus-*`, `sonnet`, `haiku`, and `default` back to the selected FCM proxy model.
+- **Claude Code helper model slots are pinned** — FCM now exports the selected model into `ANTHROPIC_MODEL`, `ANTHROPIC_DEFAULT_OPUS_MODEL`, `ANTHROPIC_DEFAULT_SONNET_MODEL`, `ANTHROPIC_DEFAULT_HAIKU_MODEL`, and `CLAUDE_CODE_SUBAGENT_MODEL` so background/helper requests stop drifting.
+- **Claude proxy auth now carries the selected model hint** — The launcher encodes the chosen proxy model into `ANTHROPIC_AUTH_TOKEN`, giving the proxy a reliable fallback even when Claude Code ignores the visible `/model` selection.
+- **Proxy support remains beta** — External-tool proxy support is still stabilizing, but Claude Code should now behave much closer to the working `free-claude-code` setup.
 
 ---
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.3.1",
+  "version": "0.3.2",
   "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/proxy-server.js

@@ -1,7 +1,7 @@
 /**
  * @file lib/proxy-server.js
  * @description Multi-account rotation proxy server with SSE streaming,
- * token stats tracking, and persistent request logging.
+ * token stats tracking, Anthropic/OpenAI translation, and persistent request logging.
  *
  * Design:
  *   - Binds to 127.0.0.1 only (never 0.0.0.0)
@@ -10,6 +10,8 @@
  *   - x-ratelimit-* headers are stripped from all responses forwarded to clients
  *   - Retry loop: first attempt uses sticky session fingerprint; subsequent
  *     retries use fresh P2C to avoid hitting the same failed account
+ *   - Claude-family aliases are resolved inside the proxy so Claude Code can
+ *     keep emitting `claude-*` / `sonnet` / `haiku` style model ids safely
  *
  * @exports ProxyServer
  */
@@ -106,6 +108,49 @@ function sendJson(res, statusCode, body) {
   res.end(json)
 }
 
+function normalizeRequestedModel(modelId) {
+  if (typeof modelId !== 'string') return null
+  const trimmed = modelId.trim()
+  if (!trimmed) return null
+  return trimmed.replace(/^fcm-proxy\//, '')
+}
+
+function classifyClaudeVirtualModel(modelId) {
+  const normalized = normalizeRequestedModel(modelId)
+  if (!normalized) return null
+
+  const lower = normalized.toLowerCase()
+
+  // 📖 Mirror free-claude-code's family routing approach: classify by Claude
+  // 📖 family keywords, not only exact ids. Claude Code regularly emits both
+  // 📖 short aliases (`sonnet`) and full versioned ids (`claude-3-5-sonnet-*`).
+  if (lower === 'default') return 'default'
+  if (/^opus(?:plan)?(?:\[1m\])?$/.test(lower)) return 'opus'
+  if (/^sonnet(?:\[1m\])?$/.test(lower)) return 'sonnet'
+  if (lower === 'haiku') return 'haiku'
+  if (!lower.startsWith('claude-')) return null
+  if (lower.includes('opus')) return 'opus'
+  if (lower.includes('haiku')) return 'haiku'
+  if (lower.includes('sonnet')) return 'sonnet'
+  return null
+}
+
+function parseProxyAuthorizationHeader(authorization, expectedToken) {
+  if (!expectedToken) return { authorized: true, modelHint: null }
+  if (typeof authorization !== 'string' || !authorization.startsWith('Bearer ')) {
+    return { authorized: false, modelHint: null }
+  }
+
+  const rawToken = authorization.slice('Bearer '.length).trim()
+  if (rawToken === expectedToken) return { authorized: true, modelHint: null }
+  if (!rawToken.startsWith(`${expectedToken}:`)) return { authorized: false, modelHint: null }
+
+  const modelHint = normalizeRequestedModel(rawToken.slice(expectedToken.length + 1))
+  return modelHint
+    ? { authorized: true, modelHint }
+    : { authorized: false, modelHint: null }
+}
+
 // ─── ProxyServer ─────────────────────────────────────────────────────────────
 
 export class ProxyServer {
@@ -194,11 +239,32 @@ export class ProxyServer {
     }
   }
 
+  _getAuthContext(req) {
+    return parseProxyAuthorizationHeader(req.headers.authorization, this._proxyApiKey)
+  }
+
   _isAuthorized(req) {
-    if (!this._proxyApiKey) return true
-    const authorization = req.headers.authorization
-    if (typeof authorization !== 'string') return false
-    return authorization === `Bearer ${this._proxyApiKey}`
+    return this._getAuthContext(req).authorized
+  }
+
+  _resolveAnthropicRequestedModel(modelId, authModelHint = null) {
+    const requestedModel = normalizeRequestedModel(modelId)
+    if (requestedModel && this._accountManager.hasAccountsForModel(requestedModel)) {
+      return requestedModel
+    }
+
+    // 📖 Claude Code still emits internal aliases / tier model ids for some
+    // 📖 background and helper paths. When the launcher encoded the selected
+    // 📖 proxy slug into the auth token, remap those virtual Claude ids here.
+    // 📖 This intentionally matches Claude families by substring so ids like
+    // 📖 `claude-3-5-sonnet-20241022` behave the same as `sonnet`.
+    if (authModelHint && this._accountManager.hasAccountsForModel(authModelHint)) {
+      if (!requestedModel || classifyClaudeVirtualModel(requestedModel)) {
+        return authModelHint
+      }
+    }
+
+    return requestedModel
   }
 
   // ── Request routing ────────────────────────────────────────────────────────
@@ -209,7 +275,8 @@ export class ProxyServer {
       return this._handleHealth(res)
     }
 
-    if (!this._isAuthorized(req)) {
+    const authContext = this._getAuthContext(req)
+    if (!authContext.authorized) {
       return sendJson(res, 401, { error: 'Unauthorized' })
     }
 
@@ -227,7 +294,7 @@ export class ProxyServer {
       })
     } else if (req.method === 'POST' && req.url === '/v1/messages') {
       // 📖 Anthropic Messages API translation — enables Claude Code compatibility
-      this._handleAnthropicMessages(req, res).catch(err => {
+      this._handleAnthropicMessages(req, res, authContext).catch(err => {
         console.error('[proxy] Internal error:', err)
         const status = err.statusCode === 413 ? 413 : 500
         const msg = err.statusCode === 413 ? 'Request body too large' : 'Internal server error'
@@ -733,7 +800,7 @@ export class ProxyServer {
    *
    * 📖 This makes Claude Code work natively through the FCM proxy.
    */
-  async _handleAnthropicMessages(clientReq, clientRes) {
+  async _handleAnthropicMessages(clientReq, clientRes, authContext = { modelHint: null }) {
     const rawBody = await readBody(clientReq)
     let anthropicBody
     try {
@@ -744,6 +811,8 @@ export class ProxyServer {
 
     // 📖 Translate Anthropic → OpenAI
     const openaiBody = translateAnthropicToOpenAI(anthropicBody)
+    const resolvedModel = this._resolveAnthropicRequestedModel(openaiBody.model, authContext.modelHint)
+    if (resolvedModel) openaiBody.model = resolvedModel
     const isStreaming = openaiBody.stream === true
 
     if (isStreaming) {

package/src/tool-launchers.js

@@ -25,13 +25,16 @@
  *
  * @functions
  *   → `resolveLauncherModelId` — choose the provider-specific id or proxy slug for a launch
+ *   → `applyClaudeCodeModelOverrides` — force Claude Code auxiliary model slots onto the chosen proxy model
+ *   → `buildClaudeProxyAuthToken` — encode the proxy token + selected model hint for Claude-only fallback routing
  *   → `buildCodexProxyArgs` — force Codex into a proxy-backed custom provider config
  *   → `inspectGeminiCliSupport` — detect whether the installed Gemini CLI can use proxy mode safely
  *   → `writeGooseConfig` — install provider + set GOOSE_PROVIDER/GOOSE_MODEL in config.yaml
  *   → `writeCrushConfig` — write provider + models.large/small to crush.json
  *   → `startExternalTool` — configure and launch the selected external tool mode
  *
- * @exports resolveLauncherModelId, buildCodexProxyArgs, inspectGeminiCliSupport, startExternalTool
+ * @exports resolveLauncherModelId, applyClaudeCodeModelOverrides, buildClaudeProxyAuthToken
+ * @exports buildCodexProxyArgs, inspectGeminiCliSupport, startExternalTool
  *
  * @see src/tool-metadata.js
  * @see src/provider-metadata.js
@@ -65,6 +68,11 @@ const ANTHROPIC_ENV_KEYS = [
   'ANTHROPIC_AUTH_TOKEN',
   'ANTHROPIC_BASE_URL',
   'ANTHROPIC_MODEL',
+  'ANTHROPIC_DEFAULT_OPUS_MODEL',
+  'ANTHROPIC_DEFAULT_SONNET_MODEL',
+  'ANTHROPIC_DEFAULT_HAIKU_MODEL',
+  'ANTHROPIC_SMALL_FAST_MODEL',
+  'CLAUDE_CODE_SUBAGENT_MODEL',
 ]
 const GEMINI_ENV_KEYS = [
   'GEMINI_API_KEY',
@@ -146,6 +154,28 @@ export function resolveLauncherModelId(model, useProxy = false) {
   return model?.modelId ?? ''
 }
 
+export function applyClaudeCodeModelOverrides(env, modelId) {
+  const resolvedModelId = typeof modelId === 'string' ? modelId.trim() : ''
+  if (!resolvedModelId) return env
+
+  // 📖 Claude Code still uses auxiliary model slots (opus/sonnet/haiku/subagents)
+  // 📖 even when a custom primary model is selected. Pin them all to the same slug.
+  env.ANTHROPIC_MODEL = resolvedModelId
+  env.ANTHROPIC_DEFAULT_OPUS_MODEL = resolvedModelId
+  env.ANTHROPIC_DEFAULT_SONNET_MODEL = resolvedModelId
+  env.ANTHROPIC_DEFAULT_HAIKU_MODEL = resolvedModelId
+  env.ANTHROPIC_SMALL_FAST_MODEL = resolvedModelId
+  env.CLAUDE_CODE_SUBAGENT_MODEL = resolvedModelId
+  return env
+}
+
+export function buildClaudeProxyAuthToken(proxyToken, modelId) {
+  const resolvedProxyToken = typeof proxyToken === 'string' ? proxyToken.trim() : ''
+  const resolvedModelId = typeof modelId === 'string' ? modelId.trim() : ''
+  if (!resolvedProxyToken) return ''
+  return resolvedModelId ? `${resolvedProxyToken}:${resolvedModelId}` : resolvedProxyToken
+}
+
 export function buildToolEnv(mode, model, config, options = {}) {
   const {
     sanitize = false,
@@ -610,8 +640,8 @@ export async function startExternalTool(mode, model, config) {
     const proxyBase = `http://127.0.0.1:${started.port}`
     const launchModelId = resolveLauncherModelId(model, true)
     proxyEnv.ANTHROPIC_BASE_URL = proxyBase
-    proxyEnv.ANTHROPIC_AUTH_TOKEN = started.proxyToken
-    proxyEnv.ANTHROPIC_MODEL = launchModelId
+    proxyEnv.ANTHROPIC_AUTH_TOKEN = buildClaudeProxyAuthToken(started.proxyToken, launchModelId)
+    applyClaudeCodeModelOverrides(proxyEnv, launchModelId)
     console.log(chalk.dim(`  📖 Claude Code routed through FCM proxy on :${started.port} (Anthropic translation enabled)`))
     return spawnCommand('claude', ['--model', launchModelId], proxyEnv)
   }