modelmix 4.7.0 → 4.7.4

package/README.md

@@ -89,7 +89,7 @@ console.log(ETH.price);
 ```javascript
 ModelMix.new()
   .gptOss()
-  .kimiK25think()
+  .kimiK25()
   .hermes3()
   .addText('What is the capital of France?');
 ```
@@ -126,7 +126,7 @@ ModelMix.new().effort(-1).minimaxM3().addText('...').message();
 
 \* Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. DeepSeek `↑` = thinking on; `off` = thinking disabled. MiniMax `off`/`adaptive` = `thinking.disabled` / `thinking.type=adaptive`. Gemini 2.5 maps 0–100 to `thinkingBudget`. Anthropic maps adaptive thinking + `output_config.effort` on Claude 5 / Fable / Opus 4.6+ / Sonnet 4.6+; older models (Sonnet 4.5, Haiku 4.5) get `thinking.type=enabled` + `budget_tokens`. `-1` = provider adaptive/dynamic when available, else no-op. Levels clamp to what each model supports.
 
-Migration: former Anthropic `*think()` shorthands are removed — use `.effort(100).opus5()` (or any 0–100 / `-1`) instead.
+Migration: former `*think()` shorthands are removed — use `.effort(n).<model>()` (or any 0–100 / `-1`). Kimi: `kimiK25()` / `kimiK26()`. Grok 4.20: `.grok420()` is non-reasoning; `.effort(20+).grok420()` (or `-1`) selects the reasoning model.
 
 ## 🔧 Model Context Protocol (MCP) Integration
 
@@ -190,11 +190,12 @@ Here's a comprehensive list of available methods:
 | `gemini31pro()`     | Google     | gemini-3.1-pro-preview       | [\$2.00 / \$12.00][3]      |
 | `gemini36flash()`   | Google     | gemini-3.6-flash             | [\$1.50 / \$7.50][3]       |
 | `gemini35flash()`   | Google     | gemini-3.5-flash             | [\$0.75 / \$4.50][3]       |
+| `gemini35flashLite()`| Google    | gemini-3.5-flash-lite        | [\$0.30 / \$2.50][3]       |
 | `gemini31flashLite()`| Google     | gemini-3.1-flash-lite-preview | [\$0.25 / \$1.50][3]       |
 | `grok45()`          | Grok       | grok-4.5                     | [\$2.00 / \$6.00][6]       |
 | `grok43()`          | Grok       | grok-4.3                     | [\$1.25 / \$2.50][6]       |
 | `grok420multiAgent()`| Grok      | grok-4.20-multi-agent-0309   | [\$1.25 / \$2.50][6]       |
-| `grok420[think]()`  | Grok       | grok-4.20-0309               | [\$1.25 / \$2.50][6]       |
+| `grok420()`         | Grok       | grok-4.20-0309 (†)           | [\$1.25 / \$2.50][6]       |
 | `qwen36plus()`      | Fireworks/Together | qwen3p6-plus / Qwen3.6-Plus | [\$0.50 / \$3.00][10] |
 | `qwen37plus()`      | Fireworks  | models/qwen3p7-plus          | [\$0.40 / \$1.60][10]      |
 | `qwen38max()`       | OpenRouter | qwen/qwen3.8-max             | [\$2.00 / \$6.00][12]      |
@@ -208,8 +209,8 @@ Here's a comprehensive list of available methods:
 | `sonarPro()`        | Perplexity | sonar-pro                    | [\$3.00 / \$15.00][4]      |
 | `hermes3()`         | Lambda     | Hermes-3-Llama-3.1-405B-FP8  | [\$0.80 / \$0.80][8]       |
 | `kimiK3()`          | Moonshot   | kimi-k3                      | [\$3.00 / \$15.00][11]     |
-| `kimiK25think()`    | Together   | Kimi-K2.5                    | [\$0.50 / \$2.80][7]       |
-| `kimiK26think()`    | Fireworks  | models/kimi-k2p6             | [\$0.95 / \$4.00][10]      |
+| `kimiK25()`         | Together   | Kimi-K2.5                    | [\$0.50 / \$2.80][7]       |
+| `kimiK26()`         | Fireworks  | models/kimi-k2p6             | [\$0.95 / \$4.00][10]      |
 
 [1]: https://platform.openai.com/docs/pricing "Pricing | OpenAI"
 [2]: https://docs.anthropic.com/en/docs/about-claude/pricing "Pricing - Anthropic"
