modelmix 4.6.7 → 4.6.8

package/README.md

@@ -90,7 +90,6 @@ console.log(ETH.price);
 ModelMix.new()
   .gptOss()
   .kimiK25think()
-  .deepseekR1()
   .hermes3()
   .addText('What is the capital of France?');
 ```
@@ -102,6 +101,32 @@ This pattern allows you to:
 - Track token usage across all providers
 - Keep your code clean and maintainable
 
+## 🎛️ Unified Effort Scale
+
+Control reasoning depth with one ModelMix policy value (`-1` adaptive, or `0`–`100`). It lives **outside** native `options` and is mapped to each provider’s effort API at request time.
+
+```javascript
+// In config (ModelMix.new or per-model shorthand)
+ModelMix.new({ config: { effort: 50 } }).sonnet46().addText('...').message();
+ModelMix.new().deepseekV4Flash({ config: { effort: 100 } }).addText('...').message();
+
+// Fluent
+ModelMix.new().effort(-1).minimaxM3().addText('...').message();
+```
+
+**Native wins:** if you already set a provider-native field (`reasoning_effort`, `output_config.effort`, `thinkingConfig`, etc.), unified `effort` is ignored for that request.
+
+| Scale | OpenAI | Anthropic | Gemini 3+ | DeepSeek V4 | MiniMax M3 |
+|------|--------|-----------|-----------|-------------|------------|
+| 0–19 / 0–24* | `none` | `low` | `minimal` | thinking `disabled` | `thinking.disabled` |
+| 20–39 / 25–49* | `low` | `medium` | `low` | `low` + thinking on | `thinking.adaptive` |
+| 40–59 / 50–74* | `medium` | `high` | `medium` | `high` + thinking on | `thinking.adaptive` |
+| 60–79 / 75–100* | `high` | `xhigh` | `high` | `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 bands use 0–24 / 25–49 / 50–74 / 75–100. Gemini 2.5 maps 0–100 to `thinkingBudget` (0→0, 100→model max). `-1` sets the provider’s adaptive/dynamic control when it exists; otherwise it is a no-op. Levels are clamped to what each model supports. Providers without effort control are a no-op.
+
 ## 🔧 Model Context Protocol (MCP) Integration
 
 ModelMix makes it incredibly easy to enhance your AI models with powerful capabilities through the Model Context Protocol. With just a few lines of code, you can add features like web search, code execution, or any custom functionality to your models.
@@ -170,6 +195,7 @@ Here's a comprehensive list of available methods:
 | `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] |
+| `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]       |
 | `GLM51()`           | Fireworks  | models/glm-5p1               | [\$1.05 / \$3.50][10]      |
@@ -195,7 +221,7 @@ Here's a comprehensive list of available methods:
 [11]: https://platform.kimi.ai/docs/guide/kimi-k3-pricing "Kimi K3 Pricing"
 
 Each method accepts optional `options`, `config`, and (for multi-provider methods) `mix` parameters to customize behavior.  
-For NVIDIA on DeepSeek V4 Pro, use `deepseekV4Pro({ mix: { nvidia: true } })`.
+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 instead of Moonshot's native API, use `kimiK3({ mix: { moonshot: false, openrouter: true } })`.
 
@@ -617,6 +643,7 @@ new ModelMix(args = { options: {}, config: {} })
   - **config**: This object contains configuration settings that control the behavior of the `ModelMix` instance. These settings can also be overridden for specific model instances. Examples of configuration settings include:
     - `system`: Sets the default system message for the model, e.g., "You are an assistant."
     - `max_history`: Limits the number of historical messages to retain, e.g., 1.
+    - `effort`: Unified reasoning effort (`-1` adaptive, or `0`–`100`). Not a native provider field — use `config.effort` or `.effort(n)`.
     - `roundRobin`: When `true`, rotates through attached models on each request for load balancing. When `false` (default), uses fallback mode where models are tried sequentially only if previous ones fail.
     - `bottleneck`: Configures the rate limiting behavior using Bottleneck. For example:
       - `maxConcurrent`: Maximum number of concurrent requests
@@ -637,6 +664,7 @@ new ModelMix(args = { options: {}, config: {} })
 - `attach(modelKey, modelInstance)`: Attaches a model instance to the `ModelMix`.
 - `new()`: `static` Creates a new `ModelMix`.
 - `new()`: Creates a new `ModelMix` using instance setup.
+- `effort(n)`: Sets unified effort (`-1` or `0`–`100`) on `config.effort`.
 
 - `setSystem(text)`: Sets the system prompt.
 - `setSystemFromFile(filePath)`: Sets the system prompt from a file.

