modelmix 5.2.1 → 5.2.3

package/README.md

@@ -179,6 +179,7 @@ ModelMix provides convenient shorthand methods for quickly accessing different A
 | `gptOss()` | Multi-provider | gpt-oss-120B | [\$0.15][7] | [\$0.60][7] |
 | `fable51()` | Anthropic | claude-fable-5-1 | [\$10.00][2] | [\$50.00][2] |
 | `fable5()` | Anthropic | claude-fable-5 | [\$10.00][2] | [\$50.00][2] |
+| `opus55()` | Anthropic | claude-opus-5-5 | [\$5.00][2] | [\$25.00][2] |
 | `opus5()` | Anthropic | claude-opus-5 | [\$5.00][2] | [\$25.00][2] |
 | `opus48()` | Anthropic | claude-opus-4-8 | [\$5.00][2] | [\$25.00][2] |
 | `opus47()` | Anthropic | claude-opus-4-7 | [\$5.00][2] | [\$25.00][2] |
@@ -193,6 +194,7 @@ ModelMix provides convenient shorthand methods for quickly accessing different A
 | `gemini35flash()` | Google | gemini-3.5-flash | [\$0.75][3] | [\$4.50][3] |
 | `gemini35flashLite()` | Google | gemini-3.5-flash-lite | [\$0.30][3] | [\$2.50][3] |
 | `gemini31flashLite()` | Google | gemini-3.1-flash-lite-preview | [\$0.25][3] | [\$1.50][3] |
+| `grok47()` | Grok | grok-4.7 | — | — |
 | `grok46()` | Grok | grok-4.6 | [\$2.00][6] | [\$6.00][6] |
 | `grok45()` | Grok | grok-4.5 | [\$2.00][6] | [\$6.00][6] |
 | `grok43()` | Grok | grok-4.3 | [\$1.25][6] | [\$2.50][6] |
@@ -218,6 +220,7 @@ ModelMix provides convenient shorthand methods for quickly accessing different A
 | `GLM52()` | Together | zai-org/GLM-5.2 | [\$1.40][7] | [\$4.40][7] |
 | `minimaxM3()` | MiniMax | MiniMax-M3 | [\$0.30][9] | [\$1.20][9] |
 | `minimaxM27()` | MiniMax | MiniMax-M2.7 | [\$0.30][9] | [\$1.20][9] |
+| `mimo26pro()` | MiMo | mimo-v2.6-pro | — | — |
 | `sonar()` | Perplexity | sonar | [\$1.00][4] | [\$1.00][4] |
 | `sonarPro()` | Perplexity | sonar-pro | [\$3.00][4] | [\$15.00][4] |
 | `hermes470b()` | OpenRouter | nousresearch/hermes-4-70b | [\$0.13][13] | [\$0.40][13] |

package/demo/grok.js

@@ -13,7 +13,7 @@ const mmix = new ModelMix({
 });
 
 
-const r = await mmix.grok46()
+const r = await mmix.grok47()
     .addText('hi there!')
     .addText('do you like cats?')
     .raw();

package/index.d.ts

@@ -470,6 +470,7 @@ export declare class ModelMix {
   fable51(args?: ModelAttachArgs): this;
   fable50(args?: ModelAttachArgs): this;
   fable5(args?: ModelAttachArgs): this;
+  opus55(args?: ModelAttachArgs): this;
   opus50(args?: ModelAttachArgs): this;
   opus5(args?: ModelAttachArgs): this;
   opus48(args?: ModelAttachArgs): this;
@@ -495,6 +496,7 @@ export declare class ModelMix {
   sonar(args?: ModelAttachArgs): this;
 
   // Grok
+  grok47(args?: ModelAttachArgs): this;
   grok46(args?: ModelAttachArgs): this;
   grok45(args?: ModelAttachArgs): this;
   grok43(args?: ModelAttachArgs): this;
@@ -526,6 +528,7 @@ export declare class ModelMix {
   minimaxM3(args?: ModelAttachArgs): this;
   mimo25(args?: ModelAttachArgs): this;
   mimo25pro(args?: ModelAttachArgs): this;
+  mimo26pro(args?: ModelAttachArgs): this;
   deepseekV4Pro(args?: ModelAttachArgs): this;
   /** Uses deepseek/deepseek-v4-pro-0813 through OpenRouter. */
   deepseekPro(args?: ModelAttachArgs): this;

package/index.js

@@ -545,6 +545,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 }));
     }