@@ -225,6 +226,7 @@ Here's a comprehensive list of available methods:
 [12]: https://openrouter.ai/qwen/qwen3.8-max "OpenRouter Pricing"
 
 Each method accepts optional `options`, `config`, and (for multi-provider methods) `mix` parameters to customize behavior.  
+† `grok420()` resolves to `grok-4.20-0309-non-reasoning` by default, or `grok-4.20-0309-reasoning` when `.effort(20+)` / `-1` (or native non-`none` `reasoning_effort`) is set.  
 For NVIDIA on DeepSeek V4 Flash/Pro, use `deepseekV4Flash({ mix: { nvidia: true } })` or `deepseekV4Pro({ mix: { nvidia: true } })`.
 For Together on Qwen 3.6 Plus, use `qwen36plus({ mix: { fireworks: false, together: true } })`.
 For OpenRouter on Qwen 3.7 Plus, use `qwen37plus({ mix: { fireworks: false, openrouter: true } })`.

package/demo/free.js

@@ -3,7 +3,7 @@ try { process.loadEnvFile(); } catch {}
 
 const ai = ModelMix.new({ config: { debug: 2 } })
     .gptOss()
-    .kimiK25think()
+    .kimiK25()
     .hermes3()
     .addText('What is the capital of France?');
 

package/effort.js

@@ -105,6 +105,39 @@ const PROVIDER_FAMILY_BY_CLASS = {
     MixCustom: null,
 };
 
