modelmix 5.2.2 → 5.3.0

package/index.js

@@ -499,6 +499,12 @@ class ModelMix {
     gpt6astra(args = {}) {
         return this._attachOpenAIWithOpenRouter('gpt-6-astra', MixOpenAIResponses, args);
     }
+    gpt6sol(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-6-sol', MixOpenAIResponses, args);
+    }
+    gpt6luna(args = {}) {
+        return this._attachOpenAIWithOpenRouter('gpt-6-luna', MixOpenAIResponses, args);
+    }
     gpt56sol(args = {}) {
         return this._attachOpenAIWithOpenRouter('gpt-5.6-sol', MixOpenAIResponses, args);
     }
@@ -545,6 +551,9 @@ class ModelMix {
         if (mix.openrouter) this.attach('anthropic/claude-fable-5.1', new MixOpenRouter({ options, config }));
         return this;
     }
+    opus55({ options = {}, config = {} } = {}) {
+        return this.attach('claude-opus-5-5', new MixAnthropic({ options, config }));
+    }
     opus50({ options = {}, config = {} } = {}) {
         return this.attach('claude-opus-5', new MixAnthropic({ options, config }));
     }
@@ -769,6 +778,13 @@ class ModelMix {
         return this;
     }
 
+    mimo26pro({ options = {}, config = {}, mix = { openrouter: true } } = {}) {
+        mix = { ...this.mix, ...mix };
+        if (mix.mimo) this.attach('mimo-v2.6-pro', new MixMiMo({ options, config }));
+        if (mix.openrouter) this.attach('xiaomi/mimo-v2.6-pro', new MixOpenRouter({ options, config }));
+        return this;
+    }
+
     deepseekPro({ options = {}, config = {} } = {}) {
         return this.attach('deepseek/deepseek-v4-pro-0813', new MixOpenRouter({ options, config }));
     }

package/lib/model-chain.js

@@ -3,9 +3,9 @@ const { normalizeEffort } = require('../effort');
 const CHAIN_MODEL_SHORTCUTS = new Set([
     'gpt5', 'gpt5mini', 'gpt5nano',
     'gpt51', 'gpt52', 'gpt54', 'gpt54mini', 'gpt54nano', 'gpt54pro',
-    'gpt6astra', 'gpt55', 'gpt55pro', 'gpt56sol', 'gpt56terra', 'gpt56luna',
+    'gpt6astra', 'gpt6sol', 'gpt6luna', 'gpt55', 'gpt55pro', 'gpt56sol', 'gpt56terra', 'gpt56luna',
     'gptRealtime', 'gptRealtimeMini', 'gpt53codex', 'gpt53chat', 'gptOss',
-    'fable51', 'fable50', 'fable5', 'opus50', 'opus5', 'opus48', 'opus47', 'opus46',
+    'fable51', 'fable50', 'fable5', 'opus55', 'opus50', 'opus5', 'opus48', 'opus47', 'opus46',
     'sonnet50', 'sonnet5', 'sonnet46', 'sonnet45', 'haiku45',
     'gemini31pro', 'gemini38flash', 'gemini37flash', 'gemini36flash', 'gemini35flash',
     'gemini35flashLite', 'gemini31flashLite', 'sonarPro', 'sonar',
@@ -14,7 +14,7 @@ const CHAIN_MODEL_SHORTCUTS = new Set([
     'qwen35397b', 'qwen36plus', 'qwen37plus', 'qwen38max', 'qwen3827b', 'qwen38flash',
     'hermes470b', 'hermes4405b', 'hermes3',
     'kimiK26', 'kimiK27Code', 'kimiK3', 'kimiK25',
-    'minimaxM27', 'minimaxM3', 'mimo25', 'mimo25pro',
+    'minimaxM27', 'minimaxM3', 'mimo25', 'mimo25pro', 'mimo26pro',
     'deepseekV4Pro', 'deepseekPro', 'deepseekV4Flash', 'deepseekV41Flash', 'GLM52', 'GLM53', 'GLM53Flash'
 ]);
 

package/lib/providers/openai-options.js

@@ -3,7 +3,7 @@ function normalizeOpenAIOptions(options) {
         delete options.max_tokens;
         delete options.temperature;
     }
-    if (options.model?.includes('gpt-5') || /^(?:openai\/)?gpt-6-astra(?:-|$)/.test(options.model || '')) {
+    if (options.model?.includes('gpt-5') || /^(?:openai\/)?gpt-6(?:-|$)/.test(options.model || '')) {
         if (options.max_tokens) {
             options.max_completion_tokens = options.max_tokens;
             delete options.max_tokens;

package/lib/providers/openai.js

@@ -11,6 +11,12 @@ const {
     validateProviderExecution
 } = require('../abort-signal');
 
+/** Explicit prompt cache controls belong to the documented "GPT-5.6 and later" family. */
+function isGPT56OrLater(model) {
+    if (typeof model !== 'string') return false;
+    return model.startsWith('gpt-5.6') || /^(?:openai\/)?gpt-6(?:-|$)/.test(model);
+}
+
 function createOpenAIProviders({
     ModelMix,
     MixCustom,
@@ -38,9 +44,8 @@ function createOpenAIProviders({
         }
     
         static buildResponsesRequest(options = {}, config = {}) {
-            const isGPT56 = typeof options.model === 'string' && options.model.startsWith('gpt-5.6');
             const input = MixOpenAIResponses.messagesToResponsesInput(options.messages, {
-                translateNeutralCache: isGPT56
+                translateNeutralCache: isGPT56OrLater(options.model)
             });
             if (config.system) {
                 input.unshift({ role: 'developer', content: [{ type: 'input_text', text: config.system }] });
@@ -106,7 +111,7 @@ function createOpenAIProviders({
         }
     
         static validatePromptCaching(options, input) {
-            const isGPT56 = typeof options.model === 'string' && options.model.startsWith('gpt-5.6');
+            const supportsCacheControls = isGPT56OrLater(options.model);
             const cacheOptions = options.prompt_cache_options;
             const breakpoints = input.flatMap(message => Array.isArray(message.content)
                 ? message.content
@@ -114,14 +119,14 @@ function createOpenAIProviders({
                     .map(block => block.prompt_cache_breakpoint)
                 : []);
     
-            if (isGPT56 && options.prompt_cache_retention !== undefined) {
-                throw new Error('GPT-5.6 does not support prompt_cache_retention; use prompt_cache_options.ttl instead.');
+            if (supportsCacheControls && options.prompt_cache_retention !== undefined) {
+                throw new Error('GPT-5.6 and later models do not support prompt_cache_retention; use prompt_cache_options.ttl instead.');
             }
-            if (!isGPT56 && cacheOptions !== undefined) {
-                throw new Error('prompt_cache_options is only supported by GPT-5.6 models.');
+            if (!supportsCacheControls && cacheOptions !== undefined) {
+                throw new Error('prompt_cache_options is only supported by GPT-5.6 and later models.');
             }
-            if (!isGPT56 && breakpoints.length > 0) {
-                throw new Error('prompt_cache_breakpoint is only supported by GPT-5.6 models.');
+            if (!supportsCacheControls && breakpoints.length > 0) {
+                throw new Error('prompt_cache_breakpoint is only supported by GPT-5.6 and later models.');
             }
             if (cacheOptions !== undefined) {
                 if (!isPlainObject(cacheOptions)) {

package/lib/token-usage.js

@@ -22,9 +22,11 @@ function usesLongContextRates(pricing, inputTokens) {
 const MODEL_PRICING = {
     // OpenAI
     'gpt-6-astra': { input: 10.00, cachedInput: 1.00, cacheWrite: 12.50, output: 50.00, longContext: OPENAI_LONG_CONTEXT_PRICING },
+    'gpt-6-sol': { input: 2.00, cachedInput: 0.20, cacheWrite: 2.50, output: 10.00, longContext: OPENAI_LONG_CONTEXT_PRICING },
+    'gpt-6-luna': { input: 0.10, cachedInput: 0.01, cacheWrite: 0.125, output: 0.50, longContext: OPENAI_LONG_CONTEXT_PRICING },
     'gpt-realtime-mini': { input: 0.60, cachedInput: 0.06, output: 2.40 },
     'gpt-realtime': { input: 4.00, cachedInput: 0.40, output: 16.00 },
-    'gpt-5.6-sol': { input: 5.00, cachedInput: 0.50, cacheWrite: 6.25, output: 30.00, longContext: OPENAI_LONG_CONTEXT_PRICING },
+    'gpt-5.6-sol': { input: 4.00, cachedInput: 0.40, cacheWrite: 5.00, output: 20.00, longContext: OPENAI_LONG_CONTEXT_PRICING },
     'gpt-5.6-terra': { input: 2.00, cachedInput: 0.20, cacheWrite: 2.50, output: 12.00, longContext: OPENAI_LONG_CONTEXT_PRICING },
     'gpt-5.6-luna': { input: 0.20, cachedInput: 0.02, cacheWrite: 0.25, output: 1.20, longContext: OPENAI_LONG_CONTEXT_PRICING },
     'gpt-5.5-pro': { input: 30.00, output: 180.00 },
@@ -53,6 +55,7 @@ const MODEL_PRICING = {
     'claude-fable-5-1': { input: 10.00, cachedInput: 0.25, cacheWrite: 12.50, cacheWrite1h: 20.00, output: 50.00 },
     'anthropic/claude-fable-5.1': { input: 10.00, cachedInput: 0.25, cacheWrite: 12.50, cacheWrite1h: 20.00, output: 50.00 },
     'claude-fable-5': { input: 10.00, cachedInput: 1.00, cacheWrite: 12.50, cacheWrite1h: 20.00, output: 50.00 },
+    'claude-opus-5-5': { input: 5.00, cachedInput: 0.50, cacheWrite: 6.25, cacheWrite1h: 10.00, output: 25.00 },
     'claude-opus-5': { input: 5.00, cachedInput: 0.50, cacheWrite: 6.25, cacheWrite1h: 10.00, output: 25.00 },
     'claude-sonnet-5': { input: 3.00, cachedInput: 0.30, cacheWrite: 3.75, cacheWrite1h: 6.00, output: 15.00 },
     'claude-opus-4-8': { input: 5.00, cachedInput: 0.50, cacheWrite: 6.25, cacheWrite1h: 10.00, output: 25.00 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "5.2.2",
+  "version": "5.3.0",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",
@@ -82,5 +82,6 @@
     "test:benchmark": "mocha plugins/benchmark/test/**/*.test.js --timeout 10000 --require test/setup.js",
     "test:rlm": "mocha plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js",
     "test:offline": "mocha test/abort.test.js test/json.test.js test/fallback.test.js test/templates.test.js test/images.test.js test/bottleneck.test.js test/tokens.test.js test/history.test.js test/anthropic.test.js test/effort.test.js test/grok.test.js test/google.test.js test/moderation.test.js test/plugins.test.js plugins/skills/test/**/*.test.js plugins/benchmark/test/**/*.test.js plugins/rlm/test/**/*.test.js --timeout 10000 --require test/setup.js"
-  }
-}
+  },
+  "packageManager": "pnpm@12.4.1"
+}

package/skills/modelmix/SKILL.md

@@ -164,7 +164,7 @@ ModelMix.new({ config: { effort: 80 } })
 | DeepSeek V4 | off | `low`↑ | `high`↑ | `high`↑ | `max`↑ | — |
 | MiniMax M3 | off | adaptive | adaptive | adaptive | adaptive | adaptive |
 
-\* GPT-6 Astra maps 0–39 / 40–59 / 60–79 / 80–99 / 100 to `low` / `medium` / `high` / `xhigh` / `max`. GPT-5.6 maps `100` to `max`; 80–99 remains `xhigh`. Qwen 3.8 27B and Flash map 0–39 / 40–79 / 80–100 to `low` / `medium` / `xhigh`; Qwen 3.8 Flash is the managed production version based on Flash-Next. GLM 5.3 and GLM 5.3 Flash require reasoning and map those bands to `low` / `high` / `max`. Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. Gemini 3.8 Flash and 3.7 Flash support only `low` / `medium` / `high`, so the first two bands clamp to `low`; `-1` keeps their native `medium` default. 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`. Grok 4.6 maps 0–39 / 40–59 / 60–79 / 80–100 to `low` / `medium` / `high` / `xhigh`; without effort it uses native `high`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. Former `*think()` methods are removed — use `.effort(n).<model>()`. Kimi: `kimiK25()` / `kimiK26()`. Grok 4.20: `.grok420()` non-reasoning; `.effort(20+|-1).grok420()` selects reasoning.
+\* GPT-6 Astra maps 0–39 / 40–59 / 60–79 / 80–99 / 100 to `low` / `medium` / `high` / `xhigh` / `max`. GPT-6 Sol, GPT-6 Luna, and GPT-5.6 map `100` to `max` and keep `xhigh` for 80–99, with OpenAI's `none` band at 0–19. Qwen 3.8 27B and Flash map 0–39 / 40–79 / 80–100 to `low` / `medium` / `xhigh`; Qwen 3.8 Flash is the managed production version based on Flash-Next. GLM 5.3 and GLM 5.3 Flash require reasoning and map those bands to `low` / `high` / `max`. Gemini bands: 0–24 / 25–49 / 50–74 / 75–100. Gemini 3.8 Flash and 3.7 Flash support only `low` / `medium` / `high`, so the first two bands clamp to `low`; `-1` keeps their native `medium` default. 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`. Grok 4.6 maps 0–39 / 40–59 / 60–79 / 80–100 to `low` / `medium` / `high` / `xhigh`; without effort it uses native `high`. `-1` = adaptive/dynamic when available, else no-op. Levels clamp per model. Former `*think()` methods are removed — use `.effort(n).<model>()`. Kimi: `kimiK25()` / `kimiK26()`. Grok 4.20: `.grok420()` non-reasoning; `.effort(20+|-1).grok420()` selects reasoning.
 
 ## Available Model Shorthands
 
@@ -172,12 +172,12 @@ ModelMix.new({ config: { effort: 80 } })
 
 Use `ModerationMix.new().openai()` with `.raw()` to classify text and images through OpenAI's Moderations endpoint. Read the results from `raw.moderation`. `ModerationMix` accepts moderation providers as ordered fallbacks, rejects generative providers, and does not generate text or support streaming.
 
-`gpt6astra()` `gpt56sol()` `gpt56terra()` `gpt56luna()` `gpt55()` `gpt55pro()` `gpt54()` `gpt54mini()` `gpt54nano()` `gpt54pro()` `gpt53codex()` `gpt53chat()` `gpt52()` `gpt51()` `gpt5()` `gpt5mini()` `gpt5nano()` `gptRealtime()` `gptRealtimeMini()` `gptOss()`
+`gpt6astra()` `gpt6sol()` `gpt6luna()` `gpt56sol()` `gpt56terra()` `gpt56luna()` `gpt55()` `gpt55pro()` `gpt54()` `gpt54mini()` `gpt54nano()` `gpt54pro()` `gpt53codex()` `gpt53chat()` `gpt52()` `gpt51()` `gpt5()` `gpt5mini()` `gpt5nano()` `gptRealtime()` `gptRealtimeMini()` `gptOss()`
 
 Every textual GPT-5 and GPT-6 shortcut registers only the official OpenAI model by default. Pass `mix: { openrouter: true }` to `ModelMix.new()` or to an individual shortcut to append its `openai/*` OpenRouter route as a fallback. `gpt53chat()` uses `gpt-5.3-chat-latest` officially and `openai/gpt-5.3-chat` through OpenRouter. Both API keys are required when that fallback is enabled. Realtime shortcuts remain official-only.
 
 ### Anthropic
-`fable51()` `fable50()` `opus50()` `opus48()` `opus47()` `opus46()` `sonnet5()` `sonnet46()` `sonnet45()` `haiku45()`
+`fable51()` `fable50()` `opus55()` `opus50()` `opus48()` `opus47()` `opus46()` `sonnet5()` `sonnet46()` `sonnet45()` `haiku45()`
 
 Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.effort(100).opus50()`. `fable5()` and `opus5()` remain available as compatibility aliases.
 
@@ -204,6 +204,9 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 ### MiniMax
 `minimaxM27()` `minimaxM3()`
 
+### MiMo
+`mimo26pro()` — uses OpenRouter (`xiaomi/mimo-v2.6-pro`) by default; the native API requires `MIMO_API_KEY` and `mix: { mimo: true }`.
+
 ### DeepSeek
 `deepseekV41Flash({ mix: { deepseek: true, openrouter: false } })` uses the native API at `https://api.deepseek.com/chat/completions` with model `deepseek-flash` (currently V4.1 Flash). Requires `DEEPSEEK_API_KEY`; `MixDeepSeek` supports explicit `.attach()` calls. Unified effort and native cache usage are supported, and assistant reasoning is preserved for tool continuations. Cost estimates use peak rates per 1M tokens: $0.30 input, $0.006 cached input, $1.20 output; off-peak charges are half. Enabling all three providers orders them DeepSeek → Fireworks → OpenRouter.
 
@@ -408,7 +411,7 @@ console.log(model.lastRaw.think);    // reasoning content (if available)
 console.log(model.lastRaw.response); // raw API response
 ```
 
-### GPT-5.6 explicit prompt caching
+### GPT-5.6 and GPT-6 explicit prompt caching
 
 ```javascript
 const model = ModelMix.new()
@@ -431,9 +434,9 @@ const model = ModelMix.new()
 const result = await model.raw();
 ```
 
-`cache: { breakpoint: true }` is provider-neutral: GPT-5.6 receives `prompt_cache_breakpoint`, Anthropic receives `cache_control`, and unsupported providers omit it. Keep native request policies inside each model shorthand so they do not leak across fallbacks. Anthropic usage separates `cacheWrite5m` and `cacheWrite1h`; `cacheWrite` stays as their compatible aggregate.
+`cache: { breakpoint: true }` is provider-neutral: GPT-5.6 and GPT-6 receive `prompt_cache_breakpoint`, Anthropic receives `cache_control`, and unsupported providers omit it. Keep native request policies inside each model shorthand so they do not leak across fallbacks. Anthropic usage separates `cacheWrite5m` and `cacheWrite1h`; `cacheWrite` stays as their compatible aggregate.
 
-GPT-5.6 replaces `prompt_cache_retention` with `prompt_cache_options.ttl`. Explicit breakpoints also work on image methods and Responses-native `input_text`, `input_image`, and `input_file` blocks. Prompts need at least 1,024 tokens to be cached. Requests over 272K input tokens use 2× input and 1.5× output prices for the complete request; ModelMix applies these multipliers to `cost`, `costBreakdown`, and cache economics.
+GPT-5.6 and GPT-6 replace `prompt_cache_retention` with `prompt_cache_options.ttl`. Explicit breakpoints also work on image methods and Responses-native `input_text`, `input_image`, and `input_file` blocks. Prompts need at least 1,024 tokens to be cached. Requests over 272K input tokens use 2× input and 1.5× output prices for the complete request; ModelMix applies these multipliers to `cost`, `costBreakdown`, and cache economics.
 
 ### Add images
 

package/test/anthropic.test.js

@@ -122,6 +122,15 @@ describe('Anthropic Model Registration Tests', () => {
         expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
     });
 
+    it('should register Claude Opus 5.5', () => {
+        const model = ModelMix.new();
+        model.opus55();
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('claude-opus-5-5');
+        expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
+    });
+
     it('should keep opus5() as an alias for opus50()', () => {
         const model = ModelMix.new();
 
@@ -147,9 +156,21 @@ describe('Anthropic Model Registration Tests', () => {
         expect(options.thinking).to.deep.equal({ type: 'adaptive', display: 'summarized' });
     });
 
+    it('should apply max effort thinking via .effort(100).opus55()', () => {
+        const model = ModelMix.new().effort(100).opus55();
+        const { applyUnifiedEffort } = require('../effort.js');
+
+        expect(model.config.effort).to.equal(100);
+        const options = { model: 'claude-opus-5-5' };
+        applyUnifiedEffort(options, model.config, 'anthropic', 'claude-opus-5-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)', () => {
         it('should detect models that reject sampling params', () => {
             expect(MixAnthropic.rejectsSamplingParams('claude-opus-5')).to.equal(true);
+            expect(MixAnthropic.rejectsSamplingParams('claude-opus-5-5')).to.equal(true);
             expect(MixAnthropic.rejectsSamplingParams('claude-opus-4-8')).to.equal(true);
             expect(MixAnthropic.rejectsSamplingParams('claude-opus-4-7')).to.equal(true);
             expect(MixAnthropic.rejectsSamplingParams('claude-sonnet-5')).to.equal(true);

package/test/effort.test.js

@@ -90,6 +90,15 @@ describe('Unified effort scale', () => {
             }
         });
 
+        it('maps GPT-6 Sol and Luna effort from none to max', () => {
+            for (const model of ['gpt-6-sol', 'gpt-6-luna']) {
+                for (const [effort, level] of [[0, 'none'], [20, 'low'], [40, 'medium'], [60, 'high'], [99, 'xhigh'], [100, 'max']]) {
+                    expect(mapEffort('openai', effort, model)).to.deep.equal({ reasoning_effort: level });
+                }
+                expect(mapEffort('openai', 100, `openai/${model}`)).to.deep.equal({ reasoning_effort: 'max' });
+            }
+        });
+
         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);
@@ -197,6 +206,10 @@ describe('Unified effort scale', () => {
                 thinking: { type: 'adaptive', display: 'summarized' },
                 output_config: { effort: 'low' }
             });
+            expect(mapEffort('anthropic', 50, 'claude-opus-5-5')).to.deep.equal({
+                thinking: { type: 'adaptive', display: 'summarized' },
+                output_config: { effort: 'high' }
+            });
             expect(mapEffort('anthropic', 90, 'claude-fable-5-1')).to.deep.equal({
                 thinking: { type: 'adaptive', display: 'summarized' },
                 output_config: { effort: 'max' }

package/test/fallback.test.js

@@ -115,6 +115,8 @@ describe('Provider Fallback Chain Tests', () => {
             expect(ModelMix.new().mix.openrouter).to.equal(false);
             const shortcuts = [
                 ['gpt6astra', 'gpt-6-astra', 'openai/gpt-6-astra', MixOpenAIResponses],
+                ['gpt6sol', 'gpt-6-sol', 'openai/gpt-6-sol', MixOpenAIResponses],
+                ['gpt6luna', 'gpt-6-luna', 'openai/gpt-6-luna', MixOpenAIResponses],
                 ['gpt5', 'gpt-5', 'openai/gpt-5', MixOpenAI],
                 ['gpt5mini', 'gpt-5-mini', 'openai/gpt-5-mini', MixOpenAI],
                 ['gpt5nano', 'gpt-5-nano', 'openai/gpt-5-nano', MixOpenAI],
@@ -232,6 +234,48 @@ describe('Provider Fallback Chain Tests', () => {
             expect(openRouterRequest).to.not.have.property('temperature');
         });
 
+        it('should fallback from the official GPT-6 Sol and Luna endpoints to OpenRouter', async () => {
+            const cases = [
+                ['gpt6sol', 'gpt-6-sol', 'Hello from GPT-6 Sol through OpenRouter!'],
+                ['gpt6luna', 'gpt-6-luna', 'Hello from GPT-6 Luna through OpenRouter!']
+            ];
+
+            for (const [shortcut, officialKey, content] of cases) {
+                let openRouterRequest;
+                const instance = ModelMix.new().effort(100);
+                instance[shortcut]({ mix: { openrouter: true } }).addText('Hello');
+
+                nock('https://api.openai.com')
+                    .post('/v1/responses', body => {
+                        expect(body.model).to.equal(officialKey);
+                        expect(body.reasoning).to.deep.equal({ effort: 'max' });
+                        expect(body.max_output_tokens).to.equal(8192);
+                        expect(body).to.not.have.property('temperature');
+                        return true;
+                    })
+                    .reply(503, { error: 'Service unavailable' });
+
+                nock('https://openrouter.ai')
+                    .post('/api/v1/chat/completions', body => {
+                        openRouterRequest = body;
+                        return true;
+                    })
+                    .reply(200, {
+                        choices: [{
+                            message: {
+                                role: 'assistant',
+                                content
+                            }
+                        }]
+                    });
+
+                expect(await instance.message()).to.equal(content);
+                expect(openRouterRequest.model).to.equal(`openai/${officialKey}`);
+                expect(openRouterRequest.max_completion_tokens).to.equal(8192);
+                expect(openRouterRequest).to.not.have.property('temperature');
+            }
+        });
+
         it('should keep the default fable51 chain on Anthropic', () => {
             model.chain('fable51@80');
 

package/test/provider-expansion.test.js

@@ -1,7 +1,9 @@
 const { expect } = require('chai');
+const nock = require('nock');
 const {
     ModelMix,
     MixFireworks,
+    MixMiMo,
     MixMiniMax,
     MixNVIDIA,
     MixOpenRouter,
@@ -97,4 +99,29 @@ describe('Provider expansion regressions', () => {
         expect(model.models[0].key).to.equal('accounts/fireworks/models/minimax-m3');
         expect(model.models[0].provider).to.be.instanceOf(MixFireworks);
     });
+
+    it('should send MiMo 2.6 Pro requests to the native MiMo API', async () => {
+        const api = nock('https://api.xiaomimimo.com')
+            .post('/v1/chat/completions', body => {
+                expect(body.model).to.equal('mimo-v2.6-pro');
+                return true;
+            })
+            .reply(200, {
+                choices: [{ message: { content: 'ok' } }],
+                usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }
+            });
+
+        const model = ModelMix.new().mimo26pro({
+            mix: { mimo: true, openrouter: false },
+            config: { apiKey: 'test-mimo-key' }
+        });
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].provider).to.be.instanceOf(MixMiMo);
+
+        const response = await model.addText('Hi').message();
+
+        expect(response).to.equal('ok');
+        api.done();
+    });
 });

package/test/tokens.test.js

@@ -252,29 +252,35 @@ describe('Token Usage Tracking', () => {
         ]);
     });
 
-    it('should translate neutral cache breakpoints for GPT-5.6 and filter them for older models', async function () {
+    it('should translate neutral cache breakpoints for GPT-5.6 and GPT-6 and filter them for older models', async function () {
         const breakpoint = { mode: 'explicit' };
         const model = ModelMix.new()
             .addText('Stable text', { role: 'developer', cache: { breakpoint: true } })
             .addImageFromUrl('data:image/png;base64,AAAA', { cache: { breakpoint: true } });
         const messages = await model.prepareMessages();
-        const gpt56Request = MixOpenAIResponses.buildResponsesRequest({
-            model: 'gpt-5.6-luna',
-            messages,
-            prompt_cache_options: { mode: 'explicit', ttl: '30m' }
-        });
-        const olderRequest = MixOpenAIResponses.buildResponsesRequest({
-            model: 'gpt-5.4',
-            messages
-        });
 
         expect(messages[0].content[0]).to.deep.include({ cache: { breakpoint: true } });
         expect(messages[0].content[0]).to.not.have.property('prompt_cache_breakpoint');
-        expect(gpt56Request.input[0].content[0].prompt_cache_breakpoint).to.deep.equal(breakpoint);
-        expect(gpt56Request.input[1].content[0]).to.deep.equal({
-            type: 'input_image',
-            image_url: 'data:image/png;base64,AAAA',
-            prompt_cache_breakpoint: breakpoint
+
+        for (const key of ['gpt-5.6-luna', 'gpt-6-astra', 'gpt-6-sol', 'gpt-6-luna']) {
+            const request = MixOpenAIResponses.buildResponsesRequest({
+                model: key,
+                messages,
+                prompt_cache_options: { mode: 'explicit', ttl: '30m' }
+            });
+
+            expect(request.prompt_cache_options).to.deep.equal({ mode: 'explicit', ttl: '30m' });
+            expect(request.input[0].content[0].prompt_cache_breakpoint).to.deep.equal(breakpoint);
+            expect(request.input[1].content[0]).to.deep.equal({
+                type: 'input_image',
+                image_url: 'data:image/png;base64,AAAA',
+                prompt_cache_breakpoint: breakpoint
+            });
+        }
+
+        const olderRequest = MixOpenAIResponses.buildResponsesRequest({
+            model: 'gpt-5.4',
+            messages
         });
         expect(olderRequest.input[0].content[0]).to.not.have.property('cache');
         expect(olderRequest.input[0].content[0]).to.not.have.property('prompt_cache_breakpoint');
@@ -347,6 +353,12 @@ describe('Token Usage Tracking', () => {
             prompt_cache_retention: '24h'
         })).to.throw('prompt_cache_options.ttl');
 
+        expect(() => MixOpenAIResponses.buildResponsesRequest({
+            model: 'gpt-6-sol',
+            messages: [{ role: 'user', content: 'Hi' }],
+            prompt_cache_retention: '24h'
+        })).to.throw('prompt_cache_options.ttl');
+
         expect(() => MixOpenAIResponses.buildResponsesRequest({
             model: 'gpt-5.4',
             messages: [{ role: 'user', content: 'Hi' }],
@@ -417,6 +429,35 @@ describe('Token Usage Tracking', () => {
         }
     });
 
+    it('should register GPT-6 Sol and Luna shortcuts with OpenAI Responses provider', function () {
+        const model = ModelMix.new({ mix: { openrouter: true } })
+            .gpt6sol()
+            .gpt6luna();
+
+        expect(model.models.map(({ key }) => key)).to.deep.equal([
+            'gpt-6-sol',
+            'openai/gpt-6-sol',
+            'gpt-6-luna',
+            'openai/gpt-6-luna'
+        ]);
+        expect(model.models[0].provider).to.be.instanceOf(MixOpenAIResponses);
+        expect(model.models[1].provider).to.be.instanceOf(MixOpenRouter);
+        expect(model.models[2].provider).to.be.instanceOf(MixOpenAIResponses);
+        expect(model.models[3].provider).to.be.instanceOf(MixOpenRouter);
+    });
+
+    it('should account for GPT-6 Sol and Luna cache usage and the long-context boundary', function () {
+        const tokens = { input: 272_000, cached: 100_000, cacheWrite: 20_000, output: 1_000 };
+        for (const key of ['gpt-6-sol', 'openai/gpt-6-sol']) {
+            expect(ModelMix.calculateCost(key, tokens)).to.be.closeTo(0.384, 1e-10);
+            expect(ModelMix.calculateCost(key, { ...tokens, input: 272_001 })).to.be.closeTo(0.763004, 1e-10);
+        }
+        for (const key of ['gpt-6-luna', 'openai/gpt-6-luna']) {
+            expect(ModelMix.calculateCost(key, tokens)).to.be.closeTo(0.0192, 1e-10);
+            expect(ModelMix.calculateCost(key, { ...tokens, input: 272_001 })).to.be.closeTo(0.0381502, 1e-10);
+        }
+    });
+
     it('should register GPT-5.6 shortcuts with OpenAI Responses provider', function () {
         const model = ModelMix.new({ mix: { openrouter: true } })
             .gpt56sol()
@@ -437,8 +478,8 @@ describe('Token Usage Tracking', () => {
         expect(model.models[3].provider).to.be.instanceOf(MixOpenRouter);
         expect(model.models[4].provider).to.be.instanceOf(MixOpenAIResponses);
         expect(model.models[5].provider).to.be.instanceOf(MixOpenRouter);
-        expect(ModelMix.calculateCost('gpt-5.6-sol', { input: 1_000_000, output: 1_000_000 })).to.equal(55);
-        expect(ModelMix.calculateCost('openai/gpt-5.6-sol', { input: 1_000_000, output: 1_000_000 })).to.equal(55);
+        expect(ModelMix.calculateCost('gpt-5.6-sol', { input: 1_000_000, output: 1_000_000 })).to.equal(38);
+        expect(ModelMix.calculateCost('openai/gpt-5.6-sol', { input: 1_000_000, output: 1_000_000 })).to.equal(38);
         expect(ModelMix.calculateCost('gpt-5.6-terra', { input: 1_000_000, output: 1_000_000 })).to.equal(22);
         expect(ModelMix.calculateCost('gpt-5.6-luna', { input: 1_000_000, output: 1_000_000 })).to.equal(2.2);
         expect(ModelMix.calculateCost('openai/gpt-5.3-chat', { input: 1_000_000, output: 1_000_000 })).to.equal(15.75);
@@ -674,6 +715,38 @@ describe('Token Usage Tracking', () => {
         }
     });
 
+    it('should register MiMo 2.6 Pro with native and OpenRouter providers', function () {
+        const originalMimoApiKey = process.env.MIMO_API_KEY;
+        const originalOpenRouterApiKey = process.env.OPENROUTER_API_KEY;
+
+        process.env.MIMO_API_KEY = 'test-mimo-key';
+        process.env.OPENROUTER_API_KEY = 'test-openrouter-key';
+
+        try {
+            const model = ModelMix.new().mimo26pro();
+            const withNative = ModelMix.new()
+                .mimo26pro({ mix: { mimo: true, openrouter: true } });
+
+            expect(model.models.map(({ key }) => key)).to.deep.equal(['xiaomi/mimo-v2.6-pro']);
+            expect(model.models[0].provider).to.be.instanceOf(MixOpenRouter);
+
+            expect(withNative.models.map(({ key }) => key)).to.deep.equal([
+                'mimo-v2.6-pro',
+                'xiaomi/mimo-v2.6-pro'
+            ]);
+            expect(withNative.models[0].provider).to.be.instanceOf(MixMiMo);
+            expect(withNative.models[1].provider).to.be.instanceOf(MixOpenRouter);
+
+            expect(ModelMix.new().chain('mimo26pro').models[0].key).to.equal('xiaomi/mimo-v2.6-pro');
+        } finally {
+            if (originalMimoApiKey === undefined) delete process.env.MIMO_API_KEY;
+            else process.env.MIMO_API_KEY = originalMimoApiKey;
+
+            if (originalOpenRouterApiKey === undefined) delete process.env.OPENROUTER_API_KEY;
+            else process.env.OPENROUTER_API_KEY = originalOpenRouterApiKey;
+        }
+    });
+
     it('should register GPT-OSS 120B through the current OpenRouter model ID', function () {
         const originalOpenRouterApiKey = process.env.OPENROUTER_API_KEY;
         process.env.OPENROUTER_API_KEY = 'test-openrouter-key';