modelmix 5.1.20 → 5.2.1

package/test/google.test.js

@@ -0,0 +1,55 @@
+const { expect } = require('chai');
+const sinon = require('sinon');
+const { MixGoogle, ModelMix } = require('../index');
+
+describe('Google message and JSON contracts', () => {
+    afterEach(() => sinon.restore());
+
+    it('converts string user and assistant messages without changing their inputs', () => {
+        const messages = [
+            { role: 'user', content: 'Request' },
+            { role: 'assistant', content: 'Answer' },
+            { role: 'user', content: [{ type: 'text', text: 'Follow-up' }] }
+        ];
+        expect(MixGoogle.convertMessages(messages)).to.deep.equal([
+            { role: 'user', parts: [{ text: 'Request' }] },
+            { role: 'model', parts: [{ text: 'Answer' }] },
+            { role: 'user', parts: [{ text: 'Follow-up' }] }
+        ]);
+        expect(messages[0]).to.deep.equal({ role: 'user', content: 'Request' });
+    });
+
+    it('sends child text messages and JSON mode through the real Google adapter', async () => {
+        const bodies = [];
+        sinon.stub(global, 'fetch').callsFake(async (_url, input) => {
+            bodies.push(JSON.parse(input.body));
+            return new Response(JSON.stringify({
+                candidates: [{ content: { parts: [{ text: '{"ok":true}' }] } }]
+            }), { status: 200 });
+        });
+        const worker = ModelMix.new({ config: { apiKey: 'test-key' } }).gemini38flash();
+        const result = await ModelMix.new().use({
+            name: 'child-json',
+            execute: context => context.invoke({
+                model: worker,
+                system: 'Return JSON.',
+                messages: [{ role: 'user', content: 'Evaluate this response.' }],
+                options: { response_format: { type: 'json_object' } },
+                plugins: 'none'
+            })
+        }).addText('Task').json();
+        expect(result).to.deep.equal({ ok: true });
+        expect(bodies[0].contents).to.deep.equal([
+            { role: 'user', parts: [{ text: 'Evaluate this response.' }] }
+        ]);
+        expect(bodies[0].generationConfig.responseMimeType).to.equal('application/json');
+    });
+
+    it('combines answer text parts without including thought parts', () => {
+        expect(MixGoogle.extractMessage({ candidates: [{ content: { parts: [
+            { thought: true, text: 'Internal analysis' },
+            { text: '{"ok":' },
+            { text: 'true}' }
+        ] } }] })).to.equal('{"ok":true}');
+    });
+});

package/test/history.test.js

@@ -629,7 +629,7 @@ describe('Conversation History Tests', () => {
             expect(model.messages).to.have.length(2);
         });
 
