modelmix 5.1.19 → 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/effort.test.js

@@ -73,6 +73,15 @@ describe('Unified effort scale', () => {
             expect(mapEffort('openai', 100)).to.deep.equal({ reasoning_effort: 'xhigh' });
         });
 
+        it('clamps GPT-6 Astra effort to its supported range', () => {
+            for (const key of ['gpt-6-astra', 'openai/gpt-6-astra']) {
+                for (const [effort, level] of [[0, 'low'], [39, 'low'], [40, 'medium'], [60, 'high'], [80, 'xhigh'], [99, 'xhigh'], [100, 'max']]) {
+                    expect(mapEffort('openai', effort, key)).to.deep.equal({ reasoning_effort: level });
+                }
+                expect(mapEffort('openai', -1, key)).to.equal(null);
+            }
+        });
+
         it('maps GPT-5.6 maximum unified effort to max', () => {
             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']) {

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) {
@@ -57,6 +114,7 @@ describe('Provider Fallback Chain Tests', () => {
         it('should register every supported OpenAI text shortcut with its OpenRouter fallback', () => {
             expect(ModelMix.new().mix.openrouter).to.equal(false);
             const shortcuts = [
+                ['gpt6astra', 'gpt-6-astra', 'openai/gpt-6-astra', MixOpenAIResponses],
                 ['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],
@@ -101,13 +159,13 @@ describe('Provider Fallback Chain Tests', () => {
         });
 
         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 official = ModelMix.new().chain('gpt6astra@100');
+            expect(official.models.map(({ key }) => key)).to.deep.equal(['gpt-6-astra']);
 
-            const routed = ModelMix.new({ mix: { openrouter: true } }).chain('gpt56sol@100');
+            const routed = ModelMix.new({ mix: { openrouter: true } }).chain('gpt6astra@100');
             expect(routed.models.map(({ key }) => key)).to.deep.equal([
-                'gpt-5.6-sol',
-                'openai/gpt-5.6-sol'
+                'gpt-6-astra',
+                'openai/gpt-6-astra'
             ]);
             expect(routed.models.map(({ provider }) => provider.config.effort)).to.deep.equal([100, 100]);
         });
@@ -140,6 +198,40 @@ describe('Provider Fallback Chain Tests', () => {
             expect(openRouterRequest).to.not.have.property('temperature');
         });
 
+        it('should fallback from the official GPT-6 Astra endpoint to OpenRouter', async () => {
+            let openRouterRequest;
+            model.effort(100).gpt6astra({ mix: { openrouter: true } }).addText('Hello');
+
+            nock('https://api.openai.com')
+                .post('/v1/responses', body => {
+                    expect(body.model).to.equal('gpt-6-astra');
+                    expect(body.reasoning).to.deep.equal({ effort: 'max' });
+                    expect(body.max_output_tokens).to.equal(8192);
+                    expect(body).to.not.have.property('temperature');
+                    return true;
+                })
+                .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-6 Astra through OpenRouter!'
+                        }
+                    }]
+                });
+
+            expect(await model.message()).to.equal('Hello from GPT-6 Astra through OpenRouter!');
+            expect(openRouterRequest.model).to.equal('openai/gpt-6-astra');
+            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');
 

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 })],