modelmix 4.6.14 → 4.7.0

package/README.md

@@ -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 Anthropic `*think()` shorthands are removed — use `.effort(100).opus5()` (or any 0–100 / `-1`) instead.
 
 ## 🔧 Model Context Protocol (MCP) Integration
 
@@ -177,23 +179,25 @@ 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]       |
 | `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]       |
-| `grok41[think]()`   | Grok       | grok-4-1-fast                | [\$0.20 / \$0.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]      |
 | `deepseekV4Flash()` | Fireworks  | models/deepseek-v4-flash     | [\$0.14 / \$0.28][10]      |
 | `deepseekV4Pro()`   | Fireworks  | models/deepseek-v4-pro       | [\$1.74 / \$3.48][10]      |
 | `GLM52()`           | Together   | zai-org/GLM-5.2              | [\$1.40 / \$4.40][7]       |
@@ -218,10 +222,12 @@ Here's a comprehensive list of available methods:
 [9]: https://platform.minimax.io/docs/api-reference/anthropic-api-compatible-cache#supported-models-and-pricing "MiniMax Pricing"
 [10]: https://fireworks.ai/pricing#serverless-pricing "Fireworks Pricing"
 [11]: https://platform.kimi.ai/docs/guide/kimi-k3-pricing "Kimi K3 Pricing"
+[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.  
 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 } })`.
 For OpenRouter instead of Moonshot's native API, use `kimiK3({ mix: { moonshot: false, openrouter: true } })`.
 
 ```javascript

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

@@ -170,6 +170,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;
@@ -282,9 +338,7 @@ function mapEffort(providerFamily, effort, modelKey) {
     }
 
     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') {
@@ -357,6 +411,7 @@ module.exports = {
     resolveProviderFamily,
     isDeepSeekV4,
     isMiniMax,
+    usesAnthropicAdaptiveThinking,
     levelFromBands,
     pickNearestLevel,
     OPENAI_BANDS,
@@ -367,4 +422,5 @@ module.exports = {
     ANTHROPIC_LEVELS,
     GEMINI_LEVELS,
     DEEPSEEK_LEVELS,
+    ANTHROPIC_MANUAL_BUDGET_MAX,
 };

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;
@@ -324,16 +310,17 @@ export declare class ModelMix {
   sonar(args?: ModelAttachArgs): this;
 
   // Grok
+  grok45(args?: ModelAttachArgs): this;
   grok43(args?: ModelAttachArgs): this;
   grok420multiAgent(args?: ModelAttachArgs): this;
   grok420think(args?: ModelAttachArgs): this;
   grok420(args?: ModelAttachArgs): this;
-  grok41think(args?: ModelAttachArgs): this;
-  grok41(args?: ModelAttachArgs): this;
 
   // Multi-provider
   qwen3(args?: ModelAttachArgs): this;
   qwen36plus(args?: ModelAttachArgs): this;
+  qwen37plus(args?: ModelAttachArgs): this;
+  qwen38max(args?: ModelAttachArgs): this;
   hermes3(args?: ModelAttachArgs): this;
   kimiK26think(args?: ModelAttachArgs): this;
   kimiK27Code(args?: ModelAttachArgs): this;
@@ -349,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

@@ -72,11 +72,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],
@@ -88,12 +85,11 @@ const MODEL_PRICING = {
     'gemini-2.5-flash': [0.30, 2.50],
     'gemini-3.1-flash-lite-preview': [0.25, 1.50],
     // Grok
+    '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-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],
@@ -106,12 +102,13 @@ const MODEL_PRICING = {
     'accounts/fireworks/models/kimi-k2p5': [0.50, 2.80],
     'accounts/fireworks/models/qwen3p6-plus': [0.50, 3.00],
     'Qwen/Qwen3.6-Plus': [0.50, 3.00],
-    'fireworks/glm-5': [1.00, 3.20],
+    '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],
     // 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],
@@ -388,29 +385,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 }));
     }
@@ -420,52 +397,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 }));
     }
@@ -497,6 +440,9 @@ class ModelMix {
         return this.attach('sonar', new MixPerplexity({ options, config }));
     }
 
+    grok45({ options = {}, config = {} } = {}) {
+        return this.attach('grok-4.5', new MixGrok({ options, config }));
+    }
     grok43({ options = {}, config = {} } = {}) {
         return this.attach('grok-4.3', new MixGrok({ options, config }));
     }
@@ -509,12 +455,6 @@ class ModelMix {
     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 }));
-    }
 
     qwen3({ options = {}, config = {}, mix = { together: true, cerebras: false } } = {}) {
         if (mix.together) this.attach('Qwen/Qwen3-235B-A22B-fp8-tput', new MixTogether({ options, config }));
@@ -527,7 +467,20 @@ class ModelMix {
         if (mix.fireworks) this.attach('accounts/fireworks/models/qwen3p6-plus', new MixFireworks({ options, config }));
         if (mix.together) this.attach('Qwen/Qwen3.6-Plus', new MixTogether({ options, config }));
         return this;
-    } 
+    }
+
+    qwen37plus({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
+        mix = { ...this.mix, ...mix };
+        if (mix.fireworks) this.attach('accounts/fireworks/models/qwen3p7-plus', new MixFireworks({ options, config }));
+        if (mix.openrouter) this.attach('qwen/qwen3.7-plus', new MixOpenRouter({ options, config }));
+        return this;
+    }
+
+    qwen38max({ options = {}, config = {}, mix = { openrouter: true } } = {}) {
+        mix = { ...this.mix, ...mix };
+        if (mix.openrouter) this.attach('qwen/qwen3.8-max', new MixOpenRouter({ options, config }));
+        return this;
+    }
 
     hermes3({ options = {}, config = {}, mix = {} } = {}) {
         mix = { ...this.mix, ...mix };
@@ -573,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;
     }
 
@@ -641,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",
@@ -987,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 () => {
@@ -2197,19 +2143,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.14",
+  "version": "4.7.0",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",

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 Anthropic `*think()` methods are removed — use `.effort(n).<model>()`.
 
 ## Available Model Shorthands
 
@@ -122,15 +122,15 @@ 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
-`grok43()` `grok420multiAgent()` `grok420()` `grok420think()` `grok41()` `grok41think()`
+`grok45()` `grok43()` `grok420multiAgent()` `grok420()` `grok420think()`
 
 ### Perplexity
 `sonar()` `sonarPro()`
@@ -145,13 +145,13 @@ Thinking variants: append `think` — e.g. `fable5think()` `opus5think()` `opus4
 `minimaxM25()` `minimaxM27()` `minimaxM3()`
 
 ### Fireworks