-        it('should handle empty assistant response gracefully', async () => {
+        it('should reject an empty assistant response without adding it to history', async () => {
             const model = ModelMix.new({
                 config: { debug: false, max_history: 10 }
             });
@@ -643,9 +643,12 @@ describe('Conversation History Tests', () => {
                     }]
                 });
 
-            const response = await model.message();
-            // Empty string is falsy, so assistant message should NOT be added
-            expect(response).to.equal('');
+            let failure;
+            try { await model.message(); } catch (error) { failure = error; }
+            expect(failure).to.include({ statusCode: 502 });
+            expect(failure.message).to.include('no text or tool calls');
+            expect(model.messages).to.have.length(1);
+            expect(model.messages[0].role).to.equal('user');
         });
 
         it('should handle multiple addText before first message()', async () => {

package/test/json.test.js

@@ -17,6 +17,34 @@ describe('JSON Schema and Structured Output Tests', () => {
         sinon.restore();
     });
 
+    describe('JSON response formatting', () => {
+        for (const suffix of ['', '```', '\n```\n']) {
+            it(`preserves embedded Markdown with trailing delimiter ${JSON.stringify(suffix)}`, async () => {
+                const value = { text: 'Use ```text\ncontent\n``` here.' };
+                const message = JSON.stringify(value) + suffix;
+                const mix = ModelMix.new();
+                const result = { message };
+                sinon.stub(mix, 'execute').resolves(result);
+                expect(await mix.json()).to.deep.equal(value);
+                expect(result.message).to.equal(message);
+            });
+        }
+
+        for (const message of ['{"ok":true} explanation```', '{"ok":true}{"other":true}```', '{"ok"":true}```']) {
+            it(`rejects invalid content even with a closing delimiter: ${message}`, async () => {
+                const mix = ModelMix.new();
+                sinon.stub(mix, 'execute').resolves({ message });
+                let failure;
+                try {
+                    await mix.json();
+                } catch (error) {
+                    failure = error;
+                }
+                expect(failure).to.be.instanceOf(SyntaxError);
+            });
+        }
+    });
+
     describe('JSON Schema Generation', () => {
         it('should generate schema for simple object', () => {
             const example = {
@@ -490,4 +518,4 @@ describe('JSON Schema and Structured Output Tests', () => {
             expect(result[2]).to.have.property('name', 'Spain');
         });
     });
-});
+});

package/test/plugins.test.js

@@ -1,6 +1,8 @@
 const { expect } = require('chai');
 const path = require('path');
-const { MixCustom, ModelMix } = require('../index.js');
+const nock = require('nock');
+const { MixCustom, MixOpenAIResponses, MixAnthropic, MixGoogle, ModelMix } = require('../index.js');
+const { skills } = require('../plugins/skills');
 
 function createProvider(handler = async () => ({ message: 'provider', toolCalls: [] })) {
     const provider = new MixCustom();
@@ -9,6 +11,153 @@ function createProvider(handler = async () => ({ message: 'provider', toolCalls:
 }
 
 describe('ModelMix plugins', () => {
+    it('runs a native Responses skill loop including reasoning and parallel tool outputs', async () => {
+        const requests = [];
+        const output = [
+            { type: 'reasoning', id: 'rs_skill', summary: [], encrypted_content: 'opaque-reasoning' },
+            { type: 'message', id: 'msg_skill', role: 'assistant', content: [{ type: 'output_text', text: 'Reading the skill.' }] },
+            { type: 'function_call', id: 'fc_skill', call_id: 'call_skill', name: 'read_skill', arguments: JSON.stringify({ name: 'modelmix' }) },
+            { type: 'function_call', id: 'fc_local', call_id: 'call_local', name: 'local_tool', arguments: '{"value":7}' }
+        ];
+        const scope = nock('https://api.openai.com')
+            .post('/v1/responses', body => { requests.push(body); return true; })
+            .reply(200, { output })
+            .post('/v1/responses', body => { requests.push(body); return true; })
+            .reply(200, { output: [{ type: 'message', content: [{ type: 'output_text', text: 'Done.' }] }] });
+        try {
+            const model = ModelMix.new({ config: { bottleneck: { minTime: 0 } } }).gpt6astra()
+                .addTool({ name: 'local_tool', description: 'Local tool', inputSchema: { type: 'object' } }, input => `value=${input.value}`)
+                .use(await skills({ paths: [path.join(__dirname, '../skills/modelmix')] }))
+                .addText('Use the modelmix skill.');
+            expect(await model.message()).to.equal('Done.');
+            expect(scope.isDone()).to.equal(true);
+            for (const request of requests) {
+                expect(request.tools.map(tool => tool.name)).to.have.members(['local_tool', 'read_skill']);
+                const skillTool = request.tools.find(tool => tool.name === 'read_skill');
+                expect(skillTool.strict).to.equal(false);
+                expect(skillTool.parameters.required).to.deep.equal(['name']);
+            }
+            expect(requests[1].input.slice(2, 6)).to.deep.equal(output);
+            const results = requests[1].input.filter(item => item.type === 'function_call_output');
+            expect(results.map(item => item.call_id)).to.deep.equal(['call_skill', 'call_local']);
+            expect(JSON.parse(results[0].output).content).to.include('name: modelmix');
+            expect(results[1].output).to.equal('value=7');
+        } finally {
+            nock.cleanAll();
+        }
+    });
+
+    it('converts neutral tool history and native Responses tool options', () => {
+        const request = MixOpenAIResponses.buildResponsesRequest({
+            tools: [{ type: 'web_search' }, { type: 'function', function: { name: 'lookup', parameters: { type: 'object' }, strict: true } }],
+            tool_choice: { type: 'function', function: { name: 'lookup' } },
+            parallel_tool_calls: false,
+            messages: [
+                { role: 'assistant', content: 'Checking.', tool_calls: [{ id: 'call_1', type: 'function', function: { name: 'lookup', arguments: '{"query":"test"}' } }] },
+                { role: 'tool', tool_call_id: 'call_1', content: 'Found.' }
+            ]
+        });
+        expect(request.tools).to.deep.equal([{ type: 'web_search' }, { type: 'function', name: 'lookup', parameters: { type: 'object' }, strict: true }]);
+        expect(request.tool_choice).to.deep.equal({ type: 'function', name: 'lookup' });
+        expect(request.parallel_tool_calls).to.equal(false);
+        expect(request.input).to.deep.equal([
+            { role: 'assistant', content: [{ type: 'output_text', text: 'Checking.' }] },
+            { type: 'function_call', call_id: 'call_1', name: 'lookup', arguments: '{"query":"test"}' },
+            { type: 'function_call_output', call_id: 'call_1', output: 'Found.' }
+        ]);
+    });
+
+    for (const Provider of [MixCustom, MixAnthropic, MixGoogle]) {
+        for (const hasExplicitTool of [false, true]) {
+            it(`preserves plugin and registered tools with ${Provider.name} options.tools (${hasExplicitTool ? 'populated' : 'empty'})`, async () => {
+                const registered = { name: 'registered', description: 'Registered tool', inputSchema: { type: 'object' } };
+                const extra = { ...registered, name: 'explicit' };
+                const provider = new Provider();
+                const explicitTools = hasExplicitTool ? provider.getOptionsTools({ local: [extra] }).tools : [];
+                let received;
+                provider.create = async ({ options }) => { received = options.tools; return { message: 'done', toolCalls: [] }; };
+                const model = ModelMix.new({ options: { tools: explicitTools } }).attach('custom', provider)
+                    .addTool(registered, () => 'registered')
+                    .use(await skills({ paths: [path.join(__dirname, '../skills/modelmix')] })).addText('Use skills');
+                await model.message();
+                const names = received.flatMap(tool => tool.functionDeclarations || [tool.function || tool]).map(tool => tool.name);
+                expect(names).to.have.members(['registered', 'read_skill', ...(hasExplicitTool ? ['explicit'] : [])]);
+                expect(model.options.tools).to.deep.equal(explicitTools);
+            });
+        }
+    }
+
+    it('rejects collisions between explicit options and plugin tools before calling the provider', async () => {
+        let calls = 0;
+        const model = ModelMix.new({ options: { tools: [{ type: 'function', function: { name: 'read_skill' } }] } })
+            .attach('custom', createProvider(async () => { calls++; return { message: 'unexpected' }; }))
+            .use(await skills({ paths: [path.join(__dirname, '../skills/modelmix')] })).addText('test');
+        let failure;
+        try { await model.message(); } catch (error) { failure = error; }
+        expect(failure?.message).to.include('Duplicate tool name: read_skill');
+        expect(calls).to.equal(0);
+    });
+
+    it('keeps plugin tools request-scoped across tool continuations and alongside local tools', async () => {
+        const requests = [];
+        const signal = new AbortController().signal;
+        const provider = createProvider(async request => {
+            requests.push(request);
+            if (requests.length === 1) return {
+                message: '',
+                toolCalls: [
+                    { id: 'skill', name: 'read_skill', input: {} },
+                    { id: 'local', name: 'local_tool', input: {} }
+                ]
+            };
+            return { message: 'done', toolCalls: [] };
+        });
+        const model = ModelMix.new().attach('custom', provider)
+            .addTool({ name: 'local_tool', description: 'Local tool', inputSchema: { type: 'object' } }, () => 'local')
+            .use({
+                name: 'skills-test',
+                async execute(context, next) {
+                    context.request.tools.push({
+                        tool: { name: 'read_skill', description: 'Read skill', inputSchema: { type: 'object' } },
+                        callback: (_args, callbackSignal) => {
+                            expect(callbackSignal).to.equal(signal);
+                            return 'skill instructions';
+                        }
+                    });
+                    return next();
+                }
+            }).addText('Use both tools');
+
+        expect(await model.message(signal)).to.equal('done');
+        expect(requests).to.have.length(2);
+        for (const request of requests) {
+            expect(request.options.tools.map(tool => tool.function.name)).to.have.members(['local_tool', 'read_skill']);
+        }
+        const results = requests[1].options.messages.filter(message => message.role === 'tool');
+        expect(results.map(result => result.content)).to.deep.equal(['skill instructions', 'local']);
+        expect(model.mcpToolsManager.hasTool('read_skill')).to.equal(false);
+        expect(model.tools.local.map(tool => tool.name)).to.deep.equal(['local_tool']);
+    });
+
+    it('rejects collisions between plugin tools and existing tools before calling a provider', async () => {
+        let calls = 0;
+        const tool = { name: 'same', description: 'Same tool', inputSchema: { type: 'object' } };
+        const model = ModelMix.new().attach('custom', createProvider(async () => {
+            calls += 1;
+            return { message: 'unexpected' };
+        })).addTool(tool, () => 'local').use({
+            name: 'collision',
+            async execute(context, next) {
+                context.request.tools.push({ tool, callback: () => 'plugin' });
+                return next();
+            }
+        }).addText('test');
+        let failure;
+        try { await model.message(); } catch (error) { failure = error; }
+        expect(failure?.message).to.include('Duplicate tool name: same');
+        expect(calls).to.equal(0);
+    });
+
     it('keeps registration instance-scoped and lets new instances inherit plugins without history', () => {
         const plugin = { name: 'metrics', execute: (_context, next) => next() };
         const parent = ModelMix.new().use(plugin).addText('parent history');

package/test/public-api.test.js

@@ -8,6 +8,7 @@ describe('public module boundary', () => {
             'MixAnthropic',
             'MixCerebras',
             'MixCustom',
+            'MixDeepSeek',
             'MixFireworks',
             'MixGoogle',
             'MixGrok',
@@ -56,6 +57,7 @@ describe('public module boundary', () => {
         ['Gemini', config => new api.MixGoogle({ config })],
         ['MiniMax', config => new api.MixMiniMax({ config })],
         ['MiMo', config => new api.MixMiMo({ config })],
+        ['DeepSeek', config => new api.MixDeepSeek({ config })],
         ['Perplexity', config => new api.MixPerplexity({ config })],
         ['Grok', config => new api.MixGrok({ config })],
         ['Lambda', config => new api.MixLambda({ config })],

package/test/tokens.test.js

@@ -1,5 +1,5 @@
 import { expect } from 'chai';
-import { ModelMix, MixAnthropic, MixCustom, MixGoogle, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenRouter } from '../index.js';
+import { ModelMix, MixAnthropic, MixCustom, MixGoogle, MixGrok, MixMiMo, MixOpenAI, MixOpenAIResponses, MixOpenRouter } from '../index.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
@@ -7,6 +7,78 @@ const nock = require('nock');
 
 describe('Token Usage Tracking', () => {
 
+    it('adds native Grok reasoning to its exclusive completion count', () => {
+        const tokens = MixGrok.extractTokens({ usage: {
+            prompt_tokens: 656, completion_tokens: 2, total_tokens: 824,
+            prompt_tokens_details: { cached_tokens: 512 },
+            completion_tokens_details: { reasoning_tokens: 166 }
+        } });
+        expect(tokens).to.include({ input: 656, output: 2, thinking: 166, total: 824 });
+        expect(ModelMix.calculateCostBreakdown('grok-4.6', tokens).total).to.equal(0.001552);
+    });
+
+    it('combines Anthropic stream input usage with the final thinking breakdown', async () => {
+        const { Readable } = require('node:stream');
+        const chunks = [
+            { type: 'message_start', message: { usage: { input_tokens: 25, output_tokens: 1, cache_read_input_tokens: 10 } } },
+            { type: 'message_delta', usage: { output_tokens: 348, output_tokens_details: { thinking_tokens: 312 } } },
+            { type: 'message_stop' }
+        ];
+        const result = await new MixAnthropic().processStream({ data: Readable.from(chunks.map(chunk => `data: ${JSON.stringify(chunk)}\n\n`)) });
+        expect(result.tokens).to.include({ input: 35, output: 36, thinking: 312, total: 383, cached: 10 });
+    });
+
+    it('preserves Gemini stream thinking usage from the final metadata', async () => {
+        const { Readable } = require('node:stream');
+        const data = { usageMetadata: { promptTokenCount: 22, candidatesTokenCount: 5, thoughtsTokenCount: 99, totalTokenCount: 126 } };
+        const result = await new MixGoogle().processStream({ data: Readable.from([`data: ${JSON.stringify(data)}\n\n`]) });
+        expect(result.tokens).to.include({ input: 22, output: 5, thinking: 99, total: 126 });
+    });
+
+    for (const [name, extract, usage] of [
+        ['Chat Completions', MixCustom.extractTokens, { prompt_tokens: 615, completion_tokens: 5930, completion_tokens_details: { reasoning_tokens: 5900 } }],
+        ['Responses', MixOpenAIResponses.extractResponsesTokens, { input_tokens: 615, output_tokens: 5930, output_tokens_details: { reasoning_tokens: 5900 } }],
+        ['Anthropic', MixAnthropic.extractTokens, { input_tokens: 615, output_tokens: 5930, output_tokens_details: { thinking_tokens: 5900 } }]
+    ]) {
+        it(`separates ${name} reasoning without billing it twice`, () => {
+            const tokens = extract({ usage });
+            expect(tokens).to.include({ input: 615, output: 30, thinking: 5900, total: 6545 });
+            expect(ModelMix.calculateCostBreakdown('deepseek/deepseek-v4.1-flash', tokens).total).to.equal(0.00365025);
+        });
+    }
+
+    it('keeps streamed OpenRouter usage and actual cost through usage-only and trailing chunks', async () => {
+        const { Readable } = require('node:stream');
+        const provider = new MixOpenRouter();
+        const chunks = [
+            { choices: [{ delta: { reasoning: 'thinking' }, finish_reason: null }] },
+            { choices: [{ delta: { content: 'ok' }, finish_reason: 'stop' }] },
+            { choices: [], usage: { prompt_tokens: 10, completion_tokens: 12, completion_tokens_details: { reasoning_tokens: 10 }, cost: 0.123 } },
+            { choices: [] }
+        ];
+        provider.create = async () => provider.processStream({ data: Readable.from(chunks.map(chunk => `data: ${JSON.stringify(chunk)}\n\n`)) });
+        const model = ModelMix.new().attach('unlisted-model', provider).addText('test');
+        const deltas = [];
+        const result = await model.stream(({ delta }) => deltas.push(delta));
+        expect(deltas.join('')).to.equal('ok');
+        expect(result.tokens).to.include({ input: 10, output: 2, thinking: 10, total: 22, cost: 0.123 });
+    });
+
+    for (const cost of [0, 0.0073005]) {
+        it(`uses the reported OpenRouter cost ${cost} instead of catalog pricing`, async () => {
+            const provider = new MixOpenRouter();
+            provider.create = async () => provider.processResponse({ data: {
+                choices: [{ message: { content: 'ok' }, finish_reason: 'stop' }],
+                usage: { prompt_tokens: 615, completion_tokens: 5930, completion_tokens_details: { reasoning_tokens: 5900 }, cost }
+            } });
+            const model = ModelMix.new().attach('deepseek/deepseek-v4.1-flash', provider).addText('test');
+            const result = await model.raw();
+            expect(result.tokens.cost).to.equal(cost);
+            expect(result.tokens).to.include({ output: 30, thinking: 5900 });
+            expect(model.lastRaw.tokens.cost).to.equal(cost);
+        });
+    }
+
     // Ensure nock doesn't interfere with live requests via MockHttpSocket
     before(function() {
         nock.cleanAll();
@@ -691,7 +763,7 @@ describe('Token Usage Tracking', () => {
         
         expect(result.tokens.input).to.be.greaterThan(0);
         expect(result.tokens.output).to.be.greaterThan(0);
-        expect(result.tokens.total).to.equal(result.tokens.input + result.tokens.output);
+        expect(result.tokens.total).to.equal(result.tokens.input + result.tokens.output + result.tokens.thinking);
     });
 
     it('should track tokens in Google Gemini response', async function () {
@@ -735,7 +807,7 @@ describe('Token Usage Tracking', () => {
         expect(result2.tokens.output).to.be.greaterThan(0);
 
         // Verify both results have valid token counts
-        expect(result1.tokens.total).to.equal(result1.tokens.input + result1.tokens.output);
+        expect(result1.tokens.total).to.equal(result1.tokens.input + result1.tokens.output + result1.tokens.thinking);
         expect(result2.tokens.total).to.be.greaterThan(0);
     });