modelmix 4.6.6 → 4.6.7

package/demo/opus5.js

@@ -0,0 +1,23 @@
+import { ModelMix } from '../index.js';
+try { process.loadEnvFile(); } catch {}
+
+
+const mmix = new ModelMix({
+    config: {
+        debug: 3,
+    }
+});
+
+console.log("\n" + '--------| opus5() |--------');
+
+const opus = mmix.opus5();
+opus.addText("Explain quantum entanglement in simple terms.");
+const response = await opus.message();
+console.log(response);
+
+console.log("\n" + '--------| opus5think() |--------');
+
+const opusThink = mmix.new().opus5think();
+opusThink.addText("A bat and a ball cost $1.10 in total. The bat costs $1.00 more than the ball. How much does the ball cost?");
+const thinkResponse = await opusThink.raw();
+console.log(thinkResponse);

package/index.js

@@ -887,13 +887,21 @@ class ModelMix {
         return input;
     }
 
+    static hasToolInteraction(message) {
+        if (!message) return false;
+        if (message.role === 'tool' || message.tool_calls || message.tool_call_id) return true;
+        // Anthropic-native assistant turns store tool_use blocks in content (no tool_calls).
+        if (message.role === 'assistant' && Array.isArray(message.content)) {
+            return message.content.some(block => block?.type === 'tool_use');
+        }
+        return false;
+    }
+
     groupByRoles(messages) {
         return messages.reduce((acc, currentMessage, index) => {
             // Don't group tool messages or assistant messages with tool_calls
             // Each tool response must be separate with its own tool_call_id
-            const shouldNotGroup = currentMessage.role === 'tool' ||
-                currentMessage.tool_calls ||
-                currentMessage.tool_call_id;
+            const shouldNotGroup = ModelMix.hasToolInteraction(currentMessage);
 
             if (index === 0 || currentMessage.role !== messages[index - 1].role || shouldNotGroup) {
                 // acc.push({
@@ -939,7 +947,7 @@ class ModelMix {
             // backtrack to include the full sequence (user → assistant/tool_calls → tool results)
             while (sliceStart > 0 && sliceStart < this.messages.length) {
                 const msg = this.messages[sliceStart];
-                if (msg.role === 'tool' || (msg.role === 'assistant' && msg.tool_calls)) {
+                if (ModelMix.hasToolInteraction(msg)) {
                     sliceStart--;
                 } else {
                     break;
@@ -1108,7 +1116,8 @@ class ModelMix {
                                 this.messages.push({
                                     role: "assistant", content: [{
                                         type: "thinking",
-                                        thinking: result.think,
+                                        // Empty string is valid (Anthropic display: "omitted").
+                                        thinking: result.think ?? '',
                                         signature: result.signature
                                     }]
                                 });
@@ -1184,7 +1193,8 @@ class ModelMix {
                             this.messages.push({
                                 role: "assistant", content: [{
                                     type: "thinking",
-                                    thinking: result.think,
+                                    // Empty string is valid (Anthropic display: "omitted").
+                                    thinking: result.think ?? '',
                                     signature: result.signature
                                 }, {
                                     type: "text",
@@ -2229,10 +2239,10 @@ class MixAnthropic extends MixCustom {
         const filteredMessages = [];
         for (let i = 0; i < messages.length; i++) {
             if (messages[i].role === 'tool') {
-                // Check if there's a preceding assistant message with tool_calls
+                // Preceding assistant may use OpenAI tool_calls or Anthropic tool_use blocks.
                 let foundToolCall = false;
                 for (let j = i - 1; j >= 0; j--) {
-                    if (messages[j].role === 'assistant' && messages[j].tool_calls) {
+                    if (ModelMix.hasToolInteraction(messages[j]) && messages[j].role === 'assistant') {
                         foundToolCall = true;
                         break;
                     }
@@ -2356,12 +2366,22 @@ class MixAnthropic extends MixCustom {
         throw new Error(`Anthropic content blocks are missing .text (stop_reason: ${stopReason ?? 'unknown'}, content_types: ${contentTypes}).`);
     }
 
+    static extractThinkingBlock(data) {
+        const content = Array.isArray(data?.content) ? data.content : [];
+        return content.find(block => block?.type === 'thinking') || null;
+    }
+
     static extractThink(data) {
-        return data.content[0]?.thinking || null;
+        const block = MixAnthropic.extractThinkingBlock(data);
+        // Preserve empty string: display "omitted" returns thinking: "" with a signature.
+        return typeof block?.thinking === 'string' ? block.thinking : null;
     }
 
     static extractSignature(data) {
-        return data.content[0]?.signature || null;
+        const block = MixAnthropic.extractThinkingBlock(data);
+        return typeof block?.signature === 'string' && block.signature
+            ? block.signature
+            : null;
     }
 
     static extractTokens(data) {
@@ -2383,13 +2403,18 @@ class MixAnthropic extends MixCustom {
     }
 
     processResponse(response) {
+        const data = response.data;
         return {
-            message: MixAnthropic.extractMessage(response.data),
-            think: MixAnthropic.extractThink(response.data),
-            toolCalls: MixAnthropic.extractToolCalls(response.data),
-            tokens: MixAnthropic.extractTokens(response.data),
-            response: response.data,
-            signature: MixAnthropic.extractSignature(response.data)
+            message: MixAnthropic.extractMessage(data),
+            think: MixAnthropic.extractThink(data),
+            toolCalls: MixAnthropic.extractToolCalls(data),
+            tokens: MixAnthropic.extractTokens(data),
+            response: data,
+            signature: MixAnthropic.extractSignature(data),
+            // Replay Anthropic content blocks verbatim (including empty thinking).
+            assistantMessage: Array.isArray(data?.content)
+                ? { role: 'assistant', content: data.content }
+                : undefined
         }
     }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "modelmix",
-  "version": "4.6.6",
+  "version": "4.6.7",
   "description": "🧬 Reliable interface with automatic fallback for AI LLMs.",
   "main": "index.js",
   "repository": {

package/test/anthropic.test.js

@@ -81,4 +81,110 @@ describe('Anthropic Model Registration Tests', () => {
             budget_tokens: 1638
         });
     });
+
+    describe('Thinking block extraction', () => {
+        it('should preserve empty thinking text from display omitted', () => {
+            const data = {
+                content: [{
+                    type: 'thinking',
+                    thinking: '',
+                    signature: 'sig-omitted'
+                }, {
+                    type: 'text',
+                    text: 'Hello'
+                }]
+            };
+
+            expect(MixAnthropic.extractThink(data)).to.equal('');
+            expect(MixAnthropic.extractSignature(data)).to.equal('sig-omitted');
+        });
+
+        it('should extract summarized thinking text', () => {
+            const data = {
+                content: [{
+                    type: 'thinking',
+                    thinking: 'Step by step...',
+                    signature: 'sig-summarized'
+                }, {
+                    type: 'text',
+                    text: 'Answer'
+                }]
+            };
+
+            expect(MixAnthropic.extractThink(data)).to.equal('Step by step...');
+            expect(MixAnthropic.extractSignature(data)).to.equal('sig-summarized');
+        });
+
+        it('should return null when thinking block is missing', () => {
+            const data = {
+                content: [{ type: 'text', text: 'Hello' }]
+            };
+
+            expect(MixAnthropic.extractThink(data)).to.equal(null);
+            expect(MixAnthropic.extractSignature(data)).to.equal(null);
+        });
+
+        it('should persist Anthropic content blocks as assistantMessage', () => {
+            const content = [{
+                type: 'thinking',
+                thinking: '',
+                signature: 'sig-omitted'
+            }, {
+                type: 'text',
+                text: 'Hello'
+            }];
+            const provider = new MixAnthropic();
+            const result = provider.processResponse({ data: { content, usage: {} } });
+
+            expect(result.think).to.equal('');
+            expect(result.signature).to.equal('sig-omitted');
+            expect(result.assistantMessage).to.deep.equal({
+                role: 'assistant',
+                content
+            });
+        });
+
+        it('should keep tool_result after native Anthropic tool_use assistantMessage', () => {
+            // processResponse stores assistant content as Anthropic blocks (tool_use),
+            // not OpenAI-style tool_calls. convertMessages must still pair tool results.
+            const toolUseId = 'toolu_01TestToolUseId';
+            const converted = MixAnthropic.convertMessages([
+                { role: 'user', content: [{ type: 'text', text: 'What time is it?' }] },
+                {
+                    role: 'assistant',
+                    content: [{
+                        type: 'tool_use',
+                        id: toolUseId,
+                        name: 'get_current_time',
+                        input: {}
+                    }]
+                },
+                {
+                    role: 'tool',
+                    tool_call_id: toolUseId,
+                    name: 'get_current_time',
+                    content: '2026-07-30T12:00:00Z'
+                }
+            ]);
+
+            expect(converted).to.have.length(3);
+            expect(converted[1]).to.deep.equal({
+                role: 'assistant',
+                content: [{
+                    type: 'tool_use',
+                    id: toolUseId,
+                    name: 'get_current_time',
+                    input: {}
+                }]
+            });
+            expect(converted[2]).to.deep.equal({
+                role: 'user',
+                content: [{
+                    type: 'tool_result',
+                    tool_use_id: toolUseId,
+                    content: '2026-07-30T12:00:00Z'
+                }]
+            });
+        });
+    });
 });

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() }
             ];