-`deepseekV4Flash()` `deepseekV4Pro()` `GLM5()`
+`qwen36plus()` `qwen37plus()` `deepseekV4Flash()` `deepseekV4Pro()`
 
 ### Cerebras
 `GLM46()`
 
 ### OpenRouter
-`GLM45()`
+`qwen38max()` `GLM45()`
 
 ### Multi-provider (auto-fallback across free/paid tiers)
 `hermes3()` `kimiK25think()`
@@ -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
@@ -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

@@ -3,6 +3,7 @@ const { ModelMix } = require('../index.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' },

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,18 +192,6 @@ 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' },
@@ -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');

package/test/qwen.test.js

@@ -17,4 +17,36 @@ describe('Qwen Model Registration Tests', () => {
         expect(model.models).to.have.length(1);
         expect(model.models[0].key).to.equal('Qwen/Qwen3.6-Plus');
     });
+
+    it('should register Fireworks Qwen 3.7 Plus by default', () => {
+        const model = ModelMix.new();
+        model.qwen37plus({ mix: { fireworks: true, openrouter: false } });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('accounts/fireworks/models/qwen3p7-plus');
+        expect(ModelMix.calculateCost('accounts/fireworks/models/qwen3p7-plus', {
+            input: 1_000_000,
+            output: 1_000_000
+        })).to.equal(2.00);
+    });
+
+    it('should register OpenRouter Qwen 3.7 Plus when openrouter mix is enabled', () => {
+        const model = ModelMix.new();
+        model.qwen37plus({ mix: { fireworks: false, openrouter: true } });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('qwen/qwen3.7-plus');
+    });
+
+    it('should register OpenRouter Qwen 3.8 Max by default', () => {
+        const model = ModelMix.new();
+        model.qwen38max();
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('qwen/qwen3.8-max');
+        expect(ModelMix.calculateCost('qwen/qwen3.8-max', {
+            input: 1_000_000,
+            output: 1_000_000
+        })).to.equal(8.00);
+    });
 });