modelmix 5.1.10 → 5.1.15

package/test/anthropic.test.js

@@ -1,8 +1,84 @@
 const { expect } = require('chai');
 const nock = require('nock');
-const { ModelMix, MixAnthropic } = require('../index.js');
+const { ModelMix, MixAnthropic, MixOpenRouter } = require('../index.js');
 
 describe('Anthropic Model Registration Tests', () => {
+    it('should register Claude Fable 5.1 through Anthropic by default', () => {
+        const model = ModelMix.new().fable51();
+
+        expect(model.models.map(({ key }) => key)).to.deep.equal(['claude-fable-5-1']);
+        expect(model.models[0].provider).to.be.instanceOf(MixAnthropic);
+    });
+
+    it('should allow enabling or selecting the OpenRouter Claude Fable 5.1 route', () => {
+        const both = ModelMix.new().fable51({ mix: { openrouter: true } });
+        const routed = ModelMix.new().fable51({
+            mix: { anthropic: false, openrouter: true }
+        });
+
+        expect(both.models.map(({ key }) => key)).to.deep.equal([
+            'claude-fable-5-1',
+            'anthropic/claude-fable-5.1'
+        ]);
+        expect(both.models[1].provider).to.be.instanceOf(MixOpenRouter);
+        expect(routed.models.map(({ key }) => key)).to.deep.equal(['anthropic/claude-fable-5.1']);
+        expect(routed.models[0].provider).to.be.instanceOf(MixOpenRouter);
+    });
+
+    it('should strip unsupported sampling params from OpenRouter Claude Fable 5.1 requests', async () => {
+        const provider = new MixOpenRouter();
+        let requestBody;
+        nock('https://openrouter.ai')
+            .post('/api/v1/chat/completions', body => {
+                requestBody = body;
+                return true;
+            })
+            .reply(200, {
+                choices: [{ message: { content: 'Done' } }],
+                usage: { prompt_tokens: 1, completion_tokens: 1 }
+            });
+
+        await provider.create({
+            config: { system: 'You are an assistant.' },
+            options: {
+                model: 'anthropic/claude-fable-5.1',
+                messages: [{ role: 'user', content: 'Hello' }],
+                max_tokens: 100,
+                temperature: 1,
+                top_p: 0.9,
+                top_k: 40
+            }
+        });
+
+        expect(requestBody).to.not.have.property('temperature');
+        expect(requestBody).to.not.have.property('top_p');
+        expect(requestBody).to.not.have.property('top_k');
+        expect(requestBody.model).to.equal('anthropic/claude-fable-5.1');
+    });
+
+    it('should price Claude Fable 5.1 cache usage equally across providers', () => {
+        const tokens = {
+            input: 3_000_000,
+            uncachedInput: 1_000_000,
+            cached: 1_000_000,
+            cacheWrite: 1_000_000,
+            cacheWrite5m: 1_000_000,
+            output: 1_000_000
+        };
+        const expected = {
+            uncachedInput: 10,
+            cachedInput: 0.25,
+            cacheWrite: 12.5,
+            cacheWrite5m: 12.5,
+            cacheWrite1h: 0,
+            output: 50,
+            total: 72.75
+        };
+
+        expect(ModelMix.calculateCostBreakdown('claude-fable-5-1', tokens)).to.deep.equal(expected);
+        expect(ModelMix.calculateCostBreakdown('anthropic/claude-fable-5.1', tokens)).to.deep.equal(expected);
+    });
+
     it('should register Claude Fable 5', () => {
         const model = ModelMix.new();
         model.fable50();

package/test/bottleneck.test.js

@@ -247,7 +247,7 @@ describe('Rate Limiting with Bottleneck Tests', () => {
         });
 
         it('should handle rate limiting with API errors', async () => {
-            model.gpt51();
+            model.gpt51({ mix: { openrouter: false } });
             
             nock('https://api.openai.com')
                 .post('/v1/responses')
@@ -455,4 +455,4 @@ describe('Rate Limiting with Bottleneck Tests', () => {
             model.addText('Event test').message();
         });
     });
-});
+});