+/** Logical alias from `.grok420()` — resolved to reasoning / non-reasoning at request time. */
+const GROK420_ALIAS = 'grok-4.20-0309';
+const GROK420_REASONING = 'grok-4.20-0309-reasoning';
+const GROK420_NON_REASONING = 'grok-4.20-0309-non-reasoning';
+
+function isGrok420Alias(modelKey) {
+    return modelKey === GROK420_ALIAS;
+}
+
+/**
+ * Pick Grok 4.20 concrete model from unified effort (and native reasoning_effort).
+ * - no effort / OpenAI band `none` (0–19) / native `none` → non-reasoning
+ * - effort -1 or 20–100 / native non-none reasoning_effort → reasoning
+ */
+function resolveGrok420ModelKey(modelKey, effort, options = {}) {
+    if (!isGrok420Alias(modelKey)) return modelKey;
+
+    const native = options.reasoning_effort;
+    if (native != null && native !== '') {
+        return native === 'none' ? GROK420_NON_REASONING : GROK420_REASONING;
+    }
+
+    if (effort === undefined || effort === null) {
+        return GROK420_NON_REASONING;
+    }
+
+    const normalized = normalizeEffort(effort);
+    if (normalized === -1) return GROK420_REASONING;
+
+    const level = levelFromBands(normalized, OPENAI_BANDS);
+    return level === 'none' ? GROK420_NON_REASONING : GROK420_REASONING;
+}
+
 function normalizeEffort(value) {
     if (typeof value !== 'number' || !Number.isFinite(value) || !Number.isInteger(value)) {
         throw new Error(`Invalid effort: expected integer -1 or 0..100, got ${JSON.stringify(value)}`);
@@ -332,6 +365,10 @@ function mapEffort(providerFamily, effort, modelKey) {
         if (isMiniMax(modelKey)) {
             return mapMiniMaxEffort(normalized);
         }
+        // Non-reasoning Grok 4.20 has no reasoning_effort control
+        if (modelKey === GROK420_NON_REASONING) {
+            return null;
+        }
         const desired = levelFromBands(normalized, OPENAI_BANDS);
         const level = pickNearestLevel(desired, OPENAI_LEVELS, supportedOpenAILevels(modelKey));
         return { reasoning_effort: level };
@@ -409,6 +446,8 @@ module.exports = {
     applyUnifiedEffort,
     hasNativeEffort,
     resolveProviderFamily,
+    resolveGrok420ModelKey,
+    isGrok420Alias,
     isDeepSeekV4,
     isMiniMax,
     usesAnthropicAdaptiveThinking,
@@ -423,4 +462,7 @@ module.exports = {
     GEMINI_LEVELS,
     DEEPSEEK_LEVELS,
     ANTHROPIC_MANUAL_BUDGET_MAX,
+    GROK420_ALIAS,
+    GROK420_REASONING,
+    GROK420_NON_REASONING,
 };

package/index.d.ts

@@ -302,6 +302,7 @@ export declare class ModelMix {
   gemini3flash(args?: ModelAttachArgs): this;
   gemini36flash(args?: ModelAttachArgs): this;
   gemini35flash(args?: ModelAttachArgs): this;
+  gemini35flashLite(args?: ModelAttachArgs): this;
   gemini31flashLite(args?: ModelAttachArgs): this;
   gemini25pro(args?: ModelAttachArgs): this;
 
@@ -313,7 +314,7 @@ export declare class ModelMix {
   grok45(args?: ModelAttachArgs): this;
   grok43(args?: ModelAttachArgs): this;
   grok420multiAgent(args?: ModelAttachArgs): this;
-  grok420think(args?: ModelAttachArgs): this;
+  /** Non-reasoning by default; with `.effort(20+)` / `-1` uses the reasoning model at request time. */
   grok420(args?: ModelAttachArgs): this;
 
   // Multi-provider
@@ -322,10 +323,10 @@ export declare class ModelMix {
   qwen37plus(args?: ModelAttachArgs): this;
   qwen38max(args?: ModelAttachArgs): this;
   hermes3(args?: ModelAttachArgs): this;
-  kimiK26think(args?: ModelAttachArgs): this;
+  kimiK26(args?: ModelAttachArgs): this;
   kimiK27Code(args?: ModelAttachArgs): this;
   kimiK3(args?: ModelAttachArgs): this;
-  kimiK25think(args?: ModelAttachArgs): this;
+  kimiK25(args?: ModelAttachArgs): this;
   lmstudio(model?: string, args?: ModelAttachArgs): this;
   minimaxM25(args?: ModelAttachArgs): this;
   minimaxM27(args?: ModelAttachArgs): this;

package/index.js

@@ -23,7 +23,8 @@ const {
 const {
     normalizeEffort,
     applyUnifiedEffort,
-    resolveProviderFamily
+    resolveProviderFamily,
+    resolveGrok420ModelKey
 } = require('./effort');
 
 const DEFAULT_RETRYABLE_STATUS_CODES = [408, 425, 429, 500, 502, 503, 504, 529];
@@ -81,6 +82,7 @@ const MODEL_PRICING = {
     'gemini-3-flash-preview': [0.50, 3.00],
     'gemini-3.6-flash': [1.50, 7.50],
     'gemini-3.5-flash': [0.75, 4.50],
+    'gemini-3.5-flash-lite': [0.30, 2.50],
     'gemini-2.5-pro': [1.25, 10.00],
     'gemini-2.5-flash': [0.30, 2.50],
     'gemini-3.1-flash-lite-preview': [0.25, 1.50],
@@ -88,6 +90,7 @@ const MODEL_PRICING = {
     'grok-4.5': [2.00, 6.00],
     'grok-4.3': [1.25, 2.50],
     'grok-4.20-multi-agent-0309': [1.25, 2.50],
+    'grok-4.20-0309': [1.25, 2.50],
     'grok-4.20-0309-reasoning': [1.25, 2.50],
     'grok-4.20-0309-non-reasoning': [1.25, 2.50],
     // Fireworks
@@ -427,6 +430,9 @@ class ModelMix {
     gemini35flash({ options = {}, config = {} } = {}) {
         return this.attach('gemini-3.5-flash', new MixGoogle({ options, config }));
     }
+    gemini35flashLite({ options = {}, config = {} } = {}) {
+        return this.attach('gemini-3.5-flash-lite', new MixGoogle({ options, config }));
+    }
     gemini31flashLite({ options = {}, config = {} } = {}) {
         return this.attach('gemini-3.1-flash-lite-preview', new MixGoogle({ options, config }));
     }
@@ -449,11 +455,9 @@ class ModelMix {
     grok420multiAgent({ options = {}, config = {} } = {}) {
         return this.attach('grok-4.20-multi-agent-0309', new MixGrok({ options, config }));
     }
-    grok420think({ options = {}, config = {} } = {}) {
-        return this.attach('grok-4.20-0309-reasoning', new MixGrok({ options, config }));
-    }
+    /** Non-reasoning by default; with `.effort(20+)` / `-1` resolves to the reasoning model at request time. */
     grok420({ options = {}, config = {} } = {}) {
-        return this.attach('grok-4.20-0309-non-reasoning', new MixGrok({ options, config }));
+        return this.attach('grok-4.20-0309', new MixGrok({ options, config }));
     }
 
     qwen3({ options = {}, config = {}, mix = { together: true, cerebras: false } } = {}) {
@@ -489,7 +493,7 @@ class ModelMix {
         return this;
     }
 
-    kimiK26think({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
+    kimiK26({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.fireworks) this.attach('accounts/fireworks/models/kimi-k2p6', new MixFireworks({ options, config }));
         if (mix.openrouter) this.attach('moonshotai/kimi-k2.6', new MixOpenRouter({ options, config }));
@@ -510,7 +514,7 @@ class ModelMix {
         return this;
     }
 
-    kimiK25think({ options = {}, config = {}, mix = { together: true } } = {}) {
+    kimiK25({ options = {}, config = {}, mix = { together: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.together) this.attach('moonshotai/Kimi-K2.5', new MixTogether({ options, config }));
         if (mix.fireworks) this.attach('accounts/fireworks/models/kimi-k2p5', new MixFireworks({ options, config }));
@@ -991,9 +995,17 @@ class ModelMix {
                     }
                 };
 
+                // Grok 4.20 alias → reasoning / non-reasoning from unified effort
+                const resolvedModelKey = resolveGrok420ModelKey(
+                    currentModelKey,
+                    currentConfig.effort,
+                    currentOptions
+                );
+                currentOptions.model = resolvedModelKey;
+
                 // Unified effort → native provider fields (skipped if native already set)
                 const providerFamily = resolveProviderFamily(providerInstance);
-                applyUnifiedEffort(currentOptions, currentConfig, providerFamily, currentModelKey);
+                applyUnifiedEffort(currentOptions, currentConfig, providerFamily, resolvedModelKey);
 
                 if (currentConfig.debug >= 1) {
                     const isPrimary = i === 0;
@@ -1003,7 +1015,7 @@ class ModelMix {
                         : ' (fallback)';
                     // Extract provider name from class name (e.g., "MixOpenRouter" -> "openrouter")
                     const providerName = providerInstance.constructor.name.replace(/^Mix/, '').toLowerCase();
-                    const header = `\n${prefix} [${providerName}:${currentModelKey}] #${originalIndex + 1}${suffix}`;
+                    const header = `\n${prefix} [${providerName}:${resolvedModelKey}] #${originalIndex + 1}${suffix}`;
 
                     if (currentConfig.debug >= 2) {
                         console.log(`${header}\n${ModelMix.formatInputSummary(this.messages, currentConfig.system, currentConfig.debug)}`);
@@ -1048,7 +1060,7 @@ class ModelMix {
                             if (currentConfig.debug >= 1) {
                                 const nextAttempt = attempt + 2;
                                 const totalAttempts = retries + 1;
-                                console.log(`↺ Retrying [${currentModelKey}] due to status ${statusCode} (${nextAttempt}/${totalAttempts})`);
+                                console.log(`↺ Retrying [${resolvedModelKey}] due to status ${statusCode} (${nextAttempt}/${totalAttempts})`);
                             }
 
                             const delay = Math.min(baseDelayMs * Math.pow(2, attempt), maxDelayMs);
@@ -1060,7 +1072,7 @@ class ModelMix {
                     const elapsedMs = Date.now() - startTime;
 
                     if (result.tokens) {
-                        result.tokens.cost = ModelMix.calculateCost(currentModelKey, result.tokens);
+                        result.tokens.cost = ModelMix.calculateCost(resolvedModelKey, result.tokens);
                         const elapsedSec = elapsedMs / 1000;
                         result.tokens.speed = elapsedSec > 0 ? Math.round(result.tokens.output / elapsedSec) : 0;
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "4.7.0",
+  "version": "4.7.4",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -72,6 +72,6 @@
     "test:live": "mocha test/live.test.js --timeout 10000 --require test/setup.js",
     "test:live.mcp": "mocha test/live.mcp.js --timeout 60000 --require test/setup.js",
     "test:tokens": "mocha test/tokens.test.js --timeout 10000 --require test/setup.js",
-    "test:offline": "mocha test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js --timeout 10000 --require test/setup.js"
+    "test:offline": "mocha test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js test/grok.test.js --timeout 10000 --require test/setup.js"
   }
 }

package/skills/modelmix/SKILL.md

@@ -114,7 +114,7 @@ ModelMix.new({ config: { effort: 80 } })
 | DeepSeek V4 | off | `low`↑ | `high`↑ | `high`↑ | `max`↑ | — |
 | MiniMax M3 | off | adaptive | adaptive | adaptive | adaptive | adaptive |
 
-\* Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. DeepSeek `↑` = thinking on; `off` = thinking disabled. MiniMax `off`/`adaptive` = `thinking.disabled` / `thinking.type=adaptive`. Gemini 2.5 maps 0–100 to `thinkingBudget`. Anthropic: adaptive + `output_config.effort` on Claude 5 / Fable / Opus 4.6+ / Sonnet 4.6+; Sonnet 4.5 / Haiku 4.5 use `thinking.type=enabled` + `budget_tokens`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. Former Anthropic `*think()` methods are removed — use `.effort(n).<model>()`.
+\* Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. DeepSeek `↑` = thinking on; `off` = thinking disabled. MiniMax `off`/`adaptive` = `thinking.disabled` / `thinking.type=adaptive`. Gemini 2.5 maps 0–100 to `thinkingBudget`. Anthropic: adaptive + `output_config.effort` on Claude 5 / Fable / Opus 4.6+ / Sonnet 4.6+; Sonnet 4.5 / Haiku 4.5 use `thinking.type=enabled` + `budget_tokens`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. Former `*think()` methods are removed — use `.effort(n).<model>()`. Kimi: `kimiK25()` / `kimiK26()`. Grok 4.20: `.grok420()` non-reasoning; `.effort(20+|-1).grok420()` selects reasoning.
 
 ## Available Model Shorthands
 
@@ -127,16 +127,16 @@ ModelMix.new({ config: { effort: 80 } })
 Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.effort(100).opus5()`.
 
 ### Google
-`gemini3pro()` `gemini3flash()` `gemini36flash()` `gemini35flash()` `gemini25pro()` `gemini25flash()`
+`gemini3pro()` `gemini3flash()` `gemini36flash()` `gemini35flash()` `gemini35flashLite()` `gemini31flashLite()` `gemini25pro()` `gemini25flash()`
 
 ### Grok
-`grok45()` `grok43()` `grok420multiAgent()` `grok420()` `grok420think()`
+`grok45()` `grok43()` `grok420multiAgent()` `grok420()`
 
 ### Perplexity
 `sonar()` `sonarPro()`
 
 ### Together
-`qwen36plus()` `GLM52()` `kimiK25think()` `gptOss()`
+`qwen36plus()` `GLM52()` `kimiK25()` `kimiK26()` `gptOss()`
 
 ### Moonshot
 `kimiK3()` — requires `MOONSHOT_API_KEY`; use `{ mix: { moonshot: false, openrouter: true } }` for OpenRouter.
@@ -145,7 +145,7 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 `minimaxM25()` `minimaxM27()` `minimaxM3()`
 
 ### Fireworks
-`qwen36plus()` `qwen37plus()` `deepseekV4Flash()` `deepseekV4Pro()`
+`qwen36plus()` `qwen37plus()` `deepseekV4Flash()` `deepseekV4Pro()` `kimiK26()`
 
 ### Cerebras
 `GLM46()`
@@ -154,7 +154,7 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 `qwen38max()` `GLM45()`
 
 ### Multi-provider (auto-fallback across free/paid tiers)
-`hermes3()` `kimiK25think()`
+`hermes3()` `kimiK25()`
 
 ### Local
 `lmstudio()` — for LM Studio local models
@@ -429,7 +429,7 @@ For full debug output, also set: `DEBUG=ModelMix* node script.js`
 ```javascript
 const model = ModelMix.new()
     .gptOss()
-    .kimiK25think()
+    .kimiK25()
     .hermes3()
     .addText("What is the capital of France?");
 console.log(await model.message());
@@ -452,7 +452,7 @@ const model = ModelMix.new({
         minimax: false,      // default: false
         fireworks: false     // default: false
     }
-}).kimiK25think();
+}).kimiK25();
 ```
 
 ## Agent Usage Rules

package/test/grok.test.js

@@ -1,13 +1,18 @@
 const { expect } = require('chai');
 const { ModelMix } = require('../index.js');
+const {
+    resolveGrok420ModelKey,
+    GROK420_ALIAS,
+    GROK420_REASONING,
+    GROK420_NON_REASONING
+} = require('../effort.js');
 
 describe('Grok Model Registration Tests', () => {
     const grokModels = [
         { method: 'grok45', key: 'grok-4.5' },
         { method: 'grok43', key: 'grok-4.3' },
         { method: 'grok420multiAgent', key: 'grok-4.20-multi-agent-0309' },
-        { method: 'grok420think', key: 'grok-4.20-0309-reasoning' },
-        { method: 'grok420', key: 'grok-4.20-0309-non-reasoning' }
+        { method: 'grok420', key: GROK420_ALIAS }
     ];
 
     for (const grokModel of grokModels) {
@@ -20,3 +25,34 @@ describe('Grok Model Registration Tests', () => {
         });
     }
 });
+
+describe('Grok 4.20 effort → model resolution', () => {
+    it('uses non-reasoning when effort is unset', () => {
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, undefined)).to.equal(GROK420_NON_REASONING);
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, null)).to.equal(GROK420_NON_REASONING);
+    });
+
+    it('uses non-reasoning for OpenAI none band (0–19)', () => {
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 0)).to.equal(GROK420_NON_REASONING);
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 19)).to.equal(GROK420_NON_REASONING);
+    });
+
+    it('uses reasoning for effort 20–100 and -1', () => {
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 20)).to.equal(GROK420_REASONING);
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 50)).to.equal(GROK420_REASONING);
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 100)).to.equal(GROK420_REASONING);
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, -1)).to.equal(GROK420_REASONING);
+    });
+
+    it('honors native reasoning_effort over config.effort', () => {
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 0, { reasoning_effort: 'high' }))
+            .to.equal(GROK420_REASONING);
+        expect(resolveGrok420ModelKey(GROK420_ALIAS, 100, { reasoning_effort: 'none' }))
+            .to.equal(GROK420_NON_REASONING);
+    });
+
+    it('leaves non-alias keys unchanged', () => {
+        expect(resolveGrok420ModelKey(GROK420_REASONING, 50)).to.equal(GROK420_REASONING);
+        expect(resolveGrok420ModelKey('grok-4.3', 50)).to.equal('grok-4.3');
+    });
+});

package/test/live.test.js

@@ -194,8 +194,8 @@ describe('Live Integration Tests', function () {
 
         const grokSeriesTests = [
             { name: 'Grok 4.3', factory: (m) => m.grok43(), token: 'grok43' },
-            { name: 'Grok 4.20 reasoning', factory: (m) => m.grok420think(), token: 'grok420think' },
-            { name: 'Grok 4.20 non-reasoning', factory: (m) => m.grok420(), token: 'grok420' }
+            { name: 'Grok 4.20 reasoning', factory: (m) => m.effort(50).grok420(), token: 'grok420' },
+            { name: 'Grok 4.20 non-reasoning', factory: (m) => m.grok420(), token: 'grok420nr' }
         ];
 
         for (const grokModel of grokSeriesTests) {
@@ -242,7 +242,7 @@ describe('Live Integration Tests', function () {
     describe('JSON Structured Output for New Models', function () {
 
         it('should return structured JSON with KimiK25 Thinking', async function () {
-            const model = ModelMix.new(setup).kimiK25think();
+            const model = ModelMix.new(setup).kimiK25();
 
             model.addText('Generate information about a fictional vehicle.');
 

package/test/tokens.test.js

@@ -108,15 +108,18 @@ describe('Token Usage Tracking', () => {
     it('should register Gemini Flash shortcuts with Google provider', function () {
         const model = ModelMix.new()
             .gemini36flash()
-            .gemini35flash();
+            .gemini35flash()
+            .gemini35flashLite();
 
         expect(model.models.map(({ key }) => key)).to.deep.equal([
             'gemini-3.6-flash',
-            'gemini-3.5-flash'
+            'gemini-3.5-flash',
+            'gemini-3.5-flash-lite'
         ]);
         expect(model.models.every(({ provider }) => provider instanceof MixGoogle)).to.equal(true);
         expect(ModelMix.calculateCost('gemini-3.6-flash', { input: 1_000_000, output: 1_000_000 })).to.equal(9);
         expect(ModelMix.calculateCost('gemini-3.5-flash', { input: 1_000_000, output: 1_000_000 })).to.equal(5.25);
+        expect(ModelMix.calculateCost('gemini-3.5-flash-lite', { input: 1_000_000, output: 1_000_000 })).to.equal(2.8);
     });
 
     it('should register MiMo shortcuts with native and OpenRouter providers', function () {