package/demo/fireworks.js

@@ -1,14 +1,12 @@
 import { ModelMix } from '../index.js';
-try { process.loadEnvFile(); } catch {}
+try { process.loadEnvFile(); } catch { }
 
 async function main() {
     try {
         const ai = ModelMix.new();
 
-        const response = await ai
-            .GLM46()
-            .deepseekV32()
-            .GLM47()
+        const response = await ai.effort(50)
+            .deepseekV4Flash()
             .addText('What is the capital of France?')
             .message();
 
@@ -20,4 +18,3 @@ async function main() {
 }
 
 main();
-

package/demo/free.js

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

package/demo/groq.js

@@ -13,7 +13,7 @@ const mmix = new ModelMix({
     }
 });
 
-mmix.attach('deepseek-r1-distill-llama-70b', new MixGroq({
+mmix.attach('openai/gpt-oss-120b', new MixGroq({
     config: {
         apiKey: env.GROQ_API_KEY,
     }

package/demo/nvidia.js

@@ -2,7 +2,7 @@ import { ModelMix } from '../index.js';
 try { process.loadEnvFile(); } catch { }
 
 const model = ModelMix.new()
-    .deepseekV4Flash()
+    .deepseekV4Flash({ mix: { nvidia: true } })
     .addText("Create exactly 5 characters for a narrative game.")
 
 const jsonResult = await model.json([], [{

package/demo/together.js

@@ -4,7 +4,7 @@ try { process.loadEnvFile(); } catch {}
 const setup = { config: { system: "You are ALF from Melmac." } };
 
 let r = ModelMix.new()
-    .attach('deepseek-ai/DeepSeek-R1', new MixTogether(setup))
+    .attach('deepseek-ai/DeepSeek-V4-Flash', new MixTogether(setup))
     .addText('hi there')
     .addText('do you like cats?')
     .message();

package/effort.js

@@ -0,0 +1,370 @@
+/**
+ * Unified effort scale for ModelMix.
+ *
+ * Policy value: integer -1 (adaptive) or 0..100.
+ * Stored in config.effort (never in native options).
+ * Mapped to provider-native fields only when native effort controls are absent.
+ */
+
+const OPENAI_LEVELS = ['none', 'low', 'medium', 'high', 'xhigh'];
+const ANTHROPIC_LEVELS = ['low', 'medium', 'high', 'xhigh', 'max'];
+const GEMINI_LEVELS = ['minimal', 'low', 'medium', 'high'];
+
+const OPENAI_BANDS = [
+    [0, 19, 'none'],
+    [20, 39, 'low'],
+    [40, 59, 'medium'],
+    [60, 79, 'high'],
+    [80, 100, 'xhigh'],
+];
+
+const ANTHROPIC_BANDS = [
+    [0, 19, 'low'],
+    [20, 39, 'medium'],
+    [40, 59, 'high'],
+    [60, 79, 'xhigh'],
+    [80, 100, 'max'],
+];
+
+const GEMINI_BANDS = [
+    [0, 24, 'minimal'],
+    [25, 49, 'low'],
+    [50, 74, 'medium'],
+    [75, 100, 'high'],
+];
+
+/** Exact model → supported OpenAI reasoning_effort values */
+const OPENAI_MODEL_LEVELS = {
+    'gpt-5': ['minimal', 'low', 'medium', 'high'],
+    'gpt-5-mini': ['minimal', 'low', 'medium', 'high'],
+    'gpt-5-nano': ['minimal', 'low', 'medium', 'high'],
+    'gpt-5.3-codex': ['low', 'medium', 'high', 'xhigh'],
+    'gpt-oss-120b': ['low', 'medium', 'high'],
+    'openai/gpt-oss-120b': ['low', 'medium', 'high'],
+    'openai/gpt-oss-120b:free': ['low', 'medium', 'high'],
+};
+
+/**
+ * DeepSeek V4 (OpenAI-compatible): reasoning_effort low|high|max + thinking toggle.
+ * Official mapping: low/high/max; xhigh remaps per model (flash→high, pro→max).
+ * @see https://api-docs.deepseek.com/guides/thinking_mode
+ */
+const DEEPSEEK_LEVELS = ['none', 'low', 'high', 'max'];
+const DEEPSEEK_BANDS = [
+    [0, 19, 'none'],
+    [20, 39, 'low'],
+    [40, 79, 'high'],
+    [80, 100, 'max'],
+];
+
+/**
+ * MiniMax M3 (OpenAI-compatible): thinking.type disabled | adaptive.
+ * @see https://platform.minimax.io/docs/api-reference/text-openai-api
+ */
+const MINIMAX_LEVELS = ['disabled', 'adaptive'];
+const MINIMAX_BANDS = [
+    [0, 19, 'disabled'],
+    [20, 100, 'adaptive'],
+];
+
+/** Exact model → supported Gemini thinkingLevel values */
+const GEMINI_MODEL_LEVELS = {
+    'gemini-3-pro-preview': ['low', 'high'],
+    'gemini-3.1-pro-preview': ['low', 'medium', 'high'],
+    'gemini-2.5-pro': ['low', 'medium', 'high'],
+    'gemini-2.5-flash': ['low', 'medium', 'high'],
+    'gemini-2.5-flash-lite': ['low', 'medium', 'high'],
+};
+
+const GEMINI_25_BUDGET_MAX = {
+    'gemini-2.5-pro': 32768,
+    'gemini-2.5-flash': 24576,
+    'gemini-2.5-flash-lite': 24576,
+};
+
+const PROVIDER_FAMILY_BY_CLASS = {
+    MixAnthropic: 'anthropic',
+    MixGoogle: 'google',
+    MixOpenAI: 'openai',
+    MixOpenAIResponses: 'openai',
+    MixOpenAIWebSocket: 'openai',
+    MixOpenRouter: 'openai',
+    MixKimi: 'openai',
+    MixMiniMax: 'openai',
+    MixMiMo: 'openai',
+    MixGrok: 'openai',
+    MixGroq: 'openai',
+    MixTogether: 'openai',
+    MixCerebras: 'openai',
+    MixFireworks: 'openai',
+    MixNVIDIA: 'openai',
+    MixPerplexity: null,
+    MixOllama: null,
+    MixLMStudio: null,
+    MixLambda: null,
+    MixCustom: null,
+};
+
+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)}`);
+    }
+    if (value === -1) return -1;
+    if (value < 0 || value > 100) {
+        throw new Error(`Invalid effort: expected integer -1 or 0..100, got ${value}`);
+    }
+    return value;
+}
+
+function levelFromBands(effort, bands) {
+    for (const [lo, hi, level] of bands) {
+        if (effort >= lo && effort <= hi) return level;
+    }
+    return bands[bands.length - 1][2];
+}
+
+function pickNearestLevel(desired, ladder, supported) {
+    if (supported.includes(desired)) return desired;
+    const desiredIdx = ladder.indexOf(desired);
+    if (desiredIdx === -1) return supported[Math.floor(supported.length / 2)];
+
+    let best = supported[0];
+    let bestDist = Infinity;
+    for (const level of supported) {
+        const idx = ladder.indexOf(level);
+        if (idx === -1) continue;
+        const dist = Math.abs(idx - desiredIdx);
+        if (dist < bestDist) {
+            bestDist = dist;
+            best = level;
+        }
+    }
+    return best;
+}
+
+function supportedOpenAILevels(modelKey) {
+    if (modelKey && OPENAI_MODEL_LEVELS[modelKey]) {
+        return OPENAI_MODEL_LEVELS[modelKey];
+    }
+    return OPENAI_LEVELS;
+}
+
+function supportedGeminiLevels(modelKey) {
+    if (modelKey && GEMINI_MODEL_LEVELS[modelKey]) {
+        return GEMINI_MODEL_LEVELS[modelKey];
+    }
+    return GEMINI_LEVELS;
+}
+
+function isGemini25(modelKey) {
+    return typeof modelKey === 'string' && modelKey.includes('2.5');
+}
+
+function isDeepSeekV4(modelKey) {
+    if (typeof modelKey !== 'string') return false;
+    const key = modelKey.toLowerCase();
+    return key.includes('deepseek-v4') || key.includes('deepseek_v4');
+}
+
+function isMiniMax(modelKey) {
+    return typeof modelKey === 'string' && modelKey.toLowerCase().includes('minimax');
+}
+
+function mapDeepSeekEffort(normalized) {
+    // DeepSeek V4 has no adaptive mode (only enabled/disabled + low|high|max)
+    if (normalized === -1) return null;
+    const level = levelFromBands(normalized, DEEPSEEK_BANDS);
+    if (level === 'none') {
+        return { thinking: { type: 'disabled' } };
+    }
+    return {
+        reasoning_effort: level,
+        thinking: { type: 'enabled' }
+    };
+}
+
+function mapMiniMaxEffort(normalized) {
+    if (normalized === -1) {
+        return { thinking: { type: 'adaptive' } };
+    }
+    const level = levelFromBands(normalized, MINIMAX_BANDS);
+    return { thinking: { type: level } };
+}
+
+/**
+ * Explicit adaptive mapping when the provider/model exposes it.
+ * Returns null when adaptive is not a settable native control.
+ */
+function mapAdaptiveEffort(providerFamily, modelKey) {
+    if (providerFamily === 'anthropic') {
+        return { thinking: { type: 'adaptive' } };
+    }
+    if (providerFamily === 'google') {
+        // Gemini dynamic thinking: thinkingBudget -1 (2.5 official; accepted on 3.x as dynamic)
+        return { thinkingConfig: { thinkingBudget: -1 } };
+    }
+    if (providerFamily === 'openai' && isMiniMax(modelKey)) {
+        return { thinking: { type: 'adaptive' } };
+    }
+    // OpenAI / DeepSeek: no adaptive enum — cannot set adaptive
+    return null;
+}
+
+function gemini25BudgetMax(modelKey) {
+    if (modelKey && GEMINI_25_BUDGET_MAX[modelKey] != null) {
+        return GEMINI_25_BUDGET_MAX[modelKey];
+    }
+    return 24576;
+}
+
+/**
+ * @returns {'openai'|'anthropic'|'google'|null}
+ */
+function resolveProviderFamily(providerInstance) {
+    if (!providerInstance || !providerInstance.constructor) return null;
+    let proto = providerInstance;
+    while (proto) {
+        const name = proto.constructor?.name;
+        if (name && Object.prototype.hasOwnProperty.call(PROVIDER_FAMILY_BY_CLASS, name)) {
+            return PROVIDER_FAMILY_BY_CLASS[name];
+        }
+        proto = Object.getPrototypeOf(proto);
+        if (!proto || proto === Object.prototype) break;
+    }
+    return null;
+}
+
+function hasNativeEffort(family, options = {}, modelKey) {
+    if (family === 'openai') {
+        if (options.reasoning_effort != null && options.reasoning_effort !== '') return true;
+        // DeepSeek / MiniMax use thinking.type as the on/off (or adaptive) control
+        if ((isDeepSeekV4(modelKey) || isMiniMax(modelKey)) && options.thinking != null) return true;
+        return false;
+    }
+    if (family === 'anthropic') {
+        return options.output_config?.effort != null && options.output_config.effort !== '';
+    }
+    if (family === 'google') {
+        if (options.thinkingConfig != null) return true;
+        if (options.thinkingLevel != null) return true;
+        if (options.thinkingBudget != null) return true;
+        return false;
+    }
+    return false;
+}
+
+/**
+ * Map unified effort to a provider-native patch object.
+ * Returns null when there is nothing to set (unsupported family, or -1 on a
+ * model with no adaptive control).
+ *
+ * @returns {object|null}
+ */
+function mapEffort(providerFamily, effort, modelKey) {
+    const normalized = normalizeEffort(effort);
+
+    if (!providerFamily) return null;
+
+    if (normalized === -1) {
+        return mapAdaptiveEffort(providerFamily, modelKey);
+    }
+
+    if (providerFamily === 'openai') {
+        if (isDeepSeekV4(modelKey)) {
+            return mapDeepSeekEffort(normalized);
+        }
+        if (isMiniMax(modelKey)) {
+            return mapMiniMaxEffort(normalized);
+        }
+        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 } };
+    }
+
+    if (providerFamily === 'google') {
+        if (isGemini25(modelKey)) {
+            const max = gemini25BudgetMax(modelKey);
+            const budget = Math.round((normalized / 100) * max);
+            return { thinkingConfig: { thinkingBudget: budget } };
+        }
+        const desired = levelFromBands(normalized, GEMINI_BANDS);
+        const level = pickNearestLevel(desired, GEMINI_LEVELS, supportedGeminiLevels(modelKey));
+        return { thinkingConfig: { thinkingLevel: level } };
+    }
+
+    return null;
+}
+
+/**
+ * Apply config.effort onto options when native controls are absent.
+ * Mutates and returns options. Never writes ModelMix `effort` into the HTTP body.
+ */
+function applyUnifiedEffort(options, config, providerFamily, modelKey) {
+    if (!config || config.effort === undefined || config.effort === null) {
+        return options;
+    }
+    if (!providerFamily) return options;
+    if (hasNativeEffort(providerFamily, options, modelKey)) return options;
+
+    const patch = mapEffort(providerFamily, config.effort, modelKey);
+    if (!patch) return options;
+
+    if (patch.reasoning_effort !== undefined) {
+        options.reasoning_effort = patch.reasoning_effort;
+    }
+    if (patch.output_config) {
+        options.output_config = {
+            ...(options.output_config || {}),
+            ...patch.output_config
+        };
+    }
+    if (patch.thinking) {
+        options.thinking = {
+            ...(options.thinking || {}),
+            ...patch.thinking
+        };
+        // Adaptive thinking rejects budget_tokens; drop it if we switched mode.
+        if (patch.thinking.type === 'adaptive') {
+            delete options.thinking.budget_tokens;
+        }
+        // DeepSeek non-thinking: do not send reasoning_effort
+        if (patch.thinking.type === 'disabled') {
+            delete options.reasoning_effort;
+        }
+    }
+    if (patch.thinkingConfig) {
+        options.thinkingConfig = {
+            ...(options.thinkingConfig || {}),
+            ...patch.thinkingConfig
+        };
+    }
+
+    return options;
+}
+
+module.exports = {
+    normalizeEffort,
+    mapEffort,
+    mapAdaptiveEffort,
+    applyUnifiedEffort,
+    hasNativeEffort,
+    resolveProviderFamily,
+    isDeepSeekV4,
+    isMiniMax,
+    levelFromBands,
+    pickNearestLevel,
+    OPENAI_BANDS,
+    ANTHROPIC_BANDS,
+    GEMINI_BANDS,
+    DEEPSEEK_BANDS,
+    OPENAI_LEVELS,
+    ANTHROPIC_LEVELS,
+    GEMINI_LEVELS,
+    DEEPSEEK_LEVELS,
+};

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 };
@@ -1038,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 ? '→' : '↻';
@@ -2892,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);
@@ -3028,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.7",
+  "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/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');
+    });
 });

package/test/effort.test.js

@@ -0,0 +1,359 @@
+const { expect } = require('chai');
+const {
+    normalizeEffort,
+    mapEffort,
+    applyUnifiedEffort,
+    hasNativeEffort,
+    resolveProviderFamily,
+    levelFromBands,
+    OPENAI_BANDS,
+    ANTHROPIC_BANDS,
+    GEMINI_BANDS,
+} = require('../effort.js');
+const {
+    ModelMix,
+    MixOpenAI,
+    MixOpenAIResponses,
+    MixAnthropic,
+    MixGoogle,
+    MixPerplexity,
+} = require('../index.js');
+
+describe('Unified effort scale', () => {
+    describe('normalizeEffort', () => {
+        it('accepts -1 and 0..100 integers', () => {
+            expect(normalizeEffort(-1)).to.equal(-1);
+            expect(normalizeEffort(0)).to.equal(0);
+            expect(normalizeEffort(50)).to.equal(50);
+            expect(normalizeEffort(100)).to.equal(100);
+        });
+
+        it('rejects invalid values', () => {
+            expect(() => normalizeEffort(1.5)).to.throw(/Invalid effort/);
+            expect(() => normalizeEffort(101)).to.throw(/Invalid effort/);
+            expect(() => normalizeEffort(-2)).to.throw(/Invalid effort/);
+            expect(() => normalizeEffort('medium')).to.throw(/Invalid effort/);
+            expect(() => normalizeEffort(null)).to.throw(/Invalid effort/);
+        });
+    });
+
+    describe('band mapping', () => {
+        it('maps OpenAI bands', () => {
+            expect(levelFromBands(0, OPENAI_BANDS)).to.equal('none');
+            expect(levelFromBands(19, OPENAI_BANDS)).to.equal('none');
+            expect(levelFromBands(20, OPENAI_BANDS)).to.equal('low');
+            expect(levelFromBands(40, OPENAI_BANDS)).to.equal('medium');
+            expect(levelFromBands(60, OPENAI_BANDS)).to.equal('high');
+            expect(levelFromBands(80, OPENAI_BANDS)).to.equal('xhigh');
+            expect(levelFromBands(100, OPENAI_BANDS)).to.equal('xhigh');
+        });
+
+        it('maps Anthropic bands', () => {
+            expect(levelFromBands(0, ANTHROPIC_BANDS)).to.equal('low');
+            expect(levelFromBands(20, ANTHROPIC_BANDS)).to.equal('medium');
+            expect(levelFromBands(40, ANTHROPIC_BANDS)).to.equal('high');
+            expect(levelFromBands(60, ANTHROPIC_BANDS)).to.equal('xhigh');
+            expect(levelFromBands(80, ANTHROPIC_BANDS)).to.equal('max');
+        });
+
+        it('maps Gemini bands', () => {
+            expect(levelFromBands(0, GEMINI_BANDS)).to.equal('minimal');
+            expect(levelFromBands(25, GEMINI_BANDS)).to.equal('low');
+            expect(levelFromBands(50, GEMINI_BANDS)).to.equal('medium');
+            expect(levelFromBands(75, GEMINI_BANDS)).to.equal('high');
+        });
+    });
+
+    describe('mapEffort', () => {
+        it('maps OpenAI effort to reasoning_effort', () => {
+            expect(mapEffort('openai', 10)).to.deep.equal({ reasoning_effort: 'none' });
+            expect(mapEffort('openai', 50)).to.deep.equal({ reasoning_effort: 'medium' });
+            expect(mapEffort('openai', 90)).to.deep.equal({ reasoning_effort: 'xhigh' });
+        });
+
+        it('sets OpenAI adaptive only when supported (otherwise no-op)', () => {
+            expect(mapEffort('openai', -1)).to.equal(null);
+            expect(mapEffort('openai', -1, 'gpt-5.2')).to.equal(null);
+        });
+
+        it('clamps OpenAI to model-supported levels', () => {
+            expect(mapEffort('openai', 10, 'gpt-5.3-codex')).to.deep.equal({ reasoning_effort: 'low' });
+            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 to thinking.type=adaptive', () => {
+            expect(mapEffort('anthropic', -1)).to.deep.equal({ thinking: { type: 'adaptive' } });
+        });
+
+        it('maps Gemini 3+ thinkingLevel', () => {
+            expect(mapEffort('google', 10, 'gemini-3.6-flash')).to.deep.equal({
+                thinkingConfig: { thinkingLevel: 'minimal' }
+            });
+            expect(mapEffort('google', 80, 'gemini-3.6-flash')).to.deep.equal({
+                thinkingConfig: { thinkingLevel: 'high' }
+            });
+        });
+
+        it('clamps Gemini levels for models with fewer steps', () => {
+            expect(mapEffort('google', 10, 'gemini-3-pro-preview')).to.deep.equal({
+                thinkingConfig: { thinkingLevel: 'low' }
+            });
+        });
+
+        it('maps Gemini adaptive (-1) to thinkingBudget -1', () => {
+            expect(mapEffort('google', -1, 'gemini-3.6-flash')).to.deep.equal({
+                thinkingConfig: { thinkingBudget: -1 }
+            });
+            expect(mapEffort('google', -1, 'gemini-2.5-flash')).to.deep.equal({
+                thinkingConfig: { thinkingBudget: -1 }
+            });
+        });
+
+        it('maps Gemini 2.5 to thinkingBudget', () => {
+            expect(mapEffort('google', 0, 'gemini-2.5-flash')).to.deep.equal({
+                thinkingConfig: { thinkingBudget: 0 }
+            });
+            expect(mapEffort('google', 100, 'gemini-2.5-flash')).to.deep.equal({
+                thinkingConfig: { thinkingBudget: 24576 }
+            });
+            expect(mapEffort('google', 50, 'gemini-2.5-pro')).to.deep.equal({
+                thinkingConfig: { thinkingBudget: 16384 }
+            });
+        });
+
+        it('maps DeepSeek V4 effort to thinking + reasoning_effort', () => {
+            const key = 'accounts/fireworks/models/deepseek-v4-flash';
+            expect(mapEffort('openai', 0, key)).to.deep.equal({
+                thinking: { type: 'disabled' }
+            });
+            expect(mapEffort('openai', 30, key)).to.deep.equal({
+                reasoning_effort: 'low',
+                thinking: { type: 'enabled' }
+            });
+            expect(mapEffort('openai', 50, key)).to.deep.equal({
+                reasoning_effort: 'high',
+                thinking: { type: 'enabled' }
+            });
+            expect(mapEffort('openai', 100, 'deepseek-ai/DeepSeek-V4-Pro')).to.deep.equal({
+                reasoning_effort: 'max',
+                thinking: { type: 'enabled' }
+            });
+            // No adaptive control on DeepSeek → no-op
+            expect(mapEffort('openai', -1, 'deepseek/deepseek-v4-flash')).to.equal(null);
+        });
+
+        it('maps MiniMax thinking adaptive/disabled', () => {
+            expect(mapEffort('openai', -1, 'MiniMax-M3')).to.deep.equal({
+                thinking: { type: 'adaptive' }
+            });
+            expect(mapEffort('openai', 0, 'minimax/minimax-m3')).to.deep.equal({
+                thinking: { type: 'disabled' }
+            });
+            expect(mapEffort('openai', 50, 'MiniMaxAI/MiniMax-M3')).to.deep.equal({
+                thinking: { type: 'adaptive' }
+            });
+        });
+
+        it('returns null for unsupported families', () => {
+            expect(mapEffort(null, 50)).to.equal(null);
+        });
+    });
+
+    describe('applyUnifiedEffort / native wins', () => {
+        it('applies OpenAI mapping when native absent', () => {
+            const options = {};
+            applyUnifiedEffort(options, { effort: 50 }, 'openai', 'gpt-5.2');
+            expect(options.reasoning_effort).to.equal('medium');
+        });
+
+        it('applies MiniMax adaptive from config.effort -1', () => {
+            const options = {};
+            applyUnifiedEffort(options, { effort: -1 }, 'openai', 'MiniMax-M3');
+            expect(options.thinking).to.deep.equal({ type: 'adaptive' });
+        });
+
+        it('applies DeepSeek mapping on Fireworks model key', () => {
+            const options = {};
+            applyUnifiedEffort(
+                options,
+                { effort: 100 },
+                'openai',
+                'accounts/fireworks/models/deepseek-v4-flash'
+            );
+            expect(options.reasoning_effort).to.equal('max');
+            expect(options.thinking).to.deep.equal({ type: 'enabled' });
+        });
+
+        it('applies DeepSeek disabled thinking without reasoning_effort', () => {
+            const options = {};
+            applyUnifiedEffort(
+                options,
+                { effort: 10 },
+                'openai',
+                'deepseek/deepseek-v4-flash'
+            );
+            expect(options.thinking).to.deep.equal({ type: 'disabled' });
+            expect(options.reasoning_effort).to.equal(undefined);
+        });
+
+        it('skips DeepSeek mapping when thinking is already set', () => {
+            const options = { thinking: { type: 'disabled' } };
+            applyUnifiedEffort(
+                options,
+                { effort: 100 },
+                'openai',
+                'accounts/fireworks/models/deepseek-v4-flash'
+            );
+            expect(options.thinking).to.deep.equal({ type: 'disabled' });
+            expect(options.reasoning_effort).to.equal(undefined);
+        });
+
+        it('skips OpenAI mapping when reasoning_effort is set', () => {
+            const options = { reasoning_effort: 'none' };
+            applyUnifiedEffort(options, { effort: 90 }, 'openai', 'gpt-5.2');
+            expect(options.reasoning_effort).to.equal('none');
+        });
+
+        it('applies Anthropic mapping when native absent', () => {
+            const options = {};
+            applyUnifiedEffort(options, { effort: 90 }, 'anthropic', 'claude-opus-5');
+            expect(options.output_config).to.deep.equal({ effort: 'max' });
+        });
+
+        it('skips Anthropic mapping when output_config.effort is set', () => {
+            const options = { output_config: { effort: 'low', format: { type: 'json_schema' } } };
+            applyUnifiedEffort(options, { effort: 90 }, 'anthropic', 'claude-opus-5');
+            expect(options.output_config.effort).to.equal('low');
+            expect(options.output_config.format).to.deep.equal({ type: 'json_schema' });
+        });
+
+        it('merges Anthropic adaptive without wiping display, drops budget_tokens', () => {
+            const options = {
+                thinking: { type: 'enabled', budget_tokens: 1638, display: 'summarized' }
+            };
+            applyUnifiedEffort(options, { effort: -1 }, 'anthropic', 'claude-sonnet-4-6');
+            expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
+        });
+
+        it('skips Google mapping when thinkingConfig is set', () => {
+            const options = { thinkingConfig: { thinkingLevel: 'low' } };
+            applyUnifiedEffort(options, { effort: 90 }, 'google', 'gemini-3.6-flash');
+            expect(options.thinkingConfig.thinkingLevel).to.equal('low');
+        });
+
+        it('does nothing when config.effort is undefined', () => {
+            const options = {};
+            applyUnifiedEffort(options, {}, 'openai', 'gpt-5.2');
+            expect(options).to.deep.equal({});
+        });
+
+        it('hasNativeEffort detects provider fields', () => {
+            expect(hasNativeEffort('openai', { reasoning_effort: 'high' })).to.equal(true);
+            expect(hasNativeEffort('openai', {})).to.equal(false);
+            expect(hasNativeEffort('anthropic', { output_config: { effort: 'max' } })).to.equal(true);
+            expect(hasNativeEffort('google', { thinkingBudget: 1024 })).to.equal(true);
+        });
+    });
+
+    describe('resolveProviderFamily', () => {
+        it('resolves known providers', () => {
+            expect(resolveProviderFamily(new MixOpenAI())).to.equal('openai');
+            expect(resolveProviderFamily(new MixOpenAIResponses())).to.equal('openai');
+            expect(resolveProviderFamily(new MixAnthropic())).to.equal('anthropic');
+            expect(resolveProviderFamily(new MixGoogle())).to.equal('google');
+            expect(resolveProviderFamily(new MixPerplexity())).to.equal(null);
+        });
+    });
+
+    describe('ModelMix API surface', () => {
+        it('accepts config.effort', () => {
+            const model = ModelMix.new({ config: { effort: 25 } });
+            expect(model.config.effort).to.equal(25);
+        });
+
+        it('accepts config.effort on model shorthand', () => {
+            const model = ModelMix.new().deepseekV4Flash({ config: { effort: 100 } });
+            expect(model.models[0].provider.config.effort).to.equal(100);
+        });
+
+        it('supports fluent .effort()', () => {
+            const model = ModelMix.new().effort(-1);
+            expect(model.config.effort).to.equal(-1);
+        });
+
+        it('lets .new({ config: { effort } }) override inherited config.effort', () => {
+            const base = ModelMix.new({ config: { effort: 20 } });
+            const child = base.new({ config: { effort: 80 } });
+            expect(child.config.effort).to.equal(80);
+            expect(base.config.effort).to.equal(20);
+        });
+
+        it('rejects invalid fluent effort', () => {
+            expect(() => ModelMix.new().effort(150)).to.throw(/Invalid effort/);
+        });
+    });
+
+    describe('provider request wiring', () => {
+        it('OpenAI Responses request uses mapped reasoning_effort', () => {
+            const options = { model: 'gpt-5.2', messages: [] };
+            applyUnifiedEffort(options, { effort: 15 }, 'openai', 'gpt-5.2');
+            const request = MixOpenAIResponses.buildResponsesRequest(options, {});
+            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');
+
+            const options = {
+                ...model.models[0].provider.options,
+                model: 'claude-opus-5'
+            };
+            applyUnifiedEffort(options, { effort: 20 }, 'anthropic', 'claude-opus-5');
+            expect(options.output_config.effort).to.equal('max');
+        });
+
+        it('MixGoogle generationConfig includes thinkingConfig from options', async () => {
+            const google = new MixGoogle({ config: { apiKey: 'test-key' } });
+            let capturedBody;
+            const originalFetch = global.fetch;
+            const responseBody = JSON.stringify({
+                candidates: [{ content: { parts: [{ text: 'ok' }] } }],
+                usageMetadata: { promptTokenCount: 1, candidatesTokenCount: 1 }
+            });
+            global.fetch = async (url, init) => {
+                capturedBody = JSON.parse(init.body);
+                return {
+                    ok: true,
+                    status: 200,
+                    headers: new Headers({ 'content-type': 'application/json' }),
+                    text: async () => responseBody,
+                    json: async () => JSON.parse(responseBody)
+                };
+            };
+
+            try {
+                await google.create({
+                    config: { system: 'sys' },
+                    options: {
+                        model: 'gemini-3.6-flash',
+                        max_tokens: 100,
+                        messages: [{ role: 'user', content: [{ type: 'text', text: 'hi' }] }],
+                        thinkingConfig: { thinkingLevel: 'low' }
+                    }
+                });
+            } finally {
+                global.fetch = originalFetch;
+            }
+
+            expect(capturedBody.generationConfig.thinkingConfig).to.deep.equal({
+                thinkingLevel: 'low'
+            });
+        });
+    });
+});

package/test/setup.js

@@ -27,6 +27,8 @@ process.env.OPENAI_API_KEY = process.env.OPENAI_API_KEY || 'sk-proj-test-dummy-k
 process.env.PPLX_API_KEY = process.env.PPLX_API_KEY || 'pplx-test-dummy-key-for-testing-purposes';
 process.env.GROQ_API_KEY = process.env.GROQ_API_KEY || 'gsk_test-dummy-key-for-testing-purposes';
 process.env.TOGETHER_API_KEY = process.env.TOGETHER_API_KEY || '49a96test-dummy-key-for-testing-purposes';
+process.env.FIREWORKS_API_KEY = process.env.FIREWORKS_API_KEY || 'fw-test-dummy-key-for-testing-purposes';
+process.env.OPENROUTER_API_KEY = process.env.OPENROUTER_API_KEY || 'sk-or-test-dummy-key-for-testing-purposes';
 process.env.XAI_API_KEY = process.env.XAI_API_KEY || 'xai-test-dummy-key-for-testing-purposes';
 process.env.CEREBRAS_API_KEY = process.env.CEREBRAS_API_KEY || 'csk-test-dummy-key-for-testing-purposes';
 process.env.NVIDIA_API_KEY = process.env.NVIDIA_API_KEY || 'nvapi-test-dummy-key-for-testing-purposes';