modelmix 4.6.15 → 4.7.2

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?');
 ```
@@ -124,7 +124,9 @@ ModelMix.new().effort(-1).minimaxM3().addText('...').message();
 | 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`. `-1` = provider adaptive/dynamic when available, else no-op. Levels clamp to what each model supports.
+\* 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 `*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
 
@@ -177,14 +179,14 @@ Here's a comprehensive list of available methods:
 | `gpt41mini()`       | OpenAI     | gpt-4.1-mini                 | [\$0.40 / \$1.60][1]       |
 | `gpt41nano()`       | OpenAI     | gpt-4.1-nano                 | [\$0.10 / \$0.40][1]       |
 | `gptOss()`          | Together   | gpt-oss-120B                 | [\$0.15 / \$0.60][7]       |
-| `fable5[think]()`   | Anthropic  | claude-fable-5               | [\$10.00 / \$50.00][2]     |
-| `opus5[think]()`    | Anthropic  | claude-opus-5                | [\$5.00 / \$25.00][2]      |
-| `opus48[think]()`   | Anthropic  | claude-opus-4-8              | [\$5.00 / \$25.00][2]      |
-| `opus47[think]()`   | Anthropic  | claude-opus-4-7              | [\$5.00 / \$25.00][2]      |
-| `opus46[think]()`   | Anthropic  | claude-opus-4-6              | [\$5.00 / \$25.00][2]      |
-| `sonnet5[think]()`  | Anthropic  | claude-sonnet-5              | [\$3.00 / \$15.00][2]      |
-| `sonnet46[think]()` | Anthropic  | claude-sonnet-4-6            | [\$3.00 / \$15.00][2]      |
-| `haiku45[think]()`  | Anthropic  | claude-haiku-4-5-20251001    | [\$1.00 / \$5.00][2]       |
+| `fable5()`          | Anthropic  | claude-fable-5               | [\$10.00 / \$50.00][2]     |
+| `opus5()`           | Anthropic  | claude-opus-5                | [\$5.00 / \$25.00][2]      |
+| `opus48()`          | Anthropic  | claude-opus-4-8              | [\$5.00 / \$25.00][2]      |
+| `opus47()`          | Anthropic  | claude-opus-4-7              | [\$5.00 / \$25.00][2]      |
+| `opus46()`          | Anthropic  | claude-opus-4-6              | [\$5.00 / \$25.00][2]      |
+| `sonnet5()`         | Anthropic  | claude-sonnet-5              | [\$3.00 / \$15.00][2]      |
+| `sonnet46()`        | Anthropic  | claude-sonnet-4-6            | [\$3.00 / \$15.00][2]      |
+| `haiku45()`         | Anthropic  | claude-haiku-4-5-20251001    | [\$1.00 / \$5.00][2]       |
 | `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]       |
@@ -192,8 +194,7 @@ Here's a comprehensive list of available methods:
 | `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]       |
-| `grok41[think]()`   | Grok       | grok-4-1-fast                | [\$0.20 / \$0.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]      |
@@ -207,8 +208,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"
@@ -224,6 +225,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/demo/opus5.js

@@ -15,9 +15,9 @@ opus.addText("Explain quantum entanglement in simple terms.");
 const response = await opus.message();
 console.log(response);
 
-console.log("\n" + '--------| opus5think() |--------');
+console.log("\n" + '--------| effort(100).opus5() |--------');
 
-const opusThink = mmix.new().opus5think();
+const opusThink = mmix.new().effort(100).opus5();
 opusThink.addText("A bat and a ball cost $1.10 in total. The bat costs $1.00 more than the ball. How much does the ball cost?");
 const thinkResponse = await opusThink.raw();
 console.log(thinkResponse);

package/demo/short.js

@@ -9,9 +9,9 @@ const setup = {
 };
 
 const mmix = await ModelMix.new(setup)
-    .sonnet4() // (main model) Anthropic claude-sonnet-4-20250514
-    .o4mini() // (fallback 1) OpenAI o4-mini
-    .gemini25proExp({ config: { temperature: 0 } }) // (fallback 2) Google gemini-2.5-pro-exp-03-25
+    .sonnet46() // (main model) Anthropic claude-sonnet-4-6
+    .gpt56luna() // (fallback 1) OpenAI gpt-5.6-luna
+    .gemini36flash({ config: { temperature: 0 } }) // (fallback 2) Google gemini-3.6-flash
     .gpt41nano() // (fallback 3) OpenAI gpt-4.1-nano
     .grok43() // (fallback 4) Grok grok-4.3
     .addText("What's your name?");

package/demo/stream.js

@@ -6,7 +6,7 @@ await ModelMix.new().gpt41nano()
     .addText('describe')
     .stream((data) => { console.log(data.message); });
 
-await ModelMix.new().haiku35()
+await ModelMix.new().haiku45()
     .addImageFromUrl('https://pbs.twimg.com/media/F6-GsjraAAADDGy?format=jpg')
     .addText('describe')
     .stream((data) => { console.log(data.message); });

package/demo/tokens.js

@@ -25,7 +25,7 @@ console.log('-'.repeat(60));
 
 const providers = [
     { name: 'OpenAI GPT-5-nano', fn: (m) => m.gpt5nano() },
-    { name: 'Anthropic Haiku', fn: (m) => m.haiku35() },
+    { name: 'Anthropic Haiku', fn: (m) => m.haiku45() },
     { name: 'Google Gemini', fn: (m) => m.gemini25flash() }
 ];
 

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)}`);
@@ -170,6 +203,62 @@ function isMiniMax(modelKey) {
     return typeof modelKey === 'string' && modelKey.toLowerCase().includes('minimax');
 }
 
