free-coding-models 0.1.67 → 0.1.69

package/lib/config.js

@@ -28,7 +28,8 @@
  *       "siliconflow":"sk-xxx",
  *       "together":   "together-xxx",
  *       "cloudflare": "cf-xxx",
- *       "perplexity": "pplx-xxx"
+ *       "perplexity": "pplx-xxx",
+ *       "zai":        "zai-xxx"
  *     },
  *     "providers": {
  *       "nvidia":     { "enabled": true },
@@ -47,18 +48,35 @@
  *       "siliconflow":{ "enabled": true },
  *       "together":   { "enabled": true },
  *       "cloudflare": { "enabled": true },
- *       "perplexity": { "enabled": true }
+ *       "perplexity": { "enabled": true },
+ *       "zai":        { "enabled": true }
  *     },
  *     "favorites": [
  *       "nvidia/deepseek-ai/deepseek-v3.2"
- *     },
+ *     ],
  *     "telemetry": {
  *       "enabled": true,
  *       "consentVersion": 1,
  *       "anonymousId": "anon_550e8400-e29b-41d4-a716-446655440000"
+ *     },
+ *     "activeProfile": "work",
+ *     "profiles": {
+ *       "work":     { "apiKeys": {...}, "providers": {...}, "favorites": [...], "settings": {...} },
+ *       "personal": { "apiKeys": {...}, "providers": {...}, "favorites": [...], "settings": {...} },
+ *       "fast":     { "apiKeys": {...}, "providers": {...}, "favorites": [...], "settings": {...} }
  *     }
  *   }
  *
+ * 📖 Profiles store a snapshot of the user's configuration. Each profile contains:
+ *   - apiKeys: API keys per provider (can differ between work/personal setups)
+ *   - providers: enabled/disabled state per provider
+ *   - favorites: list of pinned favorite models
+ *   - settings: extra TUI preferences (tierFilter, sortColumn, sortAsc, pingInterval)
+ *
+ * 📖 When a profile is loaded via --profile <name> or Shift+P, the main config's
+ *    apiKeys/providers/favorites are replaced with the profile's values. The profile
+ *    data itself stays in the profiles section — it's a named snapshot, not a fork.
+ *
  * 📖 Migration: On first run, if the old plain-text ~/.free-coding-models exists
  *    and the new JSON file does not, the old key is auto-migrated as the nvidia key.
  *    The old file is left in place (not deleted) for safety.
@@ -68,8 +86,17 @@
  *   → saveConfig(config) — Write config to ~/.free-coding-models.json with 0o600 permissions
  *   → getApiKey(config, providerKey) — Get effective API key (env var override > config > null)
  *   → isProviderEnabled(config, providerKey) — Check if provider is enabled (defaults true)
+ *   → saveAsProfile(config, name) — Snapshot current apiKeys/providers/favorites/settings into a named profile
+ *   → loadProfile(config, name) — Apply a named profile's values onto the live config
+ *   → listProfiles(config) — Return array of profile names
+ *   → deleteProfile(config, name) — Remove a named profile
+ *   → getActiveProfileName(config) — Get the currently active profile name (or null)
+ *   → setActiveProfile(config, name) — Set which profile is active (null to clear)
+ *   → _emptyProfileSettings() — Default TUI settings for a profile
  *
- * @exports loadConfig, saveConfig, getApiKey
+ * @exports loadConfig, saveConfig, getApiKey, isProviderEnabled
+ * @exports saveAsProfile, loadProfile, listProfiles, deleteProfile
+ * @exports getActiveProfileName, setActiveProfile
  * @exports CONFIG_PATH — path to the JSON config file
  *
  * @see bin/free-coding-models.js — main CLI that uses these functions