package/test/effort.test.js

@@ -77,6 +77,7 @@ describe('Unified effort scale', () => {
             expect(mapEffort('openai', 99, 'gpt-5.6-luna')).to.deep.equal({ reasoning_effort: 'xhigh' });
             for (const model of ['gpt-5.6-sol', 'gpt-5.6-terra', 'gpt-5.6-luna']) {
                 expect(mapEffort('openai', 100, model)).to.deep.equal({ reasoning_effort: 'max' });
+                expect(mapEffort('openai', 100, `openai/${model}`)).to.deep.equal({ reasoning_effort: 'max' });
             }
         });
 
@@ -87,6 +88,8 @@ describe('Unified effort scale', () => {
 
         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, 'openai/gpt-5.3-codex')).to.deep.equal({ reasoning_effort: 'low' });
+            expect(mapEffort('openai', 0, 'openai/gpt-5')).to.deep.equal({ reasoning_effort: 'minimal' });
             expect(mapEffort('openai', 10, 'gpt-oss-120b')).to.deep.equal({ reasoning_effort: 'low' });
         });
 
@@ -132,6 +135,16 @@ describe('Unified effort scale', () => {
             });
         });
 
+        it('maps Muse Spark 1.2 Contributor to every supported reasoning level', () => {
+            const key = 'meta/muse-spark-1.2-contributor';
+            expect(mapEffort('openai', 0, key)).to.deep.equal({ reasoning_effort: 'minimal' });
+            expect(mapEffort('openai', 20, key)).to.deep.equal({ reasoning_effort: 'low' });
+            expect(mapEffort('openai', 40, key)).to.deep.equal({ reasoning_effort: 'medium' });
+            expect(mapEffort('openai', 60, key)).to.deep.equal({ reasoning_effort: 'high' });
+            expect(mapEffort('openai', 80, key)).to.deep.equal({ reasoning_effort: 'xhigh' });
+            expect(mapEffort('openai', -1, key)).to.equal(null);
+        });
+
         it('maps Qwen 3.8 27B to its supported reasoning levels', () => {
             const key = 'qwen/qwen3.8-27b';
             expect(mapEffort('openai', 0, key)).to.deep.equal({ reasoning_effort: 'low' });
@@ -171,7 +184,7 @@ describe('Unified effort scale', () => {
                 thinking: { type: 'adaptive', display: 'summarized' },
                 output_config: { effort: 'low' }
             });
-            expect(mapEffort('anthropic', 90, 'claude-fable-5')).to.deep.equal({
+            expect(mapEffort('anthropic', 90, 'claude-fable-5-1')).to.deep.equal({
                 thinking: { type: 'adaptive', display: 'summarized' },
                 output_config: { effort: 'max' }
             });
@@ -181,6 +194,16 @@ describe('Unified effort scale', () => {
             });
         });
 
+        it('maps OpenRouter Claude Fable 5.1 to Anthropic effort levels', () => {
+            const key = 'anthropic/claude-fable-5.1';
+            expect(mapEffort('openai', 0, key)).to.deep.equal({ reasoning_effort: 'low' });
+            expect(mapEffort('openai', 20, key)).to.deep.equal({ reasoning_effort: 'medium' });
+            expect(mapEffort('openai', 40, key)).to.deep.equal({ reasoning_effort: 'high' });
+            expect(mapEffort('openai', 60, key)).to.deep.equal({ reasoning_effort: 'xhigh' });
+            expect(mapEffort('openai', 80, key)).to.deep.equal({ reasoning_effort: 'max' });
+            expect(mapEffort('openai', -1, key)).to.equal(null);
+        });
+
         it('maps Anthropic manual models to thinking.type=enabled + budget_tokens', () => {
             expect(mapEffort('anthropic', 50, 'claude-sonnet-4-5-20250929')).to.deep.equal({
                 thinking: { type: 'enabled', budget_tokens: 8192 }

package/test/fallback.test.js

@@ -3,7 +3,14 @@ const sinon = require('sinon');
 const nock = require('nock');
 const { EventEmitter } = require('events');
 const Module = require('module');
-const { MixCustom, MixGoogle, ModelMix } = require('../index.js');
+const {
+    MixCustom,
+    MixGoogle,
+    MixOpenAI,
+    MixOpenAIResponses,
+    MixOpenRouter,
+    ModelMix
+} = require('../index.js');
 
 describe('Provider Fallback Chain Tests', () => {
     
@@ -47,6 +54,99 @@ describe('Provider Fallback Chain Tests', () => {
             expect(model.models[1].provider.config.effort).to.equal(20);
         });
 
+        it('should register every supported OpenAI text shortcut with its OpenRouter fallback', () => {
+            expect(ModelMix.new().mix.openrouter).to.equal(false);
+            const shortcuts = [
+                ['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],
+                ['gpt51', 'gpt-5.1', 'openai/gpt-5.1', MixOpenAIResponses],
+                ['gpt52', 'gpt-5.2', 'openai/gpt-5.2', MixOpenAIResponses],
+                ['gpt53codex', 'gpt-5.3-codex', 'openai/gpt-5.3-codex', MixOpenAIResponses],
+                ['gpt53chat', 'gpt-5.3-chat-latest', 'openai/gpt-5.3-chat', MixOpenAIResponses],
+                ['gpt54', 'gpt-5.4', 'openai/gpt-5.4', MixOpenAIResponses],
+                ['gpt54mini', 'gpt-5.4-mini', 'openai/gpt-5.4-mini', MixOpenAIResponses],
+                ['gpt54nano', 'gpt-5.4-nano', 'openai/gpt-5.4-nano', MixOpenAIResponses],
+                ['gpt54pro', 'gpt-5.4-pro', 'openai/gpt-5.4-pro', MixOpenAIResponses],
+                ['gpt55', 'gpt-5.5', 'openai/gpt-5.5', MixOpenAIResponses],
+                ['gpt55pro', 'gpt-5.5-pro', 'openai/gpt-5.5-pro', MixOpenAIResponses],
+                ['gpt56sol', 'gpt-5.6-sol', 'openai/gpt-5.6-sol', MixOpenAIResponses],
+                ['gpt56terra', 'gpt-5.6-terra', 'openai/gpt-5.6-terra', MixOpenAIResponses],
+                ['gpt56luna', 'gpt-5.6-luna', 'openai/gpt-5.6-luna', MixOpenAIResponses]
+            ];
+
+            for (const [shortcut, officialKey, openRouterKey, OfficialProvider] of shortcuts) {
+                const official = ModelMix.new()[shortcut]();
+                expect(official.models.map(({ key }) => key)).to.deep.equal([officialKey]);
+                expect(official.models[0].provider).to.be.instanceOf(OfficialProvider);
+
+                const routed = ModelMix.new()[shortcut]({ mix: { openrouter: true } });
+                expect(routed.models.map(({ key }) => key)).to.deep.equal([officialKey, openRouterKey]);
+                expect(routed.models[0].provider).to.be.instanceOf(OfficialProvider);
+                expect(routed.models[1].provider).to.be.instanceOf(MixOpenRouter);
+
+                const globallyRouted = ModelMix.new({ mix: { openrouter: true } })[shortcut]();
+                expect(globallyRouted.models.map(({ key }) => key)).to.deep.equal([officialKey, openRouterKey]);
+            }
+
+            const locallyDisabled = ModelMix.new({ mix: { openrouter: true } })
+                .gpt56sol({ mix: { openrouter: false } });
+            expect(locallyDisabled.models.map(({ key }) => key)).to.deep.equal(['gpt-5.6-sol']);
+
+            const inherited = ModelMix.new({ mix: { openrouter: true } }).new().gpt5();
+            expect(inherited.models.map(({ key }) => key)).to.deep.equal([
+                'gpt-5',
+                'openai/gpt-5'
+            ]);
+        });
+
+        it('should append OpenRouter GPT fallbacks in chain() only when enabled globally', () => {
+            const official = ModelMix.new().chain('gpt56sol@100');
+            expect(official.models.map(({ key }) => key)).to.deep.equal(['gpt-5.6-sol']);
+
+            const routed = ModelMix.new({ mix: { openrouter: true } }).chain('gpt56sol@100');
+            expect(routed.models.map(({ key }) => key)).to.deep.equal([
+                'gpt-5.6-sol',
+                'openai/gpt-5.6-sol'
+            ]);
+            expect(routed.models.map(({ provider }) => provider.config.effort)).to.deep.equal([100, 100]);
+        });
+
+        it('should fallback from the official GPT-5.6 Sol endpoint to OpenRouter', async () => {
+            let openRouterRequest;
+            model.gpt56sol({ mix: { openrouter: true } }).addText('Hello');
+
+            nock('https://api.openai.com')
+                .post('/v1/responses')
+                .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: 'Hello from GPT-5.6 Sol through OpenRouter!'
+                        }
+                    }]
+                });
+
+            expect(await model.message()).to.equal('Hello from GPT-5.6 Sol through OpenRouter!');
+            expect(openRouterRequest.model).to.equal('openai/gpt-5.6-sol');
+            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');
+
+            expect(model.models.map(({ key }) => key)).to.deep.equal(['claude-fable-5-1']);
+            expect(model.models[0].provider.config.effort).to.equal(80);
+        });
+
         it('should reject invalid chains before attaching any model', () => {
             expect(() => model.chain('gpt56luna', 'unknownModel'))
                 .to.throw('Unknown model shortcut "unknownModel" in chain().');

package/test/glm.test.js

@@ -2,16 +2,12 @@ const { expect } = require('chai');
 const { ModelMix, MixFireworks, MixOpenRouter, MixTogether } = require('../index.js');
 
 describe('GLM Model Registration Tests', () => {
-    it('should register Together GLM 5.2 before the OpenRouter fallback by default', () => {
+    it('should register only Together GLM 5.2 by default', () => {
         const model = ModelMix.new();
         model.GLM52();
 
-        expect(model.models.map(({ key }) => key)).to.deep.equal([
-            'zai-org/GLM-5.2',
-            'z-ai/glm-5.2'
-        ]);
+        expect(model.models.map(({ key }) => key)).to.deep.equal(['zai-org/GLM-5.2']);
         expect(model.models[0].provider).to.be.instanceOf(MixTogether);
-        expect(model.models[1].provider).to.be.instanceOf(MixOpenRouter);
     });
 
     it('should register every requested GLM 5.2 provider', () => {

package/test/kimi.test.js

@@ -3,16 +3,12 @@ const nock = require('nock');
 const { ModelMix, MixFireworks, MixKimi, MixOpenRouter, MixTogether } = require('../index.js');
 
 describe('Kimi Model Registration Tests', () => {
-    it('should register Together Kimi K2.7 Code before the OpenRouter fallback by default', () => {
+    it('should register only Together Kimi K2.7 Code by default', () => {
         const model = ModelMix.new();
         model.kimiK27Code();
 
-        expect(model.models.map(({ key }) => key)).to.deep.equal([
-            'moonshotai/Kimi-K2.7-Code',
-            'moonshotai/kimi-k2.7-code'
-        ]);
+        expect(model.models.map(({ key }) => key)).to.deep.equal(['moonshotai/Kimi-K2.7-Code']);
         expect(model.models[0].provider).to.be.instanceOf(MixTogether);
-        expect(model.models[1].provider).to.be.instanceOf(MixOpenRouter);
     });
 
     it('should register every requested Kimi K2.7 Code provider', () => {

package/test/live.test.js

@@ -1,5 +1,5 @@
 const { expect } = require('chai');
-const { ModelMix, MixOpenAI, MixAnthropic, MixGoogle } = require('../index.js');
+const { ModelMix, MixOpenAI, MixAnthropic } = require('../index.js');
 const nock = require('nock');
 
 const blueSquareBase64 = 'data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAGQAAABkCAMAAABHPGVmAAAAGXRFWHRTb2Z0d2FyZQBBZG9iZSBJbWFnZVJlYWR5ccllPAAAAyhpVFh0WE1MOmNvbS5hZG9iZS54bXAAAAAAADw/eHBhY2tldCBiZWdpbj0i77u/IiBpZD0iVzVNME1wQ2VoaUh6cmVTek5UY3prYzlkIj8+IDx4OnhtcG1ldGEgeG1sbnM6eD0iYWRvYmU6bnM6bWV0YS8iIHg6eG1wdGs9IkFkb2JlIFhNUCBDb3JlIDkuMS1jMDAzIDc5Ljk2OTBhODdmYywgMjAyNS8wMy8wNi0yMDo1MDoxNiAgICAgICAgIj4gPHJkZjpSREYgeG1sbnM6cmRmPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5LzAyLzIyLXJkZi1zeW50YXgtbnMjIj4gPHJkZjpEZXNjcmlwdGlvbiByZGY6YWJvdXQ9IiIgeG1sbnM6eG1wPSJodHRwOi8vbnMuYWRvYmUuY29tL3hhcC8xLjAvIiB4bWxuczp4bXBNTT0iaHR0cDovL25zLmFkb2JlLmNvbS94YXAvMS4wL21tLyIgeG1sbnM6c3RSZWY9Imh0dHA6Ly9ucy5hZG9iZS5jb20veGFwLzEuMC9zVHlwZS9SZXNvdXJjZVJlZiMiIHhtcDpDcmVhdG9yVG9vbD0iQWRvYmUgUGhvdG9zaG9wIDI2LjkgKE1hY2ludG9zaCkiIHhtcE1NOkluc3RhbmNlSUQ9InhtcC5paWQ6REM2QzQ3NEQ2Q0I5MTFGMDlBRTVGQzcwQjMyMkY4MDciIHhtcE1NOkRvY3VtZW50SUQ9InhtcC5kaWQ6REM2QzQ3NEU2Q0I5MTFGMDlBRTVGQzcwQjMyMkY4MDciPiA8eG1wTU06RGVyaXZlZEZyb20gc3RSZWY6aW5zdGFuY2VJRD0ieG1wLmlpZDpEQzZDNDc0QjZDQjkxMUYwOUFFNUZDNzBCMzIyRjgwNyIgc3RSZWY6ZG9jdW1lbnRJRD0ieG1wLmRpZDpEQzZDNDc0QzZDQjkxMUYwOUFFNUZDNzBCMzIyRjgwNyIvPiA8L3JkZjpEZXNjcmlwdGlvbj4gPC9yZGY6UkRGPiA8L3g6eG1wbWV0YT4gPD94cGFja2V0IGVuZD0iciI/PvArxh0AAAAGUExURQAA/wAAAHtivz4AAAAjSURBVHja7MGBAAAAAMOg+VNf4QBVAQAAAAAAAAAAAI8JMAAndAABi7SX2gAAAABJRU5ErkJggg==';
@@ -181,7 +181,9 @@ describe('Live Integration Tests', function () {
     describe('Additional Model Tests', function () {
 
         it('should work with GPT-OSS model', async function () {
-            const model = ModelMix.new(setup).gptOss();
+            const model = ModelMix.new(setup).gptOss({
+                options: { max_tokens: 128 }
+            });
 
             model.addText('Say "gptoss test successful" and nothing else.');
 
@@ -241,8 +243,11 @@ describe('Live Integration Tests', function () {
 
     describe('JSON Structured Output for New Models', function () {
 
-        it('should return structured JSON with KimiK25 Thinking', async function () {
-            const model = ModelMix.new(setup).kimiK25();
+        it('should return structured JSON with Kimi K3', async function () {
+            const model = ModelMix.new(setup).kimiK3({
+                options: { max_tokens: 512 },
+                mix: { moonshot: false, together: true }
+            });
 
             model.addText('Generate information about a fictional vehicle.');
 
@@ -253,7 +258,7 @@ describe('Live Integration Tests', function () {
                 manufacturer: "Future Motors"
             });
 
-            console.log(`KimiK25 JSON result:`, result);
+            console.log(`Kimi K3 JSON result:`, result);
 
             expect(result).to.be.an('object');
             expect(result).to.have.property('name');

package/test/muse.test.js

@@ -7,16 +7,14 @@ const {
     MixTogether
 } = require('../index.js');
 
-describe('Muse Glimmer Model Registration Tests', () => {
-    it('registers Fireworks before the OpenRouter fallback by default', () => {
+describe('Muse Model Registration Tests', () => {
+    it('registers only Fireworks by default', () => {
         const model = ModelMix.new().museGlimmer30b();
 
         expect(model.models.map(({ key }) => key)).to.deep.equal([
-            'accounts/fireworks/models/muse-glimmer-30b',
-            'meta/muse-glimmer-30b'
+            'accounts/fireworks/models/muse-glimmer-30b'
         ]);
         expect(model.models[0].provider).to.be.instanceOf(MixFireworks);
-        expect(model.models[1].provider).to.be.instanceOf(MixOpenRouter);
     });
 
     it('registers every supported provider in fallback order', () => {
@@ -54,8 +52,27 @@ describe('Muse Glimmer Model Registration Tests', () => {
         const model = ModelMix.new().chain('museGlimmer30b');
 
         expect(model.models.map(({ key }) => key)).to.deep.equal([
-            'accounts/fireworks/models/muse-glimmer-30b',
-            'meta/muse-glimmer-30b'
+            'accounts/fireworks/models/muse-glimmer-30b'
         ]);
     });
+
+    it('registers Muse Spark 1.2 Contributor through OpenRouter', () => {
+        const model = ModelMix.new().museSpark12Contributor();
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('meta/muse-spark-1.2-contributor');
+        expect(model.models[0].provider).to.be.instanceOf(MixOpenRouter);
+        expect(ModelMix.calculateCost('meta/muse-spark-1.2-contributor', {
+            input: 1_000_000,
+            cached: 250_000,
+            output: 1_000_000
+        })).to.equal(0.2755);
+    });
+
+    it('supports Muse Spark 1.2 Contributor in chain()', () => {
+        const model = ModelMix.new().chain('museSpark12Contributor');
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('meta/muse-spark-1.2-contributor');
+    });
 });

package/test/provider-expansion.test.js

@@ -9,6 +9,23 @@ const {
 } = require('../index.js');
 
 describe('Provider expansion regressions', () => {
+    it('should keep OpenRouter fallbacks disabled by default', () => {
+        const originalMiniMaxApiKey = process.env.MINIMAX_API_KEY;
+        process.env.MINIMAX_API_KEY = 'test-minimax-key';
+
+        try {
+            const gptOss = ModelMix.new().gptOss();
+            const minimax = ModelMix.new().minimaxM27();
+
+            expect(gptOss.models.some(({ provider }) => provider instanceof MixOpenRouter)).to.equal(false);
+            expect(minimax.models.map(({ key }) => key)).to.deep.equal(['MiniMax-M2.7']);
+            expect(minimax.models[0].provider).to.be.instanceOf(MixMiniMax);
+        } finally {
+            if (originalMiniMaxApiKey === undefined) delete process.env.MINIMAX_API_KEY;
+            else process.env.MINIMAX_API_KEY = originalMiniMaxApiKey;
+        }
+    });
+
     it('should retain every enabled GPT OSS provider, including shared model keys', () => {
         const model = ModelMix.new().gptOss({
             mix: {

package/test/public-api.test.js

@@ -14,6 +14,7 @@ describe('public module boundary', () => {
             'MixGroq',
             'MixKimi',
             'MixLMStudio',
+            'MixLambda',
             'MixMiMo',
             'MixMiniMax',
             'MixModeration',
@@ -57,8 +58,7 @@ describe('public module boundary', () => {
         ['MiMo', config => new api.MixMiMo({ config })],
         ['Perplexity', config => new api.MixPerplexity({ config })],
         ['Grok', config => new api.MixGrok({ config })],
-        ['Lambda', config => api.ModelMix.new({ mix: { openrouter: false, lambda: true } })
-            .hermes3({ config }).models[0].provider],
+        ['Lambda', config => new api.MixLambda({ config })],
         ['Groq', config => new api.MixGroq({ config })],
         ['Together', config => new api.MixTogether({ config })],
         ['Cerebras', config => new api.MixCerebras({ config })],

package/test/qwen.test.js

@@ -67,13 +67,12 @@ describe('Qwen Model Registration Tests', () => {
         })).to.equal(4.08576);
     });
 
-    it('should register Fireworks Qwen 3.8 Max before the OpenRouter fallback by default', () => {
+    it('should register only Fireworks Qwen 3.8 Max by default', () => {
         const model = ModelMix.new();
         model.qwen38max();
 
         expect(model.models.map(({ key }) => key)).to.deep.equal([
-            'accounts/fireworks/models/qwen3p8-2p4t-a95b',
-            'qwen/qwen3.8-max'
+            'accounts/fireworks/models/qwen3p8-2p4t-a95b'
         ]);
         expect(ModelMix.calculateCost('accounts/fireworks/models/qwen3p8-2p4t-a95b', {
             input: 1_000_000,

package/test/tokens.test.js

@@ -321,32 +321,47 @@ describe('Token Usage Tracking', () => {
     });
 
     it('should register GPT-5.5 shortcuts with OpenAI Responses provider', function () {
-        const model = ModelMix.new()
+        const model = ModelMix.new({ mix: { openrouter: true } })
             .gpt55()
             .gpt55pro();
 
-        expect(model.models).to.have.length(2);
-        expect(model.models[0].key).to.equal('gpt-5.5');
-        expect(model.models[1].key).to.equal('gpt-5.5-pro');
+        expect(model.models.map(({ key }) => key)).to.deep.equal([
+            'gpt-5.5',
+            'openai/gpt-5.5',
+            'gpt-5.5-pro',
+            'openai/gpt-5.5-pro'
+        ]);
         expect(model.models[0].provider).to.be.instanceOf(MixOpenAIResponses);
-        expect(model.models[1].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 register GPT-5.6 shortcuts with OpenAI Responses provider', function () {
-        const model = ModelMix.new()
+        const model = ModelMix.new({ mix: { openrouter: true } })
             .gpt56sol()
             .gpt56terra()
             .gpt56luna();
 
         expect(model.models.map(({ key }) => key)).to.deep.equal([
             'gpt-5.6-sol',
+            'openai/gpt-5.6-sol',
             'gpt-5.6-terra',
-            'gpt-5.6-luna'
+            'openai/gpt-5.6-terra',
+            'gpt-5.6-luna',
+            'openai/gpt-5.6-luna'
         ]);
-        expect(model.models.every(({ provider }) => provider instanceof MixOpenAIResponses)).to.equal(true);
+        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);
+        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-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);
     });
 
     it('should calculate GPT-5.6 cache reads and writes at their actual rates', function () {