+/** Max budget_tokens when mapping unified effort onto manual Anthropic thinking. */
+const ANTHROPIC_MANUAL_BUDGET_MAX = 16384;
+
+/**
+ * Models that use adaptive thinking + output_config.effort (Claude 5 / Fable /
+ * Opus 4.6+ / Sonnet 4.6+). Older ones (Sonnet 4.5, Haiku 4.5, Opus 4.5) use
+ * thinking.type=enabled + budget_tokens.
+ */
+function usesAnthropicAdaptiveThinking(modelKey) {
+    const id = String(modelKey || '').toLowerCase();
+    if (!id) return true;
+    if (!id.includes('claude')) return true;
+    if (id.includes('fable') || id.includes('mythos')) return true;
+
+    const opus = id.match(/claude-opus-(\d+)(?:-(\d+))?/);
+    if (opus) {
+        const major = Number(opus[1]);
+        const minor = opus[2] !== undefined ? Number(opus[2]) : 0;
+        return major > 4 || (major === 4 && minor >= 6);
+    }
+
+    const sonnet = id.match(/claude-sonnet-(\d+)(?:-(\d+))?/);
+    if (sonnet) {
+        const major = Number(sonnet[1]);
+        const minor = sonnet[2] !== undefined ? Number(sonnet[2]) : 0;
+        return major > 4 || (major === 4 && minor >= 6);
+    }
+
+    // Haiku 4.5 and earlier: manual extended thinking only
+    if (id.includes('haiku')) return false;
+
+    return true;
+}
+
+function mapAnthropicManualBudget(normalized) {
+    return Math.max(1024, Math.round((normalized / 100) * ANTHROPIC_MANUAL_BUDGET_MAX));
+}
+
+function mapAnthropicEffort(normalized, modelKey) {
+    if (!usesAnthropicAdaptiveThinking(modelKey)) {
+        return {
+            thinking: {
+                type: 'enabled',
+                budget_tokens: mapAnthropicManualBudget(normalized)
+            }
+        };
+    }
+
+    const desired = levelFromBands(normalized, ANTHROPIC_BANDS);
+    const level = pickNearestLevel(desired, ANTHROPIC_LEVELS, ANTHROPIC_LEVELS);
+    return {
+        thinking: { type: 'adaptive', display: 'summarized' },
+        output_config: { effort: level }
+    };
+}
+
 function mapDeepSeekEffort(normalized) {
     // DeepSeek V4 has no adaptive mode (only enabled/disabled + low|high|max)
     if (normalized === -1) return null;
@@ -276,15 +365,17 @@ 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 };
     }
 
     if (providerFamily === 'anthropic') {
-        const desired = levelFromBands(normalized, ANTHROPIC_BANDS);
-        const level = pickNearestLevel(desired, ANTHROPIC_LEVELS, ANTHROPIC_LEVELS);
-        return { output_config: { effort: level } };
+        return mapAnthropicEffort(normalized, modelKey);
     }
 
     if (providerFamily === 'google') {
@@ -355,8 +446,11 @@ module.exports = {
     applyUnifiedEffort,
     hasNativeEffort,
     resolveProviderFamily,
+    resolveGrok420ModelKey,
+    isGrok420Alias,
     isDeepSeekV4,
     isMiniMax,
+    usesAnthropicAdaptiveThinking,
     levelFromBands,
     pickNearestLevel,
     OPENAI_BANDS,
@@ -367,4 +461,8 @@ module.exports = {
     ANTHROPIC_LEVELS,
     GEMINI_LEVELS,
     DEEPSEEK_LEVELS,
+    ANTHROPIC_MANUAL_BUDGET_MAX,
+    GROK420_ALIAS,
+    GROK420_REASONING,
+    GROK420_NON_REASONING,
 };

package/index.d.ts

@@ -286,28 +286,14 @@ export declare class ModelMix {
 
   // Anthropic
   fable5(args?: ModelAttachArgs): this;
-  fable5think(args?: ModelAttachArgs): this;
   opus5(args?: ModelAttachArgs): this;
-  opus5think(args?: ModelAttachArgs): this;
-  opus48think(args?: ModelAttachArgs): this;
-  opus47think(args?: ModelAttachArgs): this;
-  opus46think(args?: ModelAttachArgs): this;
   opus48(args?: ModelAttachArgs): this;
   opus47(args?: ModelAttachArgs): this;
   opus46(args?: ModelAttachArgs): this;
-  opus41(args?: ModelAttachArgs): this;
-  opus41think(args?: ModelAttachArgs): this;
   sonnet5(args?: ModelAttachArgs): this;
-  sonnet5think(args?: ModelAttachArgs): this;
-  sonnet4(args?: ModelAttachArgs): this;
-  sonnet4think(args?: ModelAttachArgs): this;
   sonnet46(args?: ModelAttachArgs): this;
-  sonnet46think(args?: ModelAttachArgs): this;
   sonnet45(args?: ModelAttachArgs): this;
-  sonnet45think(args?: ModelAttachArgs): this;
-  haiku35(args?: ModelAttachArgs): this;
   haiku45(args?: ModelAttachArgs): this;
-  haiku45think(args?: ModelAttachArgs): this;
 
   // Google
   gemini25flash(args?: ModelAttachArgs): this;
@@ -327,10 +313,8 @@ 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;
-  grok41think(args?: ModelAttachArgs): this;
-  grok41(args?: ModelAttachArgs): this;
 
   // Multi-provider
   qwen3(args?: ModelAttachArgs): this;
@@ -338,10 +322,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;
@@ -352,7 +336,6 @@ export declare class ModelMix {
   deepseekV4Flash(args?: ModelAttachArgs): this;
   GLM51(args?: ModelAttachArgs): this;
   GLM52(args?: ModelAttachArgs): this;
-  GLM5(args?: ModelAttachArgs): this;
 
   addText(text: string, options?: RoleOptions): this;
   addTextFromFile(filePath: string, options?: RoleOptions): 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];
@@ -72,11 +73,8 @@ const MODEL_PRICING = {
     'claude-opus-4-8': [5.00, 25.00],
     'claude-opus-4-7': [5.00, 25.00],
     'claude-opus-4-6': [5.00, 25.00],
-    'claude-opus-4-1-20250805': [15.00, 75.00],
     'claude-sonnet-4-6': [3.00, 15.00],
     'claude-sonnet-4-5-20250929': [3.00, 15.00],
-    'claude-sonnet-4-20250514': [3.00, 15.00],
-    'claude-3-5-haiku-20241022': [0.80, 4.00],
     'claude-haiku-4-5-20251001': [1.00, 5.00],
     // Google
     'gemini-3.1-pro-preview':[2.00, 12.00],
@@ -91,10 +89,9 @@ 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],
-    'grok-4-1-fast-reasoning': [0.20, 0.50],
-    'grok-4-1-fast-non-reasoning': [0.20, 0.50],
     // Fireworks
     'accounts/fireworks/models/deepseek-v4-flash': [0.14, 0.28],
     'accounts/fireworks/models/deepseek-v4-pro': [1.74, 3.48],
@@ -110,12 +107,10 @@ const MODEL_PRICING = {
     'accounts/fireworks/models/qwen3p7-plus': [0.40, 1.60],
     'qwen/qwen3.7-plus': [0.32, 1.28],
     'qwen/qwen3.8-max': [2.00, 6.00],
-    'fireworks/glm-5': [1.00, 3.20],
     // MiniMax
     'MiniMax-M2.5': [0.30, 1.20],
     'MiniMax-M2.7': [0.30, 1.20],
     'MiniMax-M3': [0.30, 1.20],
-    'fireworks/minimax-m2p5': [0.30, 1.20],
     'minimax/minimax-m2.7': [0.30, 1.20],
     'minimax/minimax-m3': [0.30, 1.20],
     'MiniMaxAI/MiniMax-M3': [0.30, 1.20],
@@ -392,29 +387,9 @@ class ModelMix {
     fable5({ options = {}, config = {} } = {}) {
         return this.attach('claude-fable-5', new MixAnthropic({ options, config }));
     }
-    fable5think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.maxEffortThinkingOptions, ...options };
-        return this.attach('claude-fable-5', new MixAnthropic({ options, config }));
-    }
     opus5({ options = {}, config = {} } = {}) {
         return this.attach('claude-opus-5', new MixAnthropic({ options, config }));
     }
-    opus5think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.maxEffortThinkingOptions, ...options };
-        return this.attach('claude-opus-5', new MixAnthropic({ options, config }));
-    }
-    opus48think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-opus-4-8', new MixAnthropic({ options, config }));
-    }
-    opus47think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-opus-4-7', new MixAnthropic({ options, config }));
-    }    
-    opus46think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-opus-4-6', new MixAnthropic({ options, config }));
-    }
     opus48({ options = {}, config = {} } = {}) {
         return this.attach('claude-opus-4-8', new MixAnthropic({ options, config }));
     }
