modelmix 4.4.24 → 4.4.28

package/README.md

@@ -159,7 +159,7 @@ Here's a comprehensive list of available methods:
 | `grok41[think]()`  | Grok       | grok-4-1-fast                  | [\$0.20 / \$0.50][6]       |
 | `deepseekV32()`    | Fireworks  | fireworks/models/deepseek-v3p2  | [\$0.56 / \$1.68][10]      |
 | `GLM47()`          | Fireworks  | fireworks/models/glm-4p7        | [\$0.55 / \$2.19][10]      |
-| `minimaxM25()`     | MiniMax    | MiniMax-M2.5                   | [\$0.30 / \$1.20][9]       |
+| `minimaxM27()`     | MiniMax    | MiniMax-M2.7                   | [\$0.30 / \$1.20][9]       |
 | `sonar()`          | Perplexity | sonar                          | [\$1.00 / \$1.00][4]       |
 | `sonarPro()`       | Perplexity | sonar-pro                      | [\$3.00 / \$15.00][4]      |
 | `hermes3()`        | Lambda     | Hermes-3-Llama-3.1-405B-FP8    | [\$0.80 / \$0.80][8]       |

package/demo/json.js

@@ -2,7 +2,7 @@ import { ModelMix } from '../index.js';
 try { process.loadEnvFile(); } catch {}
 
 const model = await ModelMix.new({ options: { max_tokens: 10000 }, config: { debug: 3 } })
-    .sonnet46()
+    .gpt51()
     // .gptOss()
     // .scout({ config: { temperature: 0 } })    
     // .o4mini()

package/demo/minimax.js

@@ -5,7 +5,7 @@ const main = async () => {
 
     const bot = ModelMix
         .new({ config: { debug: 3 } })
-        .minimaxM25()
+        .minimaxM27()
         .setSystem('You are a helpful assistant.');
 
     bot.addText('What is the capital of France?');

package/index.js

@@ -61,7 +61,9 @@ const MODEL_PRICING = {
     // MiniMax
     'MiniMax-M2.1': [0.30, 1.20],
     'MiniMax-M2.5': [0.30, 1.20],
+    'MiniMax-M2.7': [0.30, 1.20],
     'fireworks/minimax-m2p5': [0.30, 1.20],
+    'minimax/minimax-m2.7': [0.30, 1.20],
     // Perplexity
     'sonar': [1.00, 1.00],
     'sonar-pro': [3.00, 15.00],
@@ -478,6 +480,12 @@ class ModelMix {
         return this.attach('MiniMax-M2-Stable', new MixMiniMax({ options, config }));
     }
 
+    minimaxM27({ options = {}, config = {}, mix = { openrouter: true, minimax: true } } = {}) {
+        if (mix.openrouter) return this.attach('minimax/minimax-m2.7', new MixOpenRouter({ options, config }));
+        if (mix.minimax) return this.attach('MiniMax-M2.7', new MixMiniMax({ options, config }));
+        return this;
+    }  
+
     deepseekV32({ options = {}, config = {}, mix = {} } = {}) {
         mix = { ...this.mix, ...mix };
         if (mix.fireworks) this.attach('accounts/fireworks/models/deepseek-v3p2', new MixFireworks({ options, config }));
@@ -1566,7 +1574,7 @@ class MixOpenAIResponses extends MixOpenAI {
         }
 
         const responsesUrl = this.config.url.replace('/chat/completions', '/responses');
-        const request = MixOpenAIResponses.buildResponsesRequest(options);
+        const request = MixOpenAIResponses.buildResponsesRequest(options, config);
         const response = await axios.post(responsesUrl, request, {
             headers: this.headers
         });
@@ -1574,16 +1582,38 @@ class MixOpenAIResponses extends MixOpenAI {
         return MixOpenAIResponses.processResponsesResponse(response);
     }
 
-    static buildResponsesRequest(options = {}) {
+    static buildResponsesRequest(options = {}, config = {}) {
+        const input = MixOpenAIResponses.messagesToResponsesInput(options.messages);
+        if (config.system) {
+            input.unshift({ role: 'developer', content: [{ type: 'input_text', text: config.system }] });
+        }
         const request = {
             model: options.model,
-            input: MixOpenAIResponses.messagesToResponsesInput(options.messages),
+            input,
             stream: false
         };
 
         if (options.reasoning_effort) request.reasoning = { effort: options.reasoning_effort };
         if (options.verbosity) request.text = { verbosity: options.verbosity };
 
+        if (options.response_format) {
+            const rf = options.response_format;
+            let format;
+            if (rf.type === 'json_schema' && rf.json_schema) {
+                format = {
+                    type: 'json_schema',
+                    name: rf.json_schema.name || 'response',
+                    strict: true,
+                    schema: rf.json_schema.schema
+                };
+            } else if (rf.type) {
+                format = { type: rf.type };
+            }
+            if (format) {
+                request.text = { ...request.text, format };
+            }
+        }
+
         if (typeof options.max_completion_tokens === 'number') {
             request.max_output_tokens = options.max_completion_tokens;
         } else if (typeof options.max_tokens === 'number') {

package/package.json

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

package/test/json.test.js

@@ -376,6 +376,42 @@ describe('JSON Schema and Structured Output Tests', () => {
             expect(result.countries[0]).to.have.property('capital');
         });
 
+        it('should send JSON mode and system instructions in Responses API request', async () => {
+            const example = {
+                countries: [{
+                    name: 'France',
+                    capital: 'Paris'
+                }]
+            };
+
+            model.gpt51().addText('Name and capital of 3 South American countries.');
+
+            let capturedBody;
+            nock('https://api.openai.com')
+                .post('/v1/responses', (body) => {
+                    capturedBody = body;
+                    return true;
+                })
+                .reply(200, testUtils.createMockResponse('openai-responses', JSON.stringify({
+                    countries: [
+                        { name: 'Argentina', capital: 'BUENOS AIRES' },
+                        { name: 'Brazil', capital: 'BRASILIA' },
+                        { name: 'Colombia', capital: 'BOGOTA' }
+                    ]
+                })));
+
+            const result = await model.json(example);
+
+            expect(result.countries).to.be.an('array');
+            expect(result.countries).to.have.length(3);
+            expect(capturedBody).to.be.an('object');
+            expect(capturedBody.text).to.be.an('object');
+            expect(capturedBody.text.format).to.deep.equal({ type: 'json_object' });
+            expect(capturedBody.input).to.be.an('array').that.is.not.empty;
+            expect(capturedBody.input[0].role).to.equal('developer');
+            expect(capturedBody.input[0].content[0].text).to.include('JSON');
+        });
+
         it('should handle complex nested JSON schema', async () => {
             const example = {
                 user: {