modelmix 4.6.6 → 4.6.8

package/index.js

@@ -20,6 +20,11 @@ const {
     fetchBinaryResponse,
     fetchStreamResponse
 } = require('./http-client');
+const {
+    normalizeEffort,
+    applyUnifiedEffort,
+    resolveProviderFamily
+} = require('./effort');
 
 const DEFAULT_RETRYABLE_STATUS_CODES = [408, 425, 429, 500, 502, 503, 504, 529];
 
@@ -90,9 +95,11 @@ const MODEL_PRICING = {
     'grok-4-1-fast-reasoning': [0.20, 0.50],
     'grok-4-1-fast-non-reasoning': [0.20, 0.50],
     // Fireworks
-    'accounts/fireworks/models/deepseek-v3p2': [0.56, 1.68],
+    'accounts/fireworks/models/deepseek-v4-flash': [0.14, 0.28],
     'accounts/fireworks/models/deepseek-v4-pro': [1.74, 3.48],
+    'deepseek-ai/DeepSeek-V4-Flash': [0.14, 0.28],
     'deepseek-ai/DeepSeek-V4-Pro': [2.10, 4.40],
+    'deepseek/deepseek-v4-flash': [0.09, 0.18],
     'accounts/fireworks/models/glm-4p7': [0.55, 2.19],
     'accounts/fireworks/models/glm-5p1': [1.05, 3.50],
     'zai-org/GLM-5.2': [1.40, 4.40],
@@ -123,13 +130,9 @@ const MODEL_PRICING = {
     // Kimi K3
     'kimi-k3': [3.00, 15.00],
     'moonshotai/kimi-k3': [3.00, 15.00],
-    // DeepSeek V3.2 (OpenRouter)
-    'deepseek/deepseek-v3.2': [0.56, 1.68],
     // GLM 4.7 (OpenRouter/Cerebras)
     'z-ai/glm-4.7': [0.55, 2.19],
     'zai-glm-4.7': [0.55, 2.19],
-    // DeepSeek R1 (OpenRouter free)
-    'deepseek/deepseek-r1-0528:free': [0, 0],
 };
 
 class ModelMix {
@@ -168,6 +171,10 @@ class ModelMix {
             },
             roundRobin: false, // false=fallback mode, true=round robin rotation
             ...config
+        };
+        // Unified effort is ModelMix policy (config.effort / .effort()), not a native option.
+        if (this.config.effort !== undefined && this.config.effort !== null) {
+            this.config.effort = normalizeEffort(this.config.effort);
         }
         const freeMix = { openrouter: true, cerebras: true, groq: true, together: false, lambda: false };
         this.mix = { ...freeMix, ...mix };
@@ -181,12 +188,26 @@ class ModelMix {
         return this;
     }
 
+    /**
+     * Set unified reasoning effort: -1 (adaptive) or 0..100.
+     * Stored in config.effort; mapped to provider-native fields at request time
+     * unless a native effort control is already set (native wins).
+     */
+    effort(value) {
+        this.config.effort = normalizeEffort(value);
+        return this;
+    }
+
     static new({ options = {}, config = {}, mix = {} } = {}) {
         return new ModelMix({ options, config, mix });
     }
 
     new({ options = {}, config = {}, mix = {} } = {}) {
-        const instance = new ModelMix({ options: { ...this.options, ...options }, config: { ...this.config, ...config }, mix: { ...this.mix, ...mix } });
+        const instance = new ModelMix({
+            options: { ...this.options, ...options },
+            config: { ...this.config, ...config },
+            mix: { ...this.mix, ...mix }
+        });
         instance.models = this.models; // Share models array for round-robin rotation
         return instance;
     }
@@ -508,15 +529,6 @@ class ModelMix {
         return this;
     } 
 
-    deepseekR1({ options = {}, config = {}, mix = {} } = {}) {
-        mix = { ...this.mix, ...mix };
-        if (mix.groq) this.attach('deepseek-r1-distill-llama-70b', new MixGroq({ options, config }));
-        if (mix.together) this.attach('deepseek-ai/DeepSeek-R1', new MixTogether({ options, config }));
-        if (mix.cerebras) this.attach('deepseek-r1-distill-llama-70b', new MixCerebras({ options, config }));
-        if (mix.openrouter) this.attach('deepseek/deepseek-r1-0528:free', new MixOpenRouter({ options, config }));
-        return this;
-    }
-
     hermes3({ options = {}, config = {}, mix = {} } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.lambda) this.attach('Hermes-3-Llama-3.1-405B-FP8', new MixLambda({ options, config }));
@@ -576,8 +588,8 @@ class ModelMix {
 
     minimaxM3({ options = {}, config = {}, mix = { minimax: true, openrouter: false } } = {}) {
         mix = { ...this.mix, ...mix };
-        if (mix.minimax) this.attach('MiniMax-M3', new MixMiniMax({ options, config }));
         if (mix.openrouter) this.attach('minimax/minimax-m3', new MixOpenRouter({ options, config }));
+        if (mix.minimax) this.attach('MiniMax-M3', new MixMiniMax({ options, config }));
         if (mix.together) this.attach('MiniMaxAI/MiniMax-M3', new MixTogether({ options, config }));
         return this;
     }
@@ -605,11 +617,14 @@ class ModelMix {
         return this;
     }
 
-    deepseekV4Flash({ options = {}, config = {}, mix = { nvidia: true } } = {}) {
+    deepseekV4Flash({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.nvidia) this.attach('deepseek-ai/deepseek-v4-flash', new MixNVIDIA({ options, config }));
+        if (mix.fireworks) this.attach('accounts/fireworks/models/deepseek-v4-flash', new MixFireworks({ options, config }));
+        if (mix.openrouter) this.attach('deepseek/deepseek-v4-flash', new MixOpenRouter({ options, config }));
+        if (mix.together) this.attach('deepseek-ai/DeepSeek-V4-Flash', new MixTogether({ options, config }));
         return this;
-    }    
+    }
 
     GLM51({ options = {}, config = {}, mix = { fireworks: true } } = {}) {
         mix = { ...this.mix, ...mix };
@@ -887,13 +902,21 @@ class ModelMix {
         return input;
     }
 
+    static hasToolInteraction(message) {
+        if (!message) return false;
+        if (message.role === 'tool' || message.tool_calls || message.tool_call_id) return true;
+        // Anthropic-native assistant turns store tool_use blocks in content (no tool_calls).
+        if (message.role === 'assistant' && Array.isArray(message.content)) {
+            return message.content.some(block => block?.type === 'tool_use');
+        }
+        return false;
+    }
+
     groupByRoles(messages) {
         return messages.reduce((acc, currentMessage, index) => {
             // Don't group tool messages or assistant messages with tool_calls
             // Each tool response must be separate with its own tool_call_id
-            const shouldNotGroup = currentMessage.role === 'tool' ||
-                currentMessage.tool_calls ||
-                currentMessage.tool_call_id;
+            const shouldNotGroup = ModelMix.hasToolInteraction(currentMessage);
 
             if (index === 0 || currentMessage.role !== messages[index - 1].role || shouldNotGroup) {
                 // acc.push({
@@ -939,7 +962,7 @@ class ModelMix {
             // backtrack to include the full sequence (user → assistant/tool_calls → tool results)
             while (sliceStart > 0 && sliceStart < this.messages.length) {
                 const msg = this.messages[sliceStart];
-                if (msg.role === 'tool' || (msg.role === 'assistant' && msg.tool_calls)) {
+                if (ModelMix.hasToolInteraction(msg)) {
                     sliceStart--;
                 } else {
                     break;
@@ -1030,6 +1053,10 @@ class ModelMix {
                     }
                 };
 
+                // Unified effort → native provider fields (skipped if native already set)
+                const providerFamily = resolveProviderFamily(providerInstance);
+                applyUnifiedEffort(currentOptions, currentConfig, providerFamily, currentModelKey);
+
                 if (currentConfig.debug >= 1) {
                     const isPrimary = i === 0;
                     const prefix = isPrimary ? '→' : '↻';
@@ -1108,7 +1135,8 @@ class ModelMix {
                                 this.messages.push({
                                     role: "assistant", content: [{
                                         type: "thinking",
-                                        thinking: result.think,
+                                        // Empty string is valid (Anthropic display: "omitted").
+                                        thinking: result.think ?? '',
                                         signature: result.signature
                                     }]
                                 });
@@ -1184,7 +1212,8 @@ class ModelMix {
                             this.messages.push({
                                 role: "assistant", content: [{
                                     type: "thinking",
-                                    thinking: result.think,
+                                    // Empty string is valid (Anthropic display: "omitted").
+                                    thinking: result.think ?? '',
                                     signature: result.signature
                                 }, {
                                     type: "text",
@@ -2229,10 +2258,10 @@ class MixAnthropic extends MixCustom {
         const filteredMessages = [];
         for (let i = 0; i < messages.length; i++) {
             if (messages[i].role === 'tool') {
-                // Check if there's a preceding assistant message with tool_calls
+                // Preceding assistant may use OpenAI tool_calls or Anthropic tool_use blocks.
                 let foundToolCall = false;
                 for (let j = i - 1; j >= 0; j--) {
-                    if (messages[j].role === 'assistant' && messages[j].tool_calls) {
+                    if (ModelMix.hasToolInteraction(messages[j]) && messages[j].role === 'assistant') {
                         foundToolCall = true;
                         break;
                     }
@@ -2356,12 +2385,22 @@ class MixAnthropic extends MixCustom {
         throw new Error(`Anthropic content blocks are missing .text (stop_reason: ${stopReason ?? 'unknown'}, content_types: ${contentTypes}).`);
     }
 
+    static extractThinkingBlock(data) {
+        const content = Array.isArray(data?.content) ? data.content : [];
+        return content.find(block => block?.type === 'thinking') || null;
+    }
+
     static extractThink(data) {
-        return data.content[0]?.thinking || null;
+        const block = MixAnthropic.extractThinkingBlock(data);
+        // Preserve empty string: display "omitted" returns thinking: "" with a signature.
+        return typeof block?.thinking === 'string' ? block.thinking : null;
     }
 
     static extractSignature(data) {
-        return data.content[0]?.signature || null;
+        const block = MixAnthropic.extractThinkingBlock(data);
+        return typeof block?.signature === 'string' && block.signature
+            ? block.signature
+            : null;
     }
 
     static extractTokens(data) {
@@ -2383,13 +2422,18 @@ class MixAnthropic extends MixCustom {
     }
 
     processResponse(response) {
+        const data = response.data;
         return {
-            message: MixAnthropic.extractMessage(response.data),
-            think: MixAnthropic.extractThink(response.data),
-            toolCalls: MixAnthropic.extractToolCalls(response.data),
-            tokens: MixAnthropic.extractTokens(response.data),
-            response: response.data,
-            signature: MixAnthropic.extractSignature(response.data)
+            message: MixAnthropic.extractMessage(data),
+            think: MixAnthropic.extractThink(data),
+            toolCalls: MixAnthropic.extractToolCalls(data),
+            tokens: MixAnthropic.extractTokens(data),
+            response: data,
+            signature: MixAnthropic.extractSignature(data),
+            // Replay Anthropic content blocks verbatim (including empty thinking).
+            assistantMessage: Array.isArray(data?.content)
+                ? { role: 'assistant', content: data.content }
+                : undefined
         }
     }
 
@@ -2867,6 +2911,19 @@ class MixGoogle extends MixCustom {
             generationConfig.topP = options.top_p;
         }
 
+        // Thinking / effort (from unified config.effort or native options)
+        if (options.thinkingConfig) {
+            generationConfig.thinkingConfig = options.thinkingConfig;
+        } else if (options.thinkingLevel != null || options.thinkingBudget != null) {
+            generationConfig.thinkingConfig = {};
+            if (options.thinkingLevel != null) {
+                generationConfig.thinkingConfig.thinkingLevel = options.thinkingLevel;
+            }
+            if (options.thinkingBudget != null) {
+                generationConfig.thinkingConfig.thinkingBudget = options.thinkingBudget;
+            }
+        }
+
         // Gemini does not support responseMimeType when function calling is used
         const hasTools = options.tools && options.tools.length > 0 &&
             options.tools.some(t => t.functionDeclarations && t.functionDeclarations.length > 0);
@@ -3003,4 +3060,4 @@ class MixGoogle extends MixCustom {
     }
 }
 
-module.exports = { MixCustom, ModelMix, MixAnthropic, MixKimi, MixMiniMax, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA };
+module.exports = { MixCustom, ModelMix, MixAnthropic, MixKimi, MixMiniMax, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenAIWebSocket, MixOpenRouter, MixPerplexity, MixOllama, MixLMStudio, MixGroq, MixTogether, MixGrok, MixCerebras, MixGoogle, MixFireworks, MixNVIDIA, normalizeEffort, applyUnifiedEffort, resolveProviderFamily };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "4.6.6",
+  "version": "4.6.8",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "repository": {
@@ -71,6 +71,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 --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"
   }
 }

package/skills/modelmix/SKILL.md

@@ -29,6 +29,7 @@ Do NOT use for:
 - [Installation](#installation)
 - [Creating an instance](#creating-an-instance)
 - [Attaching models](#attaching-models)
+- [Unified effort](#unified-effort)
 - [Get a text response](#get-a-text-response)
 - [Get structured JSON](#get-structured-json)
 - [Stream a response](#stream-a-response)
@@ -71,7 +72,8 @@ const model = ModelMix.new({
         system: "You are a helpful assistant.",
         max_history: 5,   // -1 = unlimited, 0 = none (default), N = keep last N
         debug: 0,          // 0=silent, 1=minimal, 2=summary, 3=full, 4=verbose
-        roundRobin: false  // false=fallback, true=rotate models
+        roundRobin: false, // false=fallback, true=rotate models
+        effort: 50         // unified 0..100, or -1 adaptive
     }
 });
 ```
@@ -90,6 +92,31 @@ const model = ModelMix.new()
 
 If `sonnet46` fails, it automatically tries `gpt52`, then `gemini3flash`.
 
+### Unified effort
+
+Provider-agnostic reasoning intensity. **Not** an `options` field — use `config.effort` or `.effort(n)`.
+
+```javascript
+ModelMix.new({ config: { effort: 40 } }).sonnet46().addText('Plan this refactor').message();
+ModelMix.new().deepseekV4Flash({ config: { effort: 100 } }).addText('...').message();
+ModelMix.new().effort(-1).minimaxM3().addText('Quick question').message();
+
+// Native provider fields win when already set
+ModelMix.new({ config: { effort: 80 } })
+  .gpt52({ options: { reasoning_effort: 'none' } }) // stays none
+```
+
+| Value | OpenAI | Anthropic | Gemini 3+ | DeepSeek V4 | MiniMax M3 |
+|------|--------|-----------|-----------|-------------|------------|
+| 0–19 | `none` | `low` | `minimal` (0–24) | thinking `disabled` | `thinking.disabled` |
+| 20–39 | `low` | `medium` | `low` (25–49) | `low` + thinking on | `thinking.adaptive` |
+| 40–59 | `medium` | `high` | `medium` (50–74) | `high` + thinking on | `thinking.adaptive` |
+| 60–79 | `high` | `xhigh` | `high` (75–100) | `high` + thinking on | `thinking.adaptive` |
+| 80–100 | `xhigh` | `max` | — | `max` + thinking on | `thinking.adaptive` |
+| `-1` | no-op (no adaptive API) | `thinking.type=adaptive` | `thinkingBudget: -1` | no-op (no adaptive API) | `thinking.type=adaptive` |
+
+Gemini 2.5 maps 0–100 to numeric `thinkingBudget`. `-1` sets the provider adaptive/dynamic control when available; otherwise no-op. Levels clamp to what each model supports. `*think()` shorthands that set native effort still win over unified `effort`.
+
 ## Available Model Shorthands
 
 ### OpenAI
@@ -119,7 +146,7 @@ Thinking variants: append `think` — e.g. `fable5think()` `opus5think()` `opus4
 `minimaxM25()` `minimaxM27()` `minimaxM3()`
 
 ### Fireworks
-`deepseekV32()` `GLM5()` `GLM47()`
+`deepseekV4Flash()` `deepseekV4Pro()` `GLM5()` `GLM47()`
 
 ### Cerebras
 `GLM46()`
@@ -128,7 +155,7 @@ Thinking variants: append `think` — e.g. `fable5think()` `opus5think()` `opus4
 `GLM45()`
 
 ### Multi-provider (auto-fallback across free/paid tiers)
-`deepseekR1()` `hermes3()` `kimiK25think()` `GLM47()`
+`hermes3()` `kimiK25think()` `GLM47()`
 
 ### Local
 `lmstudio()` — for LM Studio local models
@@ -403,7 +430,6 @@ For full debug output, also set: `DEBUG=ModelMix* node script.js`
 const model = ModelMix.new()
     .gptOss()
     .kimiK25think()
-    .deepseekR1()
     .hermes3()
     .addText("What is the capital of France?");
 console.log(await model.message());
@@ -426,7 +452,7 @@ const model = ModelMix.new({
         minimax: false,      // default: false
         fireworks: false     // default: false
     }
-}).deepseekR1();
+}).GLM47();
 ```
 
 ## Agent Usage Rules
@@ -439,6 +465,7 @@ const model = ModelMix.new({
 - 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.
 - 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

@@ -81,4 +81,110 @@ describe('Anthropic Model Registration Tests', () => {
             budget_tokens: 1638
         });
     });
+
+    describe('Thinking block extraction', () => {
+        it('should preserve empty thinking text from display omitted', () => {
+            const data = {
+                content: [{
+                    type: 'thinking',
+                    thinking: '',
+                    signature: 'sig-omitted'
+                }, {
+                    type: 'text',
+                    text: 'Hello'
+                }]
+            };
+
+            expect(MixAnthropic.extractThink(data)).to.equal('');
+            expect(MixAnthropic.extractSignature(data)).to.equal('sig-omitted');
+        });
+
+        it('should extract summarized thinking text', () => {
+            const data = {
+                content: [{
+                    type: 'thinking',
+                    thinking: 'Step by step...',
+                    signature: 'sig-summarized'
+                }, {
+                    type: 'text',
+                    text: 'Answer'
+                }]
+            };
+
+            expect(MixAnthropic.extractThink(data)).to.equal('Step by step...');
+            expect(MixAnthropic.extractSignature(data)).to.equal('sig-summarized');
+        });
+
+        it('should return null when thinking block is missing', () => {
+            const data = {
+                content: [{ type: 'text', text: 'Hello' }]
+            };
+
+            expect(MixAnthropic.extractThink(data)).to.equal(null);
+            expect(MixAnthropic.extractSignature(data)).to.equal(null);
+        });
+
+        it('should persist Anthropic content blocks as assistantMessage', () => {
+            const content = [{
+                type: 'thinking',
+                thinking: '',
+                signature: 'sig-omitted'
+            }, {
+                type: 'text',
+                text: 'Hello'
+            }];
+            const provider = new MixAnthropic();
+            const result = provider.processResponse({ data: { content, usage: {} } });
+
+            expect(result.think).to.equal('');
+            expect(result.signature).to.equal('sig-omitted');
+            expect(result.assistantMessage).to.deep.equal({
+                role: 'assistant',
+                content
+            });
+        });
+
+        it('should keep tool_result after native Anthropic tool_use assistantMessage', () => {
+            // processResponse stores assistant content as Anthropic blocks (tool_use),
+            // not OpenAI-style tool_calls. convertMessages must still pair tool results.
+            const toolUseId = 'toolu_01TestToolUseId';
+            const converted = MixAnthropic.convertMessages([
+                { role: 'user', content: [{ type: 'text', text: 'What time is it?' }] },
+                {
+                    role: 'assistant',
+                    content: [{
+                        type: 'tool_use',
+                        id: toolUseId,
+                        name: 'get_current_time',
+                        input: {}
+                    }]
+                },
+                {
+                    role: 'tool',
+                    tool_call_id: toolUseId,
+                    name: 'get_current_time',
+                    content: '2026-07-30T12:00:00Z'
+                }
+            ]);
+
+            expect(converted).to.have.length(3);
+            expect(converted[1]).to.deep.equal({
+                role: 'assistant',
+                content: [{
+                    type: 'tool_use',
+                    id: toolUseId,
+                    name: 'get_current_time',
+                    input: {}
+                }]
+            });
+            expect(converted[2]).to.deep.equal({
+                role: 'user',
+                content: [{
+                    type: 'tool_result',
+                    tool_use_id: toolUseId,
+                    content: '2026-07-30T12:00:00Z'
+                }]
+            });
+        });
+    });
 });

package/test/deepseek.test.js

@@ -17,4 +17,44 @@ describe('DeepSeek Model Registration Tests', () => {
         expect(model.models).to.have.length(1);
         expect(model.models[0].key).to.equal('deepseek-ai/DeepSeek-V4-Pro');
     });
+
+    it('should register Fireworks DeepSeek V4 Flash by default', () => {
+        const model = ModelMix.new();
+        model.deepseekV4Flash({ mix: { fireworks: true, openrouter: false } });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('accounts/fireworks/models/deepseek-v4-flash');
+        expect(ModelMix.calculateCost('accounts/fireworks/models/deepseek-v4-flash', {
+            input: 1_000_000,
+            output: 1_000_000
+        })).to.be.closeTo(0.42, 1e-10);
+    });
+
+    it('should register NVIDIA DeepSeek V4 Flash when nvidia mix is enabled', () => {
+        const model = ModelMix.new();
+        model.deepseekV4Flash({ mix: { fireworks: false, openrouter: false, nvidia: true } });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('deepseek-ai/deepseek-v4-flash');
+    });
+
+    it('should register OpenRouter DeepSeek V4 Flash when openrouter mix is enabled', () => {
+        const model = ModelMix.new();
+        model.deepseekV4Flash({ mix: { fireworks: false, openrouter: true } });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('deepseek/deepseek-v4-flash');
+        expect(ModelMix.calculateCost('deepseek/deepseek-v4-flash', {
+            input: 1_000_000,
+            output: 1_000_000
+        })).to.equal(0.27);
+    });
+
+    it('should register Together DeepSeek V4 Flash when together mix is enabled', () => {
+        const model = ModelMix.new();
+        model.deepseekV4Flash({ mix: { fireworks: false, openrouter: false, together: true } });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('deepseek-ai/DeepSeek-V4-Flash');
+    });
 });