modelmix 4.6.6 → 4.6.8

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/history.test.js

@@ -456,6 +456,116 @@ describe('Conversation History Tests', () => {
             expect(capturedBody.messages[2].role).to.equal('user');
         });
 
+        it('should replay omitted thinking blocks with empty string (not null) on Anthropic', async () => {
+            // Opus 5 / Sonnet 5 / Fable 5 default to display "omitted":
+            // thinking blocks arrive as thinking: "" + signature.
+            // Replaying thinking: null causes Anthropic 400 invalid_request_error.
+            const model = ModelMix.new({
+                config: { debug: false, max_history: 10 }
+            });
+            model.opus5();
+
+            model.addText('Capital of France?');
+            nock('https://api.anthropic.com')
+                .post('/v1/messages')
+                .reply(200, {
+                    content: [{
+                        type: 'thinking',
+                        thinking: '',
+                        signature: 'sig-omitted-turn1'
+                    }, {
+                        type: 'text',
+                        text: 'Paris.'
+                    }]
+                });
+            await model.message();
+
+            expect(model.messages[1].content[0]).to.deep.equal({
+                type: 'thinking',
+                thinking: '',
+                signature: 'sig-omitted-turn1'
+            });
+            expect(model.messages[1].content[0].thinking).to.be.a('string');
+            expect(model.messages[1].content[0].thinking).to.not.equal(null);
+
+            let capturedBody;
+            model.addText('Capital of Germany?');
+            nock('https://api.anthropic.com')
+                .post('/v1/messages', (body) => {
+                    capturedBody = body;
+                    return true;
+                })
+                .reply(200, {
+                    content: [{
+                        type: 'thinking',
+                        thinking: '',
+                        signature: 'sig-omitted-turn2'
+                    }, {
+                        type: 'text',
+                        text: 'Berlin.'
+                    }]
+                });
+            await model.message();
+
+            const assistantMsg = capturedBody.messages.find(m => m.role === 'assistant');
+            expect(assistantMsg).to.exist;
+            expect(assistantMsg.content[0]).to.deep.equal({
+                type: 'thinking',
+                thinking: '',
+                signature: 'sig-omitted-turn1'
+            });
+            expect(assistantMsg.content[0].thinking).to.equal('');
+            expect(assistantMsg.content[1].text).to.equal('Paris.');
+        });
+
+        it('should replay summarized thinking blocks unchanged on Anthropic', async () => {
+            const model = ModelMix.new({
+                config: { debug: false, max_history: 10 }
+            });
+            model.opus5think();
+
+            model.addText('2+2?');
+            nock('https://api.anthropic.com')
+                .post('/v1/messages')
+                .reply(200, {
+                    content: [{
+                        type: 'thinking',
+                        thinking: 'Simple arithmetic.',
+                        signature: 'sig-summarized-turn1'
+                    }, {
+                        type: 'text',
+                        text: '4'
+                    }]
+                });
+            await model.message();
+
+            let capturedBody;
+            model.addText('3+3?');
+            nock('https://api.anthropic.com')
+                .post('/v1/messages', (body) => {
+                    capturedBody = body;
+                    return true;
+                })
+                .reply(200, {
+                    content: [{
+                        type: 'thinking',
+                        thinking: 'Also simple.',
+                        signature: 'sig-summarized-turn2'
+                    }, {
+                        type: 'text',
+                        text: '6'
+                    }]
+                });
+            await model.message();
+
+            const assistantMsg = capturedBody.messages.find(m => m.role === 'assistant');
+            expect(assistantMsg.content[0]).to.deep.equal({
+                type: 'thinking',
+                thinking: 'Simple arithmetic.',
+                signature: 'sig-summarized-turn1'
+            });
+        });
+
         it('should maintain history when using Google provider', async () => {
             const model = ModelMix.new({
                 config: { debug: false, max_history: 10 }

package/test/live.mcp.js

@@ -139,6 +139,48 @@ describe('Live MCP Integration Tests', function () {
             }
         });
 
+        it('should use custom MCP tools with Claude Opus 5', async function () {
+            // Opus 5 rejects temperature (deprecated); omit it from options.
+            const model = ModelMix.new({ config: setup.config }).opus5();
+
+            model.addTool({
+                name: "get_current_time",
+                description: "Get the current date and time",
+                inputSchema: {
+                    type: "object",
+                    properties: {
+                        timezone: {
+                            type: "string",
+                            description: "Timezone (optional, defaults to UTC)"
+                        }
+                    }
+                }
+            }, async ({ timezone = 'UTC' }) => {
+                const now = new Date();
+                if (timezone === 'UTC') {
+                    return `Current time (UTC): ${now.toISOString()}`;
+                }
+                return `Current time (${timezone}): ${now.toLocaleString('en-US', { timeZone: timezone })}`;
+            });
+
+            model.setSystem('You are a helpful assistant that can tell time. Use the get_current_time tool when asked about time.');
+            model.addText('What time is it right now?');
+
+            try {
+                const response = await withRetry(() => model.message(), { retries: 2, baseDelayMs: 1500 });
+                console.log(`Claude Opus 5 with MCP tools: ${response}`);
+
+                expect(response).to.be.a('string');
+                expect(response.toLowerCase()).to.match(/(time|clock|hour|minute|second|am|pm|utc|\d{4})/);
+            } catch (error) {
+                console.error('Full error:', error);
+                if (error.response && error.response.data) {
+                    console.error('Response data:', JSON.stringify(error.response.data, null, 2));
+                }
+                throw error;
+            }
+        });
+
         it('should use custom MCP tools with Gemini 3 Flash', async function () {
             const model = ModelMix.new(setup).gemini3flash();
 
@@ -517,7 +559,7 @@ describe('Live MCP Integration Tests', function () {
 
         it('should work with same MCP tools across different Anthropic models', async function () {
             const models = [
-                { name: 'Sonnet 4', model: ModelMix.new(setup).sonnet46() },
+                { name: 'Opus 5', model: ModelMix.new({ config: setup.config }).opus5() },
                 { name: 'Sonnet 4.6', model: ModelMix.new(setup).sonnet46() },
                 { name: 'Haiku 4.5', model: ModelMix.new(setup).haiku45() }
             ];

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';