@@ -603,6 +606,9 @@ class ModelMix {
         return this.attach('sonar', new MixPerplexity({ options, config }));
     }
 
+    grok47({ options = {}, config = {} } = {}) {
+        return this.attach('grok-4.7', new MixGrok({ options, config }));
+    }
     grok46({ options = {}, config = {} } = {}) {
         return this.attach('grok-4.6', new MixGrok({ options, config }));
     }
@@ -766,6 +772,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

@@ -5,16 +5,16 @@ const CHAIN_MODEL_SHORTCUTS = new Set([
     'gpt51', 'gpt52', 'gpt54', 'gpt54mini', 'gpt54nano', 'gpt54pro',
     'gpt6astra', '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',
-    'grok46', 'grok45', 'grok43', 'grok420multiAgent', 'grok420',
+    'grok47', 'grok46', 'grok45', 'grok43', 'grok420multiAgent', 'grok420',
     'museGlimmer30b', 'museSpark12', 'museSpark12c', 'museSpark13', 'museSpark13c',
     '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/token-usage.js

@@ -53,6 +53,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.1",
+  "version": "5.2.3",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "types": "index.d.ts",

package/skills/modelmix/SKILL.md

@@ -177,7 +177,7 @@ Use `ModerationMix.new().openai()` with `.raw()` to classify text and images thr
 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.
 
@@ -187,7 +187,7 @@ Use `.effort(n)` (or `config.effort`) to enable Anthropic thinking — e.g. `.ef
 `gemini31pro()` `gemini38flash()` `gemini37flash()` `gemini36flash()` `gemini35flash()` `gemini35flashLite()` `gemini31flashLite()`
 
 ### Grok
-`grok46()` `grok45()` `grok43()` `grok420multiAgent()` `grok420()`
+`grok47()` `grok46()` `grok45()` `grok43()` `grok420multiAgent()` `grok420()`
 
 ### Perplexity
 `sonar()` `sonarPro()`
@@ -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.
 

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

@@ -197,6 +197,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/grok.test.js

@@ -11,6 +11,7 @@ const {
 
 describe('Grok Model Registration Tests', () => {
     const grokModels = [
+        { method: 'grok47', key: 'grok-4.7' },
         { method: 'grok46', key: 'grok-4.6' },
         { method: 'grok45', key: 'grok-4.5' },
         { method: 'grok43', key: 'grok-4.3' },
@@ -38,6 +39,38 @@ describe('Grok Model Registration Tests', () => {
         expect(model.models[0].provider.config).to.include(config);
     });
 
+    it('supports Grok 4.7 in chain() and preserves attachment options', () => {
+        const options = { temperature: 0.5 };
+        const config = { max_history: 3 };
+        const model = ModelMix.new().grok47({ options, config });
+
+        expect(model.models[0].provider).to.be.instanceOf(MixGrok);
+        expect(model.models[0].provider.options).to.deep.equal(options);
+        expect(model.models[0].provider.config).to.include(config);
+        expect(ModelMix.new().chain('grok47').models[0].key).to.equal('grok-4.7');
+    });
+
+    it('sends Grok 4.7 requests to xAI', async () => {
+        const api = nock('https://api.x.ai')
+            .post('/v1/chat/completions', body => {
+                expect(body.model).to.equal('grok-4.7');
+                expect(body.temperature).to.equal(0.5);
+                return true;
+            })
+            .reply(200, {
+                choices: [{ message: { content: 'ok' } }],
+                usage: { prompt_tokens: 1, completion_tokens: 1, total_tokens: 2 }
+            });
+
+        const response = await ModelMix.new()
+            .grok47({ options: { temperature: 0.5 }, config: { apiKey: 'test-key' } })
+            .addText('Hi')
+            .message();
+
+        expect(response).to.equal('ok');
+        api.done();
+    });
+
     it('maps unified effort to Grok 4.6 supported levels', () => {
         expect(mapEffort('openai', 0, 'grok-4.6')).to.deep.equal({ reasoning_effort: 'low' });
         expect(mapEffort('openai', 39, 'grok-4.6')).to.deep.equal({ reasoning_effort: 'low' });

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

@@ -674,6 +674,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';