@@ -106,6 +133,8 @@ const ENV_VARS = {
   together:   'TOGETHER_API_KEY',
   cloudflare: ['CLOUDFLARE_API_TOKEN', 'CLOUDFLARE_API_KEY'],
   perplexity: ['PERPLEXITY_API_KEY', 'PPLX_API_KEY'],
+  zai:        'ZAI_API_KEY',
+  iflow:      'IFLOW_API_KEY',
 }
 
 /**
@@ -137,6 +166,9 @@ export function loadConfig() {
       if (typeof parsed.telemetry.enabled !== 'boolean') parsed.telemetry.enabled = null
       if (typeof parsed.telemetry.consentVersion !== 'number') parsed.telemetry.consentVersion = 0
       if (typeof parsed.telemetry.anonymousId !== 'string' || !parsed.telemetry.anonymousId.trim()) parsed.telemetry.anonymousId = null
+      // 📖 Ensure profiles section exists (added in profile system)
+      if (!parsed.profiles || typeof parsed.profiles !== 'object') parsed.profiles = {}
+      if (parsed.activeProfile && typeof parsed.activeProfile !== 'string') parsed.activeProfile = null
       return parsed
     } catch {
       // 📖 Corrupted JSON — return empty config (user will re-enter keys)
@@ -222,6 +254,129 @@ export function isProviderEnabled(config, providerKey) {
   return providerConfig.enabled !== false
 }
 
+// ─── Config Profiles ──────────────────────────────────────────────────────────
+
+/**
+ * 📖 _emptyProfileSettings: Default TUI settings stored in a profile.
+ *
+ * 📖 These settings are saved/restored when switching profiles so each profile
+ *    can have different sort, filter, and ping preferences.
+ *
+ * @returns {{ tierFilter: string|null, sortColumn: string, sortAsc: boolean, pingInterval: number }}
+ */
+export function _emptyProfileSettings() {
+  return {
+    tierFilter: null,     // 📖 null = show all tiers, or 'S'|'A'|'B'|'C'|'D'
+    sortColumn: 'avg',    // 📖 default sort column
+    sortAsc: true,        // 📖 true = ascending (fastest first for latency)
+    pingInterval: 8000,   // 📖 default ms between pings
+  }
+}
+
+/**
+ * 📖 saveAsProfile: Snapshot the current config state into a named profile.
+ *
+ * 📖 Takes the current apiKeys, providers, favorites, plus explicit TUI settings
+ *    and stores them under config.profiles[name]. Does NOT change activeProfile —
+ *    call setActiveProfile() separately if you want to switch to this profile.
+ *
+ * 📖 If a profile with the same name exists, it's overwritten.
+ *
+ * @param {object} config — Live config object (will be mutated)
+ * @param {string} name — Profile name (e.g. 'work', 'personal', 'fast')
+ * @param {object} [settings] — TUI settings to save (tierFilter, sortColumn, etc.)
+ * @returns {object} The config object (for chaining)
+ */
+export function saveAsProfile(config, name, settings = null) {
+  if (!config.profiles || typeof config.profiles !== 'object') config.profiles = {}
+  config.profiles[name] = {
+    apiKeys: JSON.parse(JSON.stringify(config.apiKeys || {})),
+    providers: JSON.parse(JSON.stringify(config.providers || {})),
+    favorites: [...(config.favorites || [])],
+    settings: settings ? { ..._emptyProfileSettings(), ...settings } : _emptyProfileSettings(),
+  }
+  return config
+}
+
+/**
+ * 📖 loadProfile: Apply a named profile's values onto the live config.
+ *
+ * 📖 Replaces config.apiKeys, config.providers, config.favorites with the
+ *    profile's stored values. Also sets config.activeProfile to the loaded name.
+ *
+ * 📖 Returns the profile's TUI settings so the caller (main CLI) can apply them
+ *    to the live state object (sortColumn, tierFilter, etc.).
+ *
+ * 📖 If the profile doesn't exist, returns null (caller should show an error).
+ *
+ * @param {object} config — Live config object (will be mutated)
+ * @param {string} name — Profile name to load
+ * @returns {{ tierFilter: string|null, sortColumn: string, sortAsc: boolean, pingInterval: number }|null}
+ *          The profile's TUI settings, or null if profile not found
+ */
+export function loadProfile(config, name) {
+  const profile = config?.profiles?.[name]
+  if (!profile) return null
+
+  // 📖 Deep-copy the profile data into the live config (don't share references)
+  config.apiKeys = JSON.parse(JSON.stringify(profile.apiKeys || {}))
+  config.providers = JSON.parse(JSON.stringify(profile.providers || {}))
+  config.favorites = [...(profile.favorites || [])]
+  config.activeProfile = name
+
+  return profile.settings ? { ..._emptyProfileSettings(), ...profile.settings } : _emptyProfileSettings()
+}
+
+/**
+ * 📖 listProfiles: Get all saved profile names.
+ *
+ * @param {object} config
+ * @returns {string[]} Array of profile names, sorted alphabetically
+ */
+export function listProfiles(config) {
+  if (!config?.profiles || typeof config.profiles !== 'object') return []
+  return Object.keys(config.profiles).sort()
+}
+
+/**
+ * 📖 deleteProfile: Remove a named profile from the config.
+ *
+ * 📖 If the deleted profile is the active one, clears activeProfile.
+ *
+ * @param {object} config — Live config object (will be mutated)
+ * @param {string} name — Profile name to delete
+ * @returns {boolean} True if the profile existed and was deleted
+ */
+export function deleteProfile(config, name) {
+  if (!config?.profiles?.[name]) return false
+  delete config.profiles[name]
+  if (config.activeProfile === name) config.activeProfile = null
+  return true
+}
+
+/**
+ * 📖 getActiveProfileName: Get the currently active profile name.
+ *
+ * @param {object} config
+ * @returns {string|null} Profile name, or null if no profile is active
+ */
+export function getActiveProfileName(config) {
+  return config?.activeProfile || null
+}
+
+/**
+ * 📖 setActiveProfile: Set which profile is active (or null to clear).
+ *
+ * 📖 This just stores the name — it does NOT load the profile's data.
+ *    Call loadProfile() first to actually apply the profile's values.
+ *
+ * @param {object} config — Live config object (will be mutated)
+ * @param {string|null} name — Profile name, or null to clear
+ */
+export function setActiveProfile(config, name) {
+  config.activeProfile = name || null
+}
+
 // 📖 Internal helper: create a blank config with the right shape
 function _emptyConfig() {
   return {
@@ -235,5 +390,9 @@ function _emptyConfig() {
       consentVersion: 0,
       anonymousId: null,
     },
+    // 📖 Active profile name — null means no profile is loaded (using raw config).
+    activeProfile: null,
+    // 📖 Named profiles: each is a snapshot of apiKeys + providers + favorites + settings.
+    profiles: {},
   }
 }