@@ -424,52 +399,18 @@ class ModelMix {
     opus46({ options = {}, config = {} } = {}) {
         return this.attach('claude-opus-4-6', new MixAnthropic({ options, config }));
     }
-    opus41({ options = {}, config = {} } = {}) {
-        return this.attach('claude-opus-4-1-20250805', new MixAnthropic({ options, config }));
-    }
-    opus41think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-opus-4-1-20250805', new MixAnthropic({ options, config }));
-    }
     sonnet5({ options = {}, config = {} } = {}) {
         return this.attach('claude-sonnet-5', new MixAnthropic({ options, config }));
     }
-    sonnet5think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-sonnet-5', new MixAnthropic({ options, config }));
-    }
-    sonnet4({ options = {}, config = {} } = {}) {
-        return this.attach('claude-sonnet-4-20250514', new MixAnthropic({ options, config }));
-    }
-    sonnet4think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-sonnet-4-20250514', new MixAnthropic({ options, config }));
-    }
     sonnet46({ options = {}, config = {} } = {}) {
         return this.attach('claude-sonnet-4-6', new MixAnthropic({ options, config }));
     }
-    sonnet46think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-sonnet-4-6', new MixAnthropic({ options, config }));
-    }
-
     sonnet45({ options = {}, config = {} } = {}) {
         return this.attach('claude-sonnet-4-5-20250929', new MixAnthropic({ options, config }));
     }
