modelmix 5.1.20 → 5.2.0

package/test/deepseek.test.js

@@ -1,7 +1,279 @@
 const { expect } = require('chai');
-const { ModelMix } = require('../index.js');
+const nock = require('nock');
+const { ModelMix, MixDeepSeek, MixFireworks, MixOpenRouter } = require('../index.js');
 
 describe('DeepSeek Model Registration Tests', () => {
+    it('registers V4 Pro 0813 through OpenRouter and preserves caller settings', () => {
+        const model = ModelMix.new();
+        expect(model.deepseekPro({
+            options: { temperature: 0.5 },
+            config: { apiKey: 'test-key', effort: 100 }
+        })).to.equal(model);
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('deepseek/deepseek-v4-pro-0813');
+        expect(model.models[0].provider).to.be.instanceOf(MixOpenRouter);
+        expect(model.models[0].provider.options.temperature).to.equal(0.5);
+        expect(model.models[0].provider.config.effort).to.equal(100);
+    });
+
+    describe('DeepSeek V4 Pro 0813 requests', () => {
+        afterEach(() => nock.cleanAll());
+
+        for (const [effort, level] of [[0, undefined], [20, 'low'], [60, 'high'], [100, 'max'], [-1, undefined]]) {
+            it(`sends the exact model ID through chain() at effort ${effort} and accounts for cached input`, async () => {
+                const scope = nock('https://openrouter.ai')
+                    .post('/api/v1/chat/completions', body => {
+                        expect(body.model).to.equal('deepseek/deepseek-v4-pro-0813');
+                        expect(body.reasoning_effort).to.equal(level);
+                        expect(body.thinking).to.deep.equal(effort === -1
+                            ? undefined
+                            : { type: effort === 0 ? 'disabled' : 'enabled' });
+                        return true;
+                    })
+                    .reply(200, {
+                        model: 'deepseek/deepseek-v4-pro-0813',
+                        choices: [{ message: { role: 'assistant', content: 'ok' } }],
+                        usage: {
+                            prompt_tokens: 1000,
+                            completion_tokens: 100,
+                            prompt_tokens_details: { cached_tokens: 400 }
+                        }
+                    });
+                const model = ModelMix.new().chain(`deepseekPro@${effort}`).addText('Hello');
+
+                expect(await model.message()).to.equal('ok');
+                expect(scope.isDone()).to.equal(true);
+                expect(model.lastRaw.tokens).to.include({ input: 1000, cached: 400, output: 100 });
+                expect(model.lastRaw.tokens.cost).to.be.closeTo(0.000545952, 1e-12);
+            });
+        }
+    });
+
+    it('requires native credentials and accepts DEEPSEEK_API_KEY', () => {
+        const originalApiKey = process.env.DEEPSEEK_API_KEY;
+        try {
+            delete process.env.DEEPSEEK_API_KEY;
+            expect(() => new MixDeepSeek()).to.throw(/DEEPSEEK_API_KEY/);
+            process.env.DEEPSEEK_API_KEY = 'native-test-key';
+            const model = ModelMix.new().deepseekV41Flash({ mix: { deepseek: true, openrouter: false } });
+            expect(model.models).to.have.length(1);
+            expect(model.models[0].key).to.equal('deepseek-flash');
+            expect(model.models[0].provider.config.apiKey).to.equal('native-test-key');
+        } finally {
+            if (originalApiKey === undefined) delete process.env.DEEPSEEK_API_KEY;
+            else process.env.DEEPSEEK_API_KEY = originalApiKey;
+        }
+    });
+
+    it('registers DeepSeek V4.1 Flash through OpenRouter and preserves caller settings', () => {
+        const model = ModelMix.new();
+        expect(model.deepseekV41Flash({
+            options: { temperature: 0.5 },
+            config: { effort: 100 }
+        })).to.equal(model);
+
+        expect(model.models).to.have.length(1);
+        expect(model.models[0].key).to.equal('deepseek/deepseek-v4.1-flash');
+        expect(model.models[0].provider).to.be.instanceOf(MixOpenRouter);
+        expect(model.models[0].provider.options.temperature).to.equal(0.5);
+        expect(model.models[0].provider.config.effort).to.equal(100);
+    });
+
+    describe('DeepSeek V4.1 Flash requests', () => {
+        afterEach(() => nock.cleanAll());
+
+        it('falls back from native DeepSeek through Fireworks to OpenRouter', async () => {
+            const native = nock('https://api.deepseek.com')
+                .post('/chat/completions', body => body.model === 'deepseek-flash')
+                .reply(503, { error: { message: 'Unavailable' } });
+            const fireworks = nock('https://api.fireworks.ai')
+                .post('/inference/v1/chat/completions')
+                .reply(503, { error: { message: 'Unavailable' } });
+            const openrouter = nock('https://openrouter.ai')
+                .post('/api/v1/chat/completions')
+                .reply(200, { choices: [{ message: { content: 'fallback' } }] });
+            const model = ModelMix.new({ config: { retry: { retries: 0 } } })
+                .deepseekV41Flash({
+                    mix: { deepseek: true, fireworks: true, openrouter: true },
+                    config: { apiKey: 'test-key' }
+                }).addText('Hello');
+
+            expect(await model.message()).to.equal('fallback');
+            expect(native.isDone()).to.equal(true);
+            expect(fireworks.isDone()).to.equal(true);
+            expect(openrouter.isDone()).to.equal(true);
+        });
+
+        for (const [effort, level] of [[0, undefined], [20, 'low'], [60, 'high'], [100, 'max'], [-1, undefined]]) {
+            it(`sends native DeepSeek effort ${effort} and reads native cache usage`, async () => {
+                const scope = nock('https://api.deepseek.com', {
+                    reqheaders: { authorization: 'Bearer native-test-key' }
+                })
+                    .post('/chat/completions', body => {
+                        expect(body.model).to.equal('deepseek-flash');
+                        expect(body.reasoning_effort).to.equal(level);
+                        expect(body.thinking).to.deep.equal(effort === -1
+                            ? undefined
+                            : { type: effort === 0 ? 'disabled' : 'enabled' });
+                        return true;
+                    })
+                    .reply(200, {
+                        choices: [{ message: { role: 'assistant', content: 'ok', reasoning_content: 'Reasoning' } }],
+                        usage: { prompt_tokens: 1000, completion_tokens: 100, prompt_cache_hit_tokens: 400 }
+                    });
+                const model = ModelMix.new().deepseekV41Flash({
+                    mix: { deepseek: true, openrouter: false },
+                    config: { apiKey: 'native-test-key', effort }
+                }).addText('Hello');
+
+                expect(model.models).to.have.length(1);
+                expect(model.models[0].provider).to.be.instanceOf(MixDeepSeek);
+                expect(await model.message()).to.equal('ok');
+                expect(scope.isDone()).to.equal(true);
+                expect(model.lastRaw.tokens).to.include({ input: 1000, cached: 400, output: 100 });
+                expect(model.lastRaw.tokens.cost).to.be.closeTo(0.0003024, 1e-12);
+            });
+        }
+
+        it('preserves native reasoning across tool continuation and later turns', async () => {
+            const assistantMessage = {
+                role: 'assistant', content: null, reasoning_content: 'Use the lookup tool.',
+                tool_calls: [{ id: 'call_lookup', type: 'function', function: { name: 'lookup', arguments: '{}' } }]
+            };
+            const scope = nock('https://api.deepseek.com')
+                .post('/chat/completions')
+                .reply(200, { choices: [{ message: assistantMessage }] })
+                .post('/chat/completions', body => {
+                    expect(body.messages.find(message => message.role === 'assistant')).to.deep.equal(assistantMessage);
+                    expect(body.messages.find(message => message.role === 'tool')).to.include({ tool_call_id: 'call_lookup' });
+                    return true;
+                })
+                .reply(200, { choices: [{ message: { role: 'assistant', content: 'Found', reasoning_content: 'Lookup complete.' } }] })
+                .post('/chat/completions', body => {
+                    expect(body.messages.filter(message => message.role === 'assistant').map(message => message.reasoning_content))
+                        .to.deep.equal(['Use the lookup tool.', 'Lookup complete.']);
+                    return true;
+                })
+                .reply(200, { choices: [{ message: { role: 'assistant', content: 'Done' } }] });
+            const model = ModelMix.new().deepseekV41Flash({
+                mix: { deepseek: true, openrouter: false },
+                config: { apiKey: 'native-test-key' }
+            }).addTool({
+                name: 'lookup', description: 'Look up a value.',
+                inputSchema: { type: 'object', properties: {} }
+            }, () => 'value').addText('Look it up');
+
+            expect(await model.message()).to.equal('Found');
+            model.addText('Continue');
+            expect(await model.message()).to.equal('Done');
+            expect(scope.isDone()).to.equal(true);
+        });
+
+        it('streams native text without including empty reasoning or usage deltas', async () => {
+            const chunks = [
+                { choices: [{ delta: { reasoning_content: 'Reasoning' } }] },
+                { choices: [{ delta: { content: 'Hello' } }] },
+                { choices: [], usage: { prompt_tokens: 1000, completion_tokens: 100, prompt_cache_hit_tokens: 400 } }
+            ];
+            const scope = nock('https://api.deepseek.com')
+                .post('/chat/completions', body => body.stream === true)
+                .reply(200, chunks.map(chunk => `data: ${JSON.stringify(chunk)}\n\n`).join('') + 'data: [DONE]\n\n', {
+                    'content-type': 'text/event-stream'
+                });
+            const model = ModelMix.new().deepseekV41Flash({
+                mix: { deepseek: true, openrouter: false },
+                config: { apiKey: 'native-test-key' }
+            }).addText('Hello');
+            const deltas = [];
+            const result = await model.stream(({ delta }) => deltas.push(delta));
+
+            expect(result.message).to.equal('Hello');
+            expect(deltas.join('')).to.equal('Hello');
+            expect(result.tokens.cached).to.equal(400);
+            expect(scope.isDone()).to.equal(true);
+        });
+
+        it('uses only Fireworks when selected and accounts for its cached input pricing', async () => {
+            const scope = nock('https://api.fireworks.ai')
+                .post('/inference/v1/chat/completions', body => {
+                    expect(body.model).to.equal('accounts/fireworks/models/deepseek-v4p1-flash');
+                    expect(body.reasoning_effort).to.equal('max');
+                    expect(body.thinking).to.deep.equal({ type: 'enabled' });
+                    expect(body.temperature).to.equal(0.5);
+                    return true;
+                })
+                .reply(200, {
+                    choices: [{ message: { content: 'ok' } }],
+                    usage: {
+                        prompt_tokens: 1000,
+                        completion_tokens: 100,
+                        prompt_tokens_details: { cached_tokens: 400 }
+                    }
+                });
+            const model = ModelMix.new().deepseekV41Flash({
+                mix: { fireworks: true, openrouter: false },
+                config: { effort: 100 },
+                options: { temperature: 0.5 }
+            }).addText('Hello');
+
+            expect(model.models).to.have.length(1);
+            expect(model.models[0].provider).to.be.instanceOf(MixFireworks);
+            expect(await model.message()).to.equal('ok');
+            expect(scope.isDone()).to.equal(true);
+            expect(model.lastRaw.tokens).to.include({ input: 1000, cached: 400, output: 100 });
+            expect(model.lastRaw.tokens.cost).to.be.closeTo(0.0002008, 1e-12);
+        });
+
+        it('falls back from Fireworks to OpenRouter when both are enabled', async () => {
+            const fireworks = nock('https://api.fireworks.ai')
+                .post('/inference/v1/chat/completions')
+                .reply(503, { error: { message: 'Unavailable' } });
+            const openrouter = nock('https://openrouter.ai')
+                .post('/api/v1/chat/completions', body => body.model === 'deepseek/deepseek-v4.1-flash')
+                .reply(200, { choices: [{ message: { content: 'fallback' } }] });
+            const model = ModelMix.new({ config: { retry: { retries: 0 } } })
+                .deepseekV41Flash({ mix: { fireworks: true, openrouter: true } })
+                .addText('Hello');
+
+            expect(model.models.map(({ key }) => key)).to.deep.equal([
+                'accounts/fireworks/models/deepseek-v4p1-flash',
+                'deepseek/deepseek-v4.1-flash'
+            ]);
+            expect(await model.message()).to.equal('fallback');
+            expect(fireworks.isDone()).to.equal(true);
+            expect(openrouter.isDone()).to.equal(true);
+        });
+
+        for (const [effort, level] of [[0, null], [20, 'low'], [60, 'high'], [100, 'max'], [-1, undefined]]) {
+            it(`sends chain effort ${effort} and accounts for cached input`, async () => {
+                const scope = nock('https://openrouter.ai')
+                    .post('/api/v1/chat/completions', body => {
+                        expect(body.model).to.equal('deepseek/deepseek-v4.1-flash');
+                        expect(body.reasoning_effort).to.equal(level || undefined);
+                        expect(body.thinking).to.deep.equal(level === undefined
+                            ? undefined
+                            : { type: level === null ? 'disabled' : 'enabled' });
+                        return true;
+                    })
+                    .reply(200, {
+                        choices: [{ message: { role: 'assistant', content: 'ok' }, finish_reason: 'stop' }],
+                        usage: {
+                            prompt_tokens: 1000,
+                            completion_tokens: 100,
+                            prompt_tokens_details: { cached_tokens: 400 }
+                        }
+                    });
+
+                const model = ModelMix.new().chain(`deepseekV41Flash@${effort}`).addText('Hello');
+                expect(await model.message()).to.equal('ok');
+                expect(scope.isDone()).to.equal(true);
+                expect(model.lastRaw.tokens).to.include({ input: 1000, cached: 400, output: 100 });
+                expect(model.lastRaw.tokens.cost).to.be.closeTo(0.000156, 1e-12);
+            });
+        }
+    });
+
     it('should register Fireworks DeepSeek V4 Pro by default', () => {
         const model = ModelMix.new();
         model.deepseekV4Pro({ mix: { fireworks: true, openrouter: false } });

package/test/fallback.test.js

@@ -13,6 +13,63 @@ const {
 } = require('../index.js');
 
 describe('Provider Fallback Chain Tests', () => {
+
+    describe('Interrupted provider responses', () => {
+        const timeout = {
+            id: 'generation-timeout',
+            provider: 'Novita',
+            error: { code: 504, message: 'Upstream idle timeout exceeded', metadata: { error_type: 'timeout' } },
+            choices: [{ finish_reason: 'error', message: { content: '' } }]
+        };
+
+        it('rejects HTTP 200 error bodies with their status and generation details', async () => {
+            sinon.stub(global, 'fetch').resolves(new Response(JSON.stringify(timeout), { status: 200 }));
+            const model = ModelMix.new().deepseekV41Flash().addText('test');
+            let failure;
+            try { await model.raw(); } catch (error) { failure = error; }
+            expect(failure).to.include({ statusCode: 504, message: timeout.error.message });
+            expect(failure.details).to.include({ id: timeout.id, provider: 'Novita' });
+            expect(failure.details.error.metadata.error_type).to.equal('timeout');
+        });
+
+        it('retries HTTP 200 provider errors only under the configured policy', async () => {
+            const fetch = sinon.stub(global, 'fetch');
+            fetch.onFirstCall().resolves(new Response(JSON.stringify(timeout)));
+            fetch.onSecondCall().resolves(new Response(JSON.stringify({ choices: [{ finish_reason: 'stop', message: { content: 'recovered' } }] })));
+            const model = ModelMix.new({ config: { retry: { enabled: true, retries: 1, baseDelayMs: 0, maxDelayMs: 0 } } }).deepseekV41Flash().addText('test');
+            expect((await model.raw()).message).to.equal('recovered');
+            expect(fetch.callCount).to.equal(2);
+        });
+
+        it('falls back when a provider returns only reasoning without completing', async () => {
+            const fetch = sinon.stub(global, 'fetch');
+            fetch.onFirstCall().resolves(new Response(JSON.stringify({ choices: [{ finish_reason: null, message: { content: '', reasoning: 'partial' } }] })));
+            fetch.onSecondCall().resolves(new Response(JSON.stringify({ choices: [{ finish_reason: 'stop', message: { content: 'fallback' } }] })));
+            const model = ModelMix.new().deepseekV41Flash().gpt5mini().addText('test');
+            expect((await model.raw()).message).to.equal('fallback');
+            expect(fetch.callCount).to.equal(2);
+        });
+
+        it('rejects a streaming timeout instead of returning partial output', async () => {
+            const chunks = [
+                { choices: [{ delta: { content: 'partial' } }] },
+                timeout
+            ];
+            sinon.stub(global, 'fetch').resolves(new Response(chunks.map(chunk => `data: ${JSON.stringify(chunk)}\n\n`).join(''), { headers: { 'content-type': 'text/event-stream' } }));
+            const model = ModelMix.new().deepseekV41Flash().addText('test');
+            let failure;
+            try { await model.stream(() => {}); } catch (error) { failure = error; }
+            expect(failure).to.include({ statusCode: 504, message: timeout.error.message });
+        });
+
+        it('rejects an abruptly ended stream even after some text arrived', async () => {
+            sinon.stub(global, 'fetch').resolves(new Response('data: {"choices":[{"delta":{"content":"partial"},"finish_reason":null}]}\n\n'));
+            let failure;
+            try { await ModelMix.new().deepseekV41Flash().addText('test').stream(() => {}); } catch (error) { failure = error; }
+            expect(failure).to.include({ statusCode: 502 });
+            expect(failure.message).to.include('without completing');
+        });
+    });
     
     // Setup test hooks
     if (global.setupTestHooks) {

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/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);
     });