package/lib/utils.js

@@ -39,7 +39,8 @@
  *
  * @exports getAvg, getVerdict, getUptime, getP95, getJitter, getStabilityScore
  * @exports sortResults, filterByTier, findBestModel, parseArgs
- * @exports TIER_ORDER, VERDICT_ORDER, TIER_LETTER_MAP
+ * @exports scoreModelForTask, getTopRecommendations
+ * @exports TIER_ORDER, VERDICT_ORDER, TIER_LETTER_MAP, TASK_TYPES, PRIORITY_TYPES, CONTEXT_BUDGETS
  *
  * @see bin/free-coding-models.js — main CLI that imports these utils
  * @see sources.js — model definitions consumed by these functions
@@ -385,17 +386,27 @@ export function parseArgs(argv) {
   let apiKey = null
   const flags = []
 
-  // Determine which arg index is consumed by --tier so we skip it
+  // 📖 Determine which arg indices are consumed by --tier and --profile so we skip them
   const tierIdx = args.findIndex(a => a.toLowerCase() === '--tier')
   const tierValueIdx = (tierIdx !== -1 && args[tierIdx + 1] && !args[tierIdx + 1].startsWith('--'))
     ? tierIdx + 1
     : -1
 
+  const profileIdx = args.findIndex(a => a.toLowerCase() === '--profile')
+  const profileValueIdx = (profileIdx !== -1 && args[profileIdx + 1] && !args[profileIdx + 1].startsWith('--'))
+    ? profileIdx + 1
+    : -1
+
+  // 📖 Set of arg indices that are values for flags (not API keys)
+  const skipIndices = new Set()
+  if (tierValueIdx !== -1) skipIndices.add(tierValueIdx)
+  if (profileValueIdx !== -1) skipIndices.add(profileValueIdx)
+
   for (const [i, arg] of args.entries()) {
     if (arg.startsWith('--')) {
       flags.push(arg.toLowerCase())
-    } else if (i === tierValueIdx) {
-      // Skip -- this is the --tier value, not an API key
+    } else if (skipIndices.has(i)) {
+      // 📖 Skip — this is a value for --tier or --profile, not an API key
     } else if (!apiKey) {
       apiKey = arg
     }
@@ -410,5 +421,161 @@ export function parseArgs(argv) {
 
   let tierFilter = tierValueIdx !== -1 ? args[tierValueIdx].toUpperCase() : null
 
-  return { apiKey, bestMode, fiableMode, openCodeMode, openCodeDesktopMode, openClawMode, noTelemetry, tierFilter }
+  const profileName = profileValueIdx !== -1 ? args[profileValueIdx] : null
+
+  // 📖 --recommend — launch directly into Smart Recommend mode (Q key equivalent)
+  const recommendMode = flags.includes('--recommend')
+
+  return { apiKey, bestMode, fiableMode, openCodeMode, openCodeDesktopMode, openClawMode, noTelemetry, tierFilter, profileName, recommendMode }
+}
+
+// ─── Smart Recommend — Scoring Engine ─────────────────────────────────────────
+
+// 📖 Task types for the Smart Recommend questionnaire.
+// 📖 Each task type has different weight priorities — quick fixes favor speed,
+//    deep refactors favor SWE score and context, code review needs balanced quality,
+//    test generation needs high SWE score + medium context.
+export const TASK_TYPES = {
+  quickfix:    { label: 'Quick Fix',       sweWeight: 0.2, speedWeight: 0.5, ctxWeight: 0.1, stabilityWeight: 0.2 },
+  refactor:    { label: 'Deep Refactor',   sweWeight: 0.4, speedWeight: 0.1, ctxWeight: 0.3, stabilityWeight: 0.2 },
+  review:      { label: 'Code Review',     sweWeight: 0.35, speedWeight: 0.2, ctxWeight: 0.25, stabilityWeight: 0.2 },
+  testgen:     { label: 'Test Generation', sweWeight: 0.35, speedWeight: 0.15, ctxWeight: 0.2, stabilityWeight: 0.3 },
+}
+
+// 📖 Priority presets — bias the scoring toward speed or quality.
+// 📖 'speed' amplifies latency weighting, 'quality' amplifies SWE score weighting.
+export const PRIORITY_TYPES = {
+  speed:   { label: 'Speed',   speedMultiplier: 1.5, sweMultiplier: 0.7 },
+  quality: { label: 'Quality', speedMultiplier: 0.7, sweMultiplier: 1.5 },
+  balanced:{ label: 'Balanced', speedMultiplier: 1.0, sweMultiplier: 1.0 },
+}
+
+// 📖 Context budget categories — match against model's context window size.
+// 📖 'small' (<4K tokens) can use any model. 'large' (>32K) strongly penalizes small-ctx models.
+export const CONTEXT_BUDGETS = {
+  small:  { label: 'Small file (<4K)',      minCtx: 0,     idealCtx: 32 },
+  medium: { label: 'Medium project (<32K)', minCtx: 32,    idealCtx: 128 },
+  large:  { label: 'Large codebase (>32K)', minCtx: 128,   idealCtx: 256 },
+}
+
+// 📖 parseCtxToK: Convert context window string ("128k", "1m", "200k") into numeric K tokens.
+// 📖 Used by the scoring engine to compare against CONTEXT_BUDGETS thresholds.
+function parseCtxToK(ctx) {
+  if (!ctx || ctx === '—') return 0
+  const str = ctx.toLowerCase()
+  if (str.includes('m')) return parseFloat(str.replace('m', '')) * 1000
+  if (str.includes('k')) return parseFloat(str.replace('k', ''))
+  return 0
+}
+
+// 📖 parseSweToNum: Convert SWE-bench score string ("49.2%", "73.1%") into a 0–100 number.
+// 📖 Returns 0 for missing or invalid scores.
+function parseSweToNum(sweScore) {
+  if (!sweScore || sweScore === '—') return 0
+  const num = parseFloat(sweScore.replace('%', ''))
+  return isNaN(num) ? 0 : num
+}
+
+/**
+ * 📖 scoreModelForTask: Score a single model result for a specific task/priority/context combination.
+ *
+ * 📖 The score is a weighted composite of 4 signals:
+ *   - SWE quality score (0–100): how good the model is at coding (from sources.js benchmarks)
+ *   - Speed score (0–100): inverse of average latency (faster = higher score)
+ *   - Context fit score (0–100): how well the model's context window matches the user's budget
+ *   - Stability score (0–100): composite p95/jitter/uptime from getStabilityScore()
+ *
+ * 📖 Each signal is weighted by the task type, then further adjusted by the priority multiplier.
+ * 📖 Models that are down/timeout get a harsh penalty but aren't completely excluded
+ *    (they might come back up during the analysis phase).
+ *
+ * @param {object} result — A model result object (from state.results)
+ * @param {string} taskType — Key from TASK_TYPES ('quickfix'|'refactor'|'review'|'testgen')
+ * @param {string} priority — Key from PRIORITY_TYPES ('speed'|'quality'|'balanced')
+ * @param {string} contextBudget — Key from CONTEXT_BUDGETS ('small'|'medium'|'large')
+ * @returns {number} Score between 0 and 100 (higher = better recommendation)
+ */
+export function scoreModelForTask(result, taskType, priority, contextBudget) {
+  const task = TASK_TYPES[taskType]
+  const prio = PRIORITY_TYPES[priority]
+  const budget = CONTEXT_BUDGETS[contextBudget]
+  if (!task || !prio || !budget) return 0
+
+  // 📖 SWE quality signal (0–100) — raw SWE-bench score
+  const sweNum = parseSweToNum(result.sweScore)
+  const sweScore = Math.min(100, sweNum * (100 / 80)) // 📖 Normalize: 80% SWE → 100 score
+
+  // 📖 Speed signal (0–100) — inverse latency, capped at 5000ms
+  const avg = getAvg(result)
+  let speedScore
+  if (avg === Infinity) {
+    speedScore = 0 // 📖 No data yet — can't judge speed
+  } else {
+    speedScore = Math.max(0, Math.min(100, 100 * (1 - avg / 5000)))
+  }
+
+  // 📖 Context fit signal (0–100):
+  //   - Full score if model ctx >= idealCtx
+  //   - Partial score if model ctx >= minCtx but < idealCtx (linear interpolation)
+  //   - Zero if model ctx < minCtx (too small for the job)
+  const modelCtx = parseCtxToK(result.ctx)
+  let ctxScore
+  if (modelCtx >= budget.idealCtx) {
+    ctxScore = 100
+  } else if (modelCtx >= budget.minCtx) {
+    ctxScore = budget.idealCtx === budget.minCtx
+      ? 100
+      : Math.round(100 * (modelCtx - budget.minCtx) / (budget.idealCtx - budget.minCtx))
+  } else {
+    ctxScore = 0
+  }
+
+  // 📖 Stability signal (0–100) — from getStabilityScore(), or 0 if no data
+  const stability = getStabilityScore(result)
+  const stabScore = stability === -1 ? 0 : stability
+
+  // 📖 Weighted combination: task weights × priority multipliers
+  const rawScore =
+    (sweScore   * task.sweWeight       * prio.sweMultiplier) +
+    (speedScore * task.speedWeight     * prio.speedMultiplier) +
+    (ctxScore   * task.ctxWeight) +
+    (stabScore  * task.stabilityWeight)
+
+  // 📖 Normalize by total effective weight to keep result in 0–100 range
+  const totalWeight =
+    (task.sweWeight   * prio.sweMultiplier) +
+    (task.speedWeight * prio.speedMultiplier) +
+    task.ctxWeight +
+    task.stabilityWeight
+
+  let score = totalWeight > 0 ? rawScore / totalWeight : 0
+
+  // 📖 Penalty for models that are currently down/timeout — still scoreable but penalized
+  if (result.status === 'down' || result.status === 'timeout') {
+    score *= 0.2
+  }
+
+  return Math.round(Math.min(100, Math.max(0, score)))
+}
+
+/**
+ * 📖 getTopRecommendations: Score all models and return the top N recommendations.
+ *
+ * 📖 Filters out hidden models, scores each one, sorts descending, returns topN.
+ * 📖 Each returned item includes the original result + computed score for display.
+ *
+ * @param {Array} results — Full state.results array
+ * @param {string} taskType — Key from TASK_TYPES
+ * @param {string} priority — Key from PRIORITY_TYPES
+ * @param {string} contextBudget — Key from CONTEXT_BUDGETS
+ * @param {number} [topN=3] — How many recommendations to return
+ * @returns {Array<{result: object, score: number}>} Top N scored models, descending by score
+ */
+export function getTopRecommendations(results, taskType, priority, contextBudget, topN = 3) {
+  const scored = results
+    .filter(r => !r.hidden)
+    .map(r => ({ result: r, score: scoreModelForTask(r, taskType, priority, contextBudget) }))
+    .sort((a, b) => b.score - a.score)
+
+  return scored.slice(0, topN)
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "free-coding-models",
-  "version": "0.1.67",
+  "version": "0.1.69",
   "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, huggingface, replicate, deepinfra, fireworks, codestral, hyperbolic, scaleway, googleai, siliconflow, together, cloudflare, perplexity — model arrays per provider
- *   @exports sources — map of { nvidia, groq, cerebras, sambanova, openrouter, huggingface, replicate, deepinfra, fireworks, codestral, hyperbolic, scaleway, googleai, siliconflow, together, cloudflare, perplexity } each with { name, url, models }
+ *   @exports nvidiaNim, groq, cerebras, sambanova, openrouter, huggingface, replicate, deepinfra, fireworks, codestral, hyperbolic, scaleway, googleai, siliconflow, together, cloudflare, perplexity, iflow — model arrays per provider
+ *   @exports sources — map of { nvidia, groq, cerebras, sambanova, openrouter, huggingface, replicate, deepinfra, fireworks, codestral, hyperbolic, scaleway, googleai, siliconflow, together, cloudflare, perplexity, iflow } 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
@@ -230,6 +230,18 @@ export const googleai = [
   ['gemma-3-4b-it',                            'Gemma 3 4B',         'C',  '10.0%', '128k'],
 ]
 
+// 📖 ZAI source - https://open.z.ai
+// 📖 Free API keys available at https://open.z.ai — GLM frontier models
+// 📖 OpenAI-compatible endpoint for coding tasks
+export const zai = [
+  // ── S+ tier — SWE-bench Verified ≥70% ──
+  ['zai/glm-5',                                           'GLM-5',               'S+', '77.8%', '128k'],
+  ['zai/glm-4.7',                                         'GLM-4.7',             'S+', '73.8%', '200k'],
+  ['zai/glm-4.5',                                         'GLM-4.5',             'S+', '75.0%', '128k'],
+  ['zai/glm-4.5-air',                                     'GLM-4.5-Air',         'S+', '72.0%', '128k'],
+  ['zai/glm-4.6',                                         'GLM-4.6',             'S+', '70.0%', '128k'],
+]
+
 // 📖 SiliconFlow source - https://cloud.siliconflow.cn
 // 📖 OpenAI-compatible endpoint: https://api.siliconflow.com/v1/chat/completions
 // 📖 Free model quotas vary by model and can change over time.
@@ -278,6 +290,27 @@ export const perplexity = [
   ['sonar',                                    'Sonar',               'B',  '25.0%', '128k'],
 ]
 
+// 📖 iFlow source - https://platform.iflow.cn
+// 📖 OpenAI-compatible endpoint: https://apis.iflow.cn/v1/chat/completions
+// 📖 Free for individual users with no request limits (API key expires every 7 days)
+// 📖 Provides high-performance models including DeepSeek, Qwen3, Kimi K2, GLM, and TBStars2
+export const iflow = [
+  // ── S+ tier — SWE-bench Verified ≥70% ──
+  ['TBStars2-200B-A13B',                      'TBStars2 200B',       'S+', '77.8%', '128k'],
+  ['deepseek-v3.2',                           'DeepSeek V3.2',       'S+', '73.1%', '128k'],
+  ['qwen3-coder-plus',                        'Qwen3 Coder Plus',    'S+', '72.0%', '256k'],
+  ['qwen3-235b-a22b-instruct',                'Qwen3 235B',          'S+', '70.0%', '256k'],
+  ['deepseek-r1',                             'DeepSeek R1',         'S+', '70.6%', '128k'],
+  // ── S tier — SWE-bench Verified 60–70% ──
+  ['kimi-k2',                                 'Kimi K2',             'S',  '65.8%', '128k'],
+  ['kimi-k2-0905',                            'Kimi K2 0905',        'S',  '68.0%', '256k'],
+  ['glm-4.6',                                 'GLM 4.6',             'S',  '62.0%', '200k'],
+  ['deepseek-v3',                             'DeepSeek V3',         'S',  '62.0%', '128k'],
+  // ── A+ tier — SWE-bench Verified 50–60% ──
+  ['qwen3-32b',                               'Qwen3 32B',           'A+', '50.0%', '128k'],
+  ['qwen3-max',                               'Qwen3 Max',           'A+', '55.0%', '256k'],
+]
+
 // 📖 All sources combined - used by the main script
 // 📖 Each source has: name (display), url (API endpoint), models (array of model tuples)
 export const sources = {
@@ -346,6 +379,11 @@ export const sources = {
     url: 'https://generativelanguage.googleapis.com/v1beta/openai/chat/completions',
     models: googleai,
   },
+  zai: {
+    name: 'ZAI',
+    url: 'https://api.z.ai/api/coding/paas/v4/chat/completions',
+    models: zai,
+  },
   siliconflow: {
     name: 'SiliconFlow',
     url: 'https://api.siliconflow.com/v1/chat/completions',
@@ -366,6 +404,11 @@ export const sources = {
     url: 'https://api.perplexity.ai/chat/completions',
     models: perplexity,
   },
+  iflow: {
+    name: 'iFlow',
+    url: 'https://apis.iflow.cn/v1/chat/completions',
+    models: iflow,
+  },
 }
 
 // 📖 Flatten all models from all sources — each entry includes providerKey as 6th element