-    sonnet45think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-sonnet-4-5-20250929', new MixAnthropic({ options, config }));
-    }
-    haiku35({ options = {}, config = {} } = {}) {
-        return this.attach('claude-3-5-haiku-20241022', new MixAnthropic({ options, config }));
-    }
     haiku45({ options = {}, config = {} } = {}) {
         return this.attach('claude-haiku-4-5-20251001', new MixAnthropic({ options, config }));
     }
-    haiku45think({ options = {}, config = {} } = {}) {
-        options = { ...MixAnthropic.thinkingOptions, ...options };
-        return this.attach('claude-haiku-4-5-20251001', new MixAnthropic({ options, config }));
-    }
     gemini25flash({ options = {}, config = {} } = {}) {
         return this.attach('gemini-2.5-flash', new MixGoogle({ options, config }));
     }
@@ -510,17 +451,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 }));
-    }
-    grok41think({ options = {}, config = {} } = {}) {
-        return this.attach('grok-4-1-fast-reasoning', new MixGrok({ options, config }));
-    }
-    grok41({ options = {}, config = {} } = {}) {
-        return this.attach('grok-4-1-fast-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 } } = {}) {
@@ -556,7 +489,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 }));
@@ -577,7 +510,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 }));
@@ -593,7 +526,6 @@ class ModelMix {
     minimaxM25({ options = {}, config = {}, mix = { minimax: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.minimax) this.attach('MiniMax-M2.5', new MixMiniMax({ options, config }));
-        if (mix.fireworks) this.attach('fireworks/minimax-m2p5', new MixFireworks({ options, config }));
         return this;
     }
 
@@ -661,12 +593,6 @@ class ModelMix {
         return this;
     }
 
-    GLM5({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
-        mix = { ...this.mix, ...mix };
-        if (mix.fireworks) this.attach('fireworks/glm-5', new MixFireworks({ options, config }));
-        return this;
-    }
-
     addText(text, { role = "user" } = {}) {
         const content = [{
             type: "text",
@@ -1007,7 +933,7 @@ class ModelMix {
 
     async execute({ config = {}, options = {} } = {}) {
         if (!this.models || this.models.length === 0) {
-            throw new Error("No models specified. Use methods like .gpt5(), .sonnet4() first.");
+            throw new Error("No models specified. Use methods like .gpt5(), .sonnet46() first.");
         }
 
         return this.limiter.schedule(async () => {
@@ -1065,9 +991,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;
@@ -1077,7 +1011,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)}`);
@@ -1122,7 +1056,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);
@@ -1134,7 +1068,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;
                     }
@@ -2217,19 +2151,6 @@ class MixKimi extends MixOpenAI {
 
 class MixAnthropic extends MixCustom {
 
-    static thinkingOptions = {
-        thinking: {
-            "type": "enabled",
-            "budget_tokens": 1638
-        },
-        temperature: 1
-    };
-
-    static maxEffortThinkingOptions = {
-        output_config: { effort: 'max' },
-        thinking: { display: 'summarized' }
-    };
-
     /**
      * Opus 4.7+ and Claude 5 family reject sampling params (temperature/top_p/top_k).
      * See: https://platform.claude.com/docs/en/about-claude/models/migration-guide

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "4.6.15",
+  "version": "4.7.2",
   "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`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. `*think()` shorthands still win over unified `effort`.
+\* 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
 
@@ -122,21 +122,21 @@ ModelMix.new({ config: { effort: 80 } })
 `gpt52()` `gpt52chat()` `gpt51()` `gpt5()` `gpt5mini()` `gpt5nano()` `gpt45()` `gpt41()` `gpt41mini()` `gpt41nano()` `o3()` `o4mini()`
 
 ### Anthropic
-`fable5()` `opus5()` `opus48()` `opus47()` `opus46()` `opus41()` `sonnet5()` `sonnet46()` `sonnet45()` `sonnet4()` `haiku45()` `haiku35()`
+`fable5()` `opus5()` `opus48()` `opus47()` `opus46()` `sonnet5()` `sonnet46()` `sonnet45()` `haiku45()`
 
-Thinking variants: append `think` — e.g. `fable5think()` `opus5think()` `opus48think()` `opus47think()` `opus46think()` `sonnet5think()` `sonnet46think()` `sonnet45think()` `sonnet4think()` `opus41think()` `haiku45think()`
+Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.effort(100).opus5()`.
 
 ### Google
 `gemini3pro()` `gemini3flash()` `gemini36flash()` `gemini35flash()` `gemini25pro()` `gemini25flash()`
 
 ### Grok
-`grok45()` `grok43()` `grok420multiAgent()` `grok420()` `grok420think()` `grok41()` `grok41think()`
+`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 @@ Thinking variants: append `think` — e.g. `fable5think()` `opus5think()` `opus4
 `minimaxM25()` `minimaxM27()` `minimaxM3()`
 
 ### Fireworks
-`qwen36plus()` `qwen37plus()` `deepseekV4Flash()` `deepseekV4Pro()` `GLM5()`
+`qwen36plus()` `qwen37plus()` `deepseekV4Flash()` `deepseekV4Pro()` `kimiK26()`
 
 ### Cerebras
 `GLM46()`
@@ -154,7 +154,7 @@ Thinking variants: append `think` — e.g. `fable5think()` `opus5think()` `opus4
 `qwen38max()` `GLM45()`
 
 ### Multi-provider (auto-fallback across free/paid tiers)
-`hermes3()` `kimiK25think()`
+`hermes3()` `kimiK25()`
 
 ### Local
 `lmstudio()` — for LM Studio local models
@@ -286,7 +286,8 @@ const code = await ModelMix.new()
 
 ```javascript
 const raw = await ModelMix.new()
-    .sonnet45think()
+    .effort(100)
+    .sonnet45()
     .addText("Solve this step by step: 2+2*3")
     .raw();
 // raw.message, raw.think, raw.tokens, raw.toolCalls, raw.response
@@ -428,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());
@@ -451,7 +452,7 @@ const model = ModelMix.new({
         minimax: false,      // default: false
         fireworks: false     // default: false
     }
-}).kimiK25think();
+}).kimiK25();
 ```
 
 ## Agent Usage Rules
@@ -463,8 +464,7 @@ const model = ModelMix.new({
 - When using MCP tools or `addTool()`, set `max_history` to at least 3 — tool call/response pairs consume history slots.
 - Use `.json()` for structured output instead of parsing text manually. Use descriptor objects `{ description, required, enum, default, nullable }` for richer schema control.
 - Use `.message()` for simple text, `.raw()` when you need tokens/thinking/toolCalls.
-- For thinking models, append `think` to the method name (e.g. `sonnet45think()`).
-- For cross-provider reasoning intensity, use unified `effort` (`-1` or `0`–`100`) via `config.effort` or `.effort(n)` — never put it in `options`. Native fields win if already set.
+- For Anthropic thinking, use unified `effort` (`-1` or `0`–`100`) via `config.effort` or `.effort(n)` — e.g. `.effort(100).opus5()`. Never put `effort` in `options`. Native fields win if already set.
 - Template placeholders use `{key}` syntax in both system prompts and user messages.
 - The library uses CommonJS internally but supports ESM import via `{ ModelMix }`.
 - GPT-5+ models automatically use `max_completion_tokens` instead of `max_tokens`.

package/test/anthropic.test.js

@@ -12,15 +12,15 @@ describe('Anthropic Model Registration Tests', () => {
         expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
     });
 
-    it('should register Claude Fable 5 with max effort thinking', () => {
-        const model = ModelMix.new();
-        model.fable5think();
-
-        expect(model.models).to.have.length(1);
-        expect(model.models[0].key).to.equal('claude-fable-5');
-        expect(model.models[0].provider.options.output_config).to.deep.equal({ effort: 'max' });
-        expect(model.models[0].provider.options.thinking).to.deep.equal({ display: 'summarized' });
-        expect(model.models[0].provider.options).to.not.have.property('temperature');
+    it('should apply max effort thinking via .effort(100).fable5()', () => {
+        const model = ModelMix.new().effort(100).fable5();
+        const { applyUnifiedEffort } = require('../effort.js');
+
+        expect(model.config.effort).to.equal(100);
+        const options = { model: 'claude-fable-5' };
+        applyUnifiedEffort(options, model.config, 'anthropic', 'claude-fable-5');
+        expect(options.output_config).to.deep.equal({ effort: 'max' });
+        expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
     });
 
     it('should register Claude Opus 5', () => {
@@ -32,15 +32,15 @@ describe('Anthropic Model Registration Tests', () => {
         expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
     });
 
-    it('should register Claude Opus 5 with max effort thinking', () => {
-        const model = ModelMix.new();
-        model.opus5think();
+    it('should apply max effort thinking via .effort(100).opus5()', () => {
+        const model = ModelMix.new().effort(100).opus5();
+        const { applyUnifiedEffort } = require('../effort.js');
 
-        expect(model.models).to.have.length(1);
-        expect(model.models[0].key).to.equal('claude-opus-5');
-        expect(model.models[0].provider.options.output_config).to.deep.equal({ effort: 'max' });
-        expect(model.models[0].provider.options.thinking).to.deep.equal({ display: 'summarized' });
-        expect(model.models[0].provider.options).to.not.have.property('temperature');
+        expect(model.config.effort).to.equal(100);
+        const options = { model: 'claude-opus-5' };
+        applyUnifiedEffort(options, model.config, 'anthropic', 'claude-opus-5');
+        expect(options.output_config).to.deep.equal({ effort: 'max' });
+        expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
     });
 
     describe('Sampling params (temperature/top_p/top_k)', () => {
@@ -53,7 +53,6 @@ describe('Anthropic Model Registration Tests', () => {
             expect(MixAnthropic.rejectsSamplingParams('anthropic/claude-opus-5')).to.equal(true);
 
             expect(MixAnthropic.rejectsSamplingParams('claude-opus-4-6')).to.equal(false);
-            expect(MixAnthropic.rejectsSamplingParams('claude-opus-4-1-20250805')).to.equal(false);
             expect(MixAnthropic.rejectsSamplingParams('claude-sonnet-4-6')).to.equal(false);
             expect(MixAnthropic.rejectsSamplingParams('claude-haiku-4-5-20251001')).to.equal(false);
         });
@@ -143,16 +142,14 @@ describe('Anthropic Model Registration Tests', () => {
         expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
     });
 
-    it('should register Claude Opus 4.8 with thinking enabled', () => {
-        const model = ModelMix.new();
-        model.opus48think();
+    it('should apply adaptive thinking via .effort(100).opus48()', () => {
+        const model = ModelMix.new().effort(100).opus48();
+        const { applyUnifiedEffort } = require('../effort.js');
 
-        expect(model.models).to.have.length(1);
-        expect(model.models[0].key).to.equal('claude-opus-4-8');
-        expect(model.models[0].provider.options.thinking).to.deep.equal({
-            type: 'enabled',
-            budget_tokens: 1638
-        });
+        const options = { model: 'claude-opus-4-8' };
+        applyUnifiedEffort(options, model.config, 'anthropic', 'claude-opus-4-8');
+        expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
+        expect(options.output_config).to.deep.equal({ effort: 'max' });
     });
 
     it('should register Claude Sonnet 5', () => {
@@ -164,16 +161,14 @@ describe('Anthropic Model Registration Tests', () => {
         expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
     });
 
-    it('should register Claude Sonnet 5 with thinking enabled', () => {
-        const model = ModelMix.new();
-        model.sonnet5think();
+    it('should apply adaptive thinking via .effort(100).sonnet5()', () => {
+        const model = ModelMix.new().effort(100).sonnet5();
+        const { applyUnifiedEffort } = require('../effort.js');
 
-        expect(model.models).to.have.length(1);
-        expect(model.models[0].key).to.equal('claude-sonnet-5');
-        expect(model.models[0].provider.options.thinking).to.deep.equal({
-            type: 'enabled',
-            budget_tokens: 1638
-        });
+        const options = { model: 'claude-sonnet-5' };
+        applyUnifiedEffort(options, model.config, 'anthropic', 'claude-sonnet-5');
+        expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
+        expect(options.output_config).to.deep.equal({ effort: 'max' });
     });
 
     describe('Thinking block extraction', () => {

package/test/effort.test.js

@@ -81,9 +81,31 @@ describe('Unified effort scale', () => {
             expect(mapEffort('openai', 10, 'gpt-oss-120b')).to.deep.equal({ reasoning_effort: 'low' });
         });
 
-        it('maps Anthropic effort to output_config.effort', () => {
-            expect(mapEffort('anthropic', 10)).to.deep.equal({ output_config: { effort: 'low' } });
-            expect(mapEffort('anthropic', 90)).to.deep.equal({ output_config: { effort: 'max' } });
+        it('maps Anthropic adaptive models to thinking + output_config.effort', () => {
+            expect(mapEffort('anthropic', 10, 'claude-opus-5')).to.deep.equal({
+                thinking: { type: 'adaptive', display: 'summarized' },
+                output_config: { effort: 'low' }
+            });
+            expect(mapEffort('anthropic', 90, 'claude-fable-5')).to.deep.equal({
+                thinking: { type: 'adaptive', display: 'summarized' },
+                output_config: { effort: 'max' }
+            });
+            expect(mapEffort('anthropic', 50, 'claude-sonnet-4-6')).to.deep.equal({
+                thinking: { type: 'adaptive', display: 'summarized' },
+                output_config: { effort: 'high' }
+            });
+        });
+
+        it('maps Anthropic manual models to thinking.type=enabled + budget_tokens', () => {
+            expect(mapEffort('anthropic', 50, 'claude-sonnet-4-5-20250929')).to.deep.equal({
+                thinking: { type: 'enabled', budget_tokens: 8192 }
+            });
+            expect(mapEffort('anthropic', 100, 'claude-haiku-4-5-20251001')).to.deep.equal({
+                thinking: { type: 'enabled', budget_tokens: 16384 }
+            });
+            expect(mapEffort('anthropic', 0, 'claude-sonnet-4-5-20250929')).to.deep.equal({
+                thinking: { type: 'enabled', budget_tokens: 1024 }
+            });
         });
 
         it('maps Anthropic adaptive to thinking.type=adaptive', () => {
@@ -223,6 +245,14 @@ describe('Unified effort scale', () => {
             const options = {};
             applyUnifiedEffort(options, { effort: 90 }, 'anthropic', 'claude-opus-5');
             expect(options.output_config).to.deep.equal({ effort: 'max' });
+            expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
+        });
+
+        it('applies Anthropic manual thinking for Sonnet 4.5', () => {
+            const options = {};
+            applyUnifiedEffort(options, { effort: 50 }, 'anthropic', 'claude-sonnet-4-5-20250929');
+            expect(options.thinking).to.deep.equal({ type: 'enabled', budget_tokens: 8192 });
+            expect(options.output_config).to.equal(undefined);
         });
 
         it('skips Anthropic mapping when output_config.effort is set', () => {
@@ -306,16 +336,29 @@ describe('Unified effort scale', () => {
             expect(request.reasoning).to.deep.equal({ effort: 'none' });
         });
 
-        it('Anthropic *think() native effort wins over config.effort', () => {
-            const model = ModelMix.new({ config: { effort: 20 } }).opus5think();
-            expect(model.models[0].provider.options.output_config.effort).to.equal('max');
+        it('Anthropic config.effort maps through .effort().opus5()', () => {
+            const model = ModelMix.new().effort(100).opus5();
+            expect(model.config.effort).to.equal(100);
 
             const options = {
                 ...model.models[0].provider.options,
                 model: 'claude-opus-5'
             };
-            applyUnifiedEffort(options, { effort: 20 }, 'anthropic', 'claude-opus-5');
+            applyUnifiedEffort(options, model.config, 'anthropic', 'claude-opus-5');
             expect(options.output_config.effort).to.equal('max');
+            expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
+        });
+
+        it('Anthropic .effort(50).sonnet45() maps to manual budget_tokens', () => {
+            const model = ModelMix.new().effort(50).sonnet45();
+            expect(model.config.effort).to.equal(50);
+
+            const options = {
+                ...model.models[0].provider.options,
+                model: 'claude-sonnet-4-5-20250929'
+            };
+            applyUnifiedEffort(options, model.config, 'anthropic', 'claude-sonnet-4-5-20250929');
+            expect(options.thinking).to.deep.equal({ type: 'enabled', budget_tokens: 8192 });
         });
 
         it('MixGoogle generationConfig includes thinkingConfig from options', async () => {

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/history.test.js

@@ -522,7 +522,7 @@ describe('Conversation History Tests', () => {
             const model = ModelMix.new({
                 config: { debug: false, max_history: 10 }
             });
-            model.opus5think();
+            model.effort(100).opus5();
 
             model.addText('2+2?');
             nock('https://api.anthropic.com')

package/test/live.test.js

@@ -98,7 +98,7 @@ describe('Live Integration Tests', function () {
         });
 
         it('should return structured JSON with Sonnet 4.6 thinking', async function () {
-            const model = ModelMix.new(setup).sonnet46think();
+            const model = ModelMix.new(setup).effort(100).sonnet46();
 
             model.addText('Generate information about a fictional city.');
 
@@ -192,22 +192,10 @@ describe('Live Integration Tests', function () {
             expect(response.toLowerCase()).to.include('gptoss test successful');
         });
 
-        it('should work with Grok 4.1 model', async function () {
-            const model = ModelMix.new(setup).grok41();
-
-            model.addText('Say "grok41 test successful" and nothing else.');
-
-            const response = await model.message();
-            console.log(`Grok 4.1 response: ${response}`);
-
-            expect(response).to.be.a('string');
-            expect(response.toLowerCase()).to.include('grok41 test successful');
-        });
-
         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) {
@@ -254,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.');
 
@@ -275,8 +263,8 @@ describe('Live Integration Tests', function () {
             expect(result.features).to.be.an('array');
         });
 
-        it('should return structured JSON with Grok3Mini', async function () {
-            const model = ModelMix.new(setup).grok41();
+        it('should return structured JSON with Grok 4.3', async function () {
+            const model = ModelMix.new(setup).grok43();
 
             model.addText('Generate information about a fictional technology.');
 
@@ -287,7 +275,7 @@ describe('Live Integration Tests', function () {
                 power: "1000 qubits"
             });
 
-            console.log(`Grok3Mini JSON result:`, result);
+            console.log(`Grok 4.3 JSON result:`, result);
 
             expect(result).to.be.an('object');
             expect(result).to